It answers from the record, or it says nothing.
You give it a body of text. It answers only out of that text, word for word — and when what you type does not match anything it holds, it refuses instead of producing something plausible. This page explains how, in the order the machine actually does it, and states plainly what it cannot do.
You give it a body of text. It answers using only that text, word for word. If what you type is not in that text, it says nothing. It does not make something up to fill the gap. This page shows how it works, one step at a time. It also says plainly what it cannot do.
There are three answers, and one of them is no.
Everything below exists to produce one of three . Each example here was run against the same loaded text — a 15,564-byte story, the only thing this field has ever been given — and the words, the verdict and the two numbers are copied from that run. Pick one.
Everything below leads to one of three . Each example was run against the same loaded text. That text is one story of 15,564 bytes. It is the only thing this field has ever been given. The words, the verdict and the two numbers are copied straight from that run. Pick one.
In the beginning, before light and shadow,
Everything and Nothing were. In the silence, through the depths, they were
leftover 0.0000 · novelty 0.1014 · twelve words, each one a position in the text, not a generated token
the connection between them upon they thought as more knew it
what had been his will, within the unfolding of form. was unfolding.
leftover 0.0000 · novelty 0.4421 · it still answers, and it tells you the arrangement is not one it holds
The mitochondrion is the powerhouse of the cell.
[ nothing rings ] — no text is returned
leftover 0.5744 · novelty 0.2655 · the sentence is ordinary English and every byte in it is known; the arrangement is not in the record, so there is nothing to say
All three readings above are taken with a trailing space on the prompt. That is not a trick: the shipped front end appends one to every prompt that does not already end in a space (Ω/index.html · listen(ω, p.endsWith(' ') ? p : p + ' ', 14)), because a word boundary is what the index is keyed on. Called from the library without it, the first example comes back not mine at leftover 0.7196 and the second not mine at 0.7090; the third stays not mine but reads 0.8410 / 0.3624 instead. If you reproduce these by hand, type the space.
All three readings above have a space at the end of the prompt. That is not a trick. The front end that ships adds one to every prompt that does not already end in a space, because the index is keyed on word boundaries. Call the library directly without it and the first example comes back not mine, the second comes back not mine as well, and the third stays not mine but with different numbers. If you are reproducing these by hand, type the space.
Why the third one is the point
A retrieval system that cannot refuse will always return its closest match, and a closest match to a question the record does not answer is a fabrication with a confidence score attached. The refusal here is not a fallback for when the search fails, and there is no confidence threshold in it that anybody typed.
A search tool that cannot say no will always hand back its closest match. If the record does not hold the answer, that closest match is made up. It just arrives with a score beside it. Here, saying no is not a backup plan for a failed search. And nobody typed in a cut-off score.
The mechanism is this. At the moment the text is loaded, the field measures two reference points on its own material: what a reading looks like when it is answering something it holds, and what a reading looks like when it is handed its own bytes with the order destroyed. Every later reading is placed between those two. Land nearer the first and the answer is mine; nearer the second and there is nothing to say, and it says nothing. The third example above is ordinary English in which every single byte is one the field holds — and it still refuses, because the comparison is not on the bytes but on the arrangement. The rest of this page is how that reading is computed and where the two reference points come from.
Here is how it works. The text is loaded. At that moment the field measures two reference points on its own material. The first is what a reading looks like when it answers something it holds. The second is what a reading looks like when it is handed its own bytes with the order destroyed. Every later reading is placed between those two points. Land nearer the first and the answer is mine. Land nearer the second and there is nothing to say, so it says nothing. Now look at the third example again. It is ordinary English. Every single byte in it is a byte the field holds. It still refuses. The check is not on the bytes. It is on the order they sit in. The rest of this page shows how that reading is worked out, and where the two reference points come from.
Bytes in, one pass, no gradients — and it is still a fitted model.
Bytes in, one pass. And it is still a fitted model.
There is no training loop, no pretrained weights, no dependencies and no accelerator. There is a single pass over the text that produces a positive-PMI spectral embedding of the 256 byte values, and then a purely geometric pipeline on top of it. Both halves of that sentence matter: fitted in one pass and fitted. The embedding is derived from this and is different for every corpus.
There is no training loop. There are no borrowed weights, no outside code and no special chip. There is one pass over the text. That pass works out where each of the 256 byte values sits. Everything after it is geometry. Both halves of this matter: it is fitted in one pass, and it is fitted. The map of the bytes is built from this , and it comes out different for every corpus.
The engine is one file. As shipped it is 27,029 bytes of source, 10,466 gzipped, and it runs unchanged in Node and in a browser because it never touches a Buffer.
The engine is one file. It is 27,029 bytes of source, or 10,466 bytes zipped. The same file runs in Node and in a browser, with nothing changed.
Each step below names the function that does it, so the chain can be followed in the code afterwards.
Each step below names the function that does it. So you can follow the same chain in the code.
1 bytes(src) one char, one byte. latin1 in, no
decoding. 66 distinct values here
2 company(src) 256x256 co-occurrence. for each
position, look 1 2 3 5 8 13 21 bytes
either side, weight those seven arms
φ¹ … φ⁷
3 aboveNull(C) positive pointwise mutual information
log(v·T / row·col), negatives clamped
to 0, then symmetrised
4 axes(M,64,30) subspace iteration. 30 rounds of
multiply-then-Gram-Schmidt from a fixed
seed, then one Rayleigh quotient per axis
for its eigenvalue. 30 is a budget, not a
convergence test — nothing anywhere
checks whether the axes settled
5 EN 256 byte positions, 256 wide.
64 axes carry signal, 192 are zero
6 tile(EN,b) divide each of the 256 numbers by
the mean magnitude, round, clamp to
-3…+3. one byte -> 256 small integers
7 faces(EN,b) split those cells three ways by sign
and sum each group as a phasor at
angle 2πjφ. three (radius, angle) pairs
8 τ(pts) recursive four-way split of the disc,
radial x angular. each level appends one
symbol. stops below the null. -> address
9 this.trie index every word start in the corpus
under the 12 preceding address symbols.
9,693 nodes here
10 read(ctx) walk the trie to a candidate pool,
score it from ten directions, return
two numbers and one word
11 hear(ctx) compare those two numbers against
four poles the field measured on its
own material. -> one of three verdicts
What that produced on the loaded text
| Quantity | Value | Where it comes from |
|---|---|---|
| Corpus | 15,564 bytes | Δ/V·001, one story, the only material fed |
| Distinct byte values | 66 | the alphabet the field actually has |
| Indexed states | 2,919 | word starts — every position preceded by whitespace |
| Trie nodes | 9,693 | prefix index over 12 address symbols |
| Read window | 8 bytes | log(N/2πe) gives 5; floored to 8 by liftoff, below |
| Candidate pool target | 64 | max(64, exp(log N − W)) |
| Feed time | 0.9 s | one pass, one core, no accelerator |
Steps 6 through 9 are where the interesting geometry is, and they get a section each below.
Steps 6 through 9 hold the interesting geometry. Each one gets its own section below.
One cell, three faces.
After step 6 a byte is 256 small integers between −3 and +3. A cell is not a number the machine keeps; it is a number the machine sorts. Positive cells go to one face, negative cells to another, and cells that rounded to zero go to a third.
After step 6, a byte is 256 small whole numbers. Each one runs from minus 3 to plus 3. A cell is not a number the machine keeps. It is a number the machine sorts. Positive cells go to one face. Negative cells go to a second. Cells that rounded to zero go to a third.
Three, not two, because zero is not an absence here. Only 64 of the 256 axes are ever filled by the embedding; the other 192 quantise to zero on every byte, and those empty dimensions are classified into the null face with unit weight. The null face is a real channel carrying most of the tile — across the 66 live bytes, a mean of 78.72% of cells are null.
Three faces, not two, because zero is not nothing here. The map only ever fills 64 of the 256 axes. The other 192 come out as zero on every byte. Those empty slots are put in the null face, each counted once. So the null face is a real channel, and it carries most of the . Across the 66 live bytes, a mean of 78.72% of cells are null.
Dropping them is the obvious optimisation and it was tried. Cutting the from 256 dimensions to 64 took next-word reading on stored material from 0.985 to 0.316 and novelty detection from 0.980 AUC to 0.649, a result recorded in the code beside the constant.
Dropping the null cells is the obvious speed-up, and it was tried. Cutting the tile from 256 slots to 64 hurt badly. Next-word reading on stored material fell from 0.985 to 0.316. Novelty detection fell from 0.980 AUC to 0.649. That result is written in the code, right beside the constant.
Each face is then summed as a single phasor: cell j contributes at angle 2πjφ, weighted by its magnitude. A face comes out as one radius and one angle. That is all three faces are — two numbers each.
Each face is then added up as one arrow. Cell j points at angle 2πjφ, and its length is its own size. Add them all and the face comes out as one length and one angle. That is all a face is: two numbers.
In Ω.js, ω.(b) is NOT this three-valued cell.
It returns the first symbol of face 0's address,
which has four states, and it is what the trie is
keyed on. The three-valued cell is what tile()
produces. The two are one step apart and share
no arithmetic.
A tile is the field again, one level down.
A byte's 256 cells are not a raster and they are not a list. They are placed by their own index — cell j sits at angle 2πjφ, exactly the rule the whole field uses to place its states. The magnitude, 1, 2 or 3, picks a ring. The sign picks a face. So one byte's is drawn the same way the entire corpus is drawn, and the picture of a byte and the picture of a library are the same picture at different scales.
A byte's 256 cells are not a picture and not a list. Each cell is placed by its own number. Cell j sits at angle 2πjφ. That is the same rule the whole field uses to place its states. The size of the cell, 1, 2 or 3, picks a ring. The sign picks a face. So one byte's is drawn the same way a whole corpus is drawn. The picture of a byte and the picture of a library are the same picture at different scales.
There is a legibility floor and it is worth stating because it explains why the live tool draws three different things depending on zoom. 256 marks need roughly 55 pixels of diameter before they stop merging into a solid blob. Below that the same coordinate is aggregated to 8 sectors × 3 rings, with area carrying the count. Below that, a mark is a single dot in its loudest sector. All three are the same address at the resolution the space can honestly hold.
There is a floor on what can be read, and it explains why the live tool draws three different things as you zoom. 256 marks need about 55 pixels across before they stop merging into a blob. Below that, the same coordinate is grouped into 8 sectors by 3 rings, and area carries the count. Below that, a mark is one dot in its loudest sector. All three are the same address, at the detail the space can honestly hold.
State k sits at radius √k, angle 2πkφ.
Two constants, no lookup, no allocator. The position of the kth thing in the field is a function of k alone.
Two constants. No lookup table and no allocator. Where the kth thing sits depends on k and nothing else.
The consequence is the reason it is used, and it is worth being exact about its scope. The placement rule alone never moves anything already placed. Add a million states and the kth one is still at √k and 2πkφ, because nothing in the formula refers to how many states exist. Growth in the plot happens strictly at the rim. That is a statement about the layout and nothing more: feed() re-runs the whole eigendecomposition over the entire corpus and rebuilds the trie from scratch every time, so the encoder and the index are recomputed on every feed. Appending is cheap on the picture and not on the address book.
That is why it is used, and it is worth saying exactly what it covers. The placement rule on its own never moves a thing already placed. Add a million states and the kth one is still at the same radius and the same angle. The formula never asks how many states exist. In the picture, growth happens at the rim only. That is all it says. feed() still runs the whole eigendecomposition over the entire corpus and builds the index again from nothing every time. The map of the bytes and the index are rebuilt on every feed. Appending is cheap on the picture. It is not cheap on the address book.
The golden angle is chosen for a specific and often mis-stated property. It is not the densest packing — hexagonal is. It is the most uniform sequential placement: because φ is the hardest number to approximate by fractions, each new seed lands in the largest gap the previous ones left, so the arrangement is even at every count, not only at the end. That is the property an append-only structure needs.
The golden angle is picked for one property, and that property is often stated wrongly. It is not the tightest packing. Hexagonal packing is tighter. It is the most even placement when things arrive one at a time. φ is the hardest number to approximate with fractions, so each new seed lands in the largest gap the earlier ones left. The layout is even at every count, not just at the end. That is what an append-only structure needs.
Measured on the placement itself, sampling nearest-neighbour distance at 355 values of k between 200 and 19,000: 1.71 ± 0.03 field units, a standard deviation of 1.6% of the mean. Two digits is all that is real — the spacing steps at each Fibonacci transition rather than converging, so quoting it to seven figures, as an earlier write-up did, was false precision.
This was measured on the placement itself. Nearest-neighbour distance was sampled at 355 values of k between 200 and 19,000. It came out 1.71 ± 0.03 field units. That standard deviation is 1.6% of the mean. Only two digits of this are real. The spacing steps at each Fibonacci transition instead of settling down, so quoting it to seven figures, as an earlier write-up did, was false precision.
The mark size then follows rather than being picked. A mark that overlaps its neighbour by exactly the bleed has diameter 1.71·(1+φ⁷), and the overlap is φ⁷/(1+φ⁷) = 3.33% of the mark whatever the spacing turns out to be.
The mark size then follows. It was not picked. A mark that overlaps its neighbour by exactly the bleed has diameter 1.71·(1+φ⁷). The overlap is φ⁷/(1+φ⁷) = 3.33% of the mark, whatever the spacing turns out to be.
The address that gets built on top of it
Step 8 takes the three (radius, angle) pairs for every live byte and splits the disc four ways — nearer or further than the geometric-mean radius, clockwise or anticlockwise of the mid-angle — recording one two-bit symbol per level, then recursing into each quadrant. Two bytes are close when their addresses agree for longer.
Step 8 takes the three (radius, angle) pairs for every live byte. It splits the disc four ways: nearer or further than the geometric-mean radius, and clockwise or anticlockwise of the mid-angle. It writes down one two-bit symbol for that level. Then it does the same thing inside each quarter. Two bytes are close when their addresses agree for longer.
The recursion stops when a cell gets smaller than the null, whose radius is φ⁷ of the field. That is what sets the depth, and therefore the collision rate: a larger null gives shorter addresses and more collisions, a smaller one gives fewer. On this corpus face-0 addresses run 2 to 6 symbols deep.
The splitting stops when a cell gets smaller than the null. The null has a radius of φ⁷ of the field. That is what sets the depth, and the depth sets how often two things share an address. A larger null gives shorter addresses and more clashes. A smaller null gives fewer. On this corpus, face-0 addresses run 2 to 6 symbols deep.
Because each level appends a symbol and never rewrites an earlier one, an address is a prefix code. Truncating the stream gives a valid coarser field rather than a corrupt one. One level is a four-way split on each of the three faces — 4³ = 64 combinations, not 3 × 4 — which is why the interchange format writes a level as one base-100 pair, with 36 codes spare.
Each level adds a symbol and never rewrites an earlier one. So an address is a prefix code. Cut the stream short and you get a valid, coarser field rather than a broken one. One level is a four-way split on each of the three faces. That is 4 × 4 × 4 = 64 combinations, not 3 × 4. That is why the interchange format writes a level as one base-100 pair, with 36 codes spare.
Per face, distance is 4^(-k) at the first
divergence on a rooted tree. That IS an
ultrametric; every triangle is isosceles.
It is a regression test on the code, not a
discovery — it cannot come out otherwise.
It is a pseudo-ultrametric. Distinct bytes
share an address:
face 0 65 addresses for 66 live bytes
face 1 63 addresses for 66 live bytes
face 2 65 addresses for 66 live bytes
Identity of indiscernibles fails on one face.
Three faces are what repair it.
Branching is 4 = ||, and that does not
make it 4-adic: 4 is not prime and the
branching group is (Z/2)², not Z/4. It is a
4-ary ultrametric Cantor space.
And θ, the comparison the engine actually
uses, sums depth across the three faces.
The summed metric is not ultrametric. The
100% figure describes how the address is
built, not what the field reads with.
A question costs the same whatever the corpus weighs.
The address symbols of the bytes you typed walk down the trie until the candidate list is small enough, and then every candidate is scored: a of 8 bytes back from each one for the best-match pass, and up to 400 bytes back for the ten directions. That is a lot of reading — and the point is what bounds it. The candidate pool is capped at DENS = 800, so the cost of a hop is set by the pool and the context, never by how much has been fed. It is not that a question touches little; it is that what it touches does not grow.
The address symbols of the bytes you typed walk down the index until the candidate list is small. Then every candidate on that list is scored. The best-match pass reads a of 8 bytes back from each one, and the ten directions read up to 400 bytes back. That is a lot of reading. What matters is what limits it. The candidate list is capped at DENS = 800. So the cost of one hop is set by that list and by your prompt, never by how much has been fed. The claim is not that a question touches little. It is that what it touches does not grow.
| Hop | Word returned | Position | Positions read | Distinct so far | Landing window |
|---|---|---|---|---|---|
| 1 | Everything | 69 | 1,389 | 1,389 | 8 |
| 2 | and | 80 | 2,051 | 3,275 | 16 |
| 3 | Nothing | 84 | 1,978 | 4,652 | 20 |
| 4 | were. | 92 | 1,335 | 5,480 | 28 |
| 5 | In | 98 | 363 | 5,753 | 34 |
| 6 | the | 101 | 2,694 | 7,294 | 37 |
| 7 | silence, | 105 | 3,477 | 9,096 | 41 |
| 8 | through | 114 | 1,328 | 9,538 | 49 |
| 9 | the | 122 | 1,960 | 10,264 | 57 |
| 10 | depths, | 126 | 1,899 | 10,758 | 61 |
| 11 | they | 134 | 3,291 | 11,796 | 69 |
| 12 | were | 139 | 3,696 | 12,083 | 74 |
Read the two right-hand columns together, because an earlier version of this page printed only the last one and called it the reach. Landing window is the 74 positions the walk landed on and read out — that is what the figure draws and what the live tool counts on its status line. Distinct so far is every position the algorithm actually consulted to get there: direction scoring, the best-match rescore and ἀστήρ's pairwise overlap. Instrumented on a copy of Ω.js, recording every this.buf[…] index consulted inside read(), that comes to 12,083 of 15,564 — 77.63% of the field, with the first hop alone at 1,389.
Read the last two columns together. An earlier version of this page printed only the last one and called it the reach. Landing window is the 74 positions the walk landed on and read out. That is what the figure draws, and what the live tool counts on its status line. Distinct so far is every position the algorithm really looked at on the way: scoring the ten directions, the best-match pass, and the fusing step. This was instrumented on a copy of Ω.js, recording every byte index it touches inside read(). It comes to 12,083 of 15,564 — 77.63% of the field. The first hop alone is 1,389.
So the small number is not the claim. The claim is the one that survives instrumentation: a hop costs what the pool costs, and the pool is capped. Feed the same field three more books, ask the same question, and the first hop still reads a few thousand positions while the fraction of the field it touches collapses:
So the small number is not the claim. The claim that survives is a different one. A hop costs what the candidate list costs, and that list is capped. Feed the same field three more books and ask the same question. The first hop still reads a few thousand positions, and the share of the field it touches falls:
| Ledger | Bytes | States | Read, hop 1 | Distinct, 12 hops | Of the field |
|---|---|---|---|---|---|
| the story only | 15,564 | 2,919 | 1,389 | 12,083 | 77.63% |
| + Frankenstein | 105,563 | 18,964 | 828 | 20,233 | 19.17% |
| + Pride and Prejudice | 195,557 | 39,446 | 1,352 | 29,881 | 15.28% |
| + Moby-Dick | 285,554 | 56,105 | 2,075 | 37,220 | 13.03% |
The ledger grows eighteen-fold and the first hop stays between 828 and 2,075 positions. On these four runs the candidate pool never exceeded 158, well under the 800 ceiling, so the ceiling was not even the binding constraint — the trie descent stops at the target list size first. That is the asymptotic statement, and it is the one that is safe to make.
The ledger grows eighteen times over and the first hop stays between 828 and 2,075 positions. Across these runs the candidate list never got above 158, well under the ceiling of 800. The ceiling was not even what stopped it — the walk down the index stops at the target list size first. That is the claim about growth, and it is the one that is safe to make.
This is a property of the index, not an optimisation on top of it. The address is a prefix, so retrieval cost follows the rather than the size of the corpus — which is also why recall in the ten-book benchmark does not decay from the front of the haystack to the back the way an attention window does.
This comes from the index itself. It is not a speed-up bolted on afterwards. The address is a prefix, so the cost of retrieval follows the rather than the size of the corpus. That is also why recall in the ten-book benchmark does not fade. It holds from the front of the haystack to the back. An attention window does not.
1 the last bytes you typed are converted to
address symbols and walk the trie, one
symbol per level, until the candidate list
is at or below 64
2 the candidates are thinned to at most 800
(a ceiling, not a working value. on Δ/V·001
the pool never exceeded 158 over 1,453 reads,
so DENS never fires — see Exhibit A on /toe)
3 the context is split into ten directions by
the same golden-angle rule, each byte at
radius √(k+1). every direction scores every
candidate independently, weighting nearer
context by 1/φ per step
4 θ scores one pair: count the shared address
prefix on each of the three faces; if more
than 1.5 of the three faces agree at all,
return the summed depth, else zero
5 the ten proposals are fused by pairwise
overlap with a zeroed diagonal, thresholded
at the median — a medoid, not a mean, so
near-duplicates do not smear together
6 unsigned sum across the ten directions is
agreement. the alternating sum is what does
not cancel. those become the two numbers
Two scalars, four , and a that can never be met.
Two numbers, four reference points, and a that can never be met.
The comparison produces exactly two numbers, and they are deliberately different quantities rather than two views of one. Three earlier candidates for the second number — a reverse residual, a coverage count, a concentration — all turned out to be rescalings of the first and separated nothing.
The comparison gives back exactly two numbers. They measure different things on purpose. They are not two views of one thing. Three earlier candidates for the second number were tried — a reverse residual, a coverage count, a concentration. Each one turned out to be the first number in disguise, and separated nothing.
- leftover, in the source, reads the 8-byte window. Is this language I hold?
- novelty, in the source, reads up to 400 bytes through the ten directions. Is it arranged as I hold it?
Neither is compared against a threshold anybody typed. The field measures four on its own material at feed time. For leftover it reads passages of its own text with every other word deleted, and it reads its own bytes shuffled. For novelty it reads intact passages at seven different lengths, and its own words in random order. The median of each is a pole. On the loaded story:
Neither number is checked against a cut-off somebody typed in. The field measures four on its own material when the text is fed. For leftover it reads passages of its own text with every other word deleted, and it reads its own bytes shuffled. For novelty it reads whole passages at seven different lengths, and its own words in random order. The middle value of each is a pole. On the loaded story:
measured, not set — shipped defaults on Δ/V·001leftover answered 0.11765 stranger 0.69189 novelty ordered 0.14372 scrambled 0.46093 a reading is "mine" if it is nearer the answered pole than the stranger pole on a log scale, which puts the boundary at the geometric mean. the same rule on the other pair gives 0.2574. these are the DEFAULTS the engine uses at feed time: measurePoles(120) and measureOrderPole(140). the figure scripts call measureOrderPole(210), a larger sample, which gives 0.1449 / 0.4594 and a boundary of 0.2580. same field, different sample size — the pair above is what ships.
Sampling novelty across seven context lengths rather than one was a correction, not a refinement. Calibrated at a single 380-byte length the boundary fell at 0.2318 — straight through the real distribution at 260 bytes, where the ten sectors fill unevenly and novelty peaks. Recall at 260 bytes was 0.885 for that reason alone. Across the range it holds at every length.
Sampling novelty at seven context lengths instead of one was a correction, not a polish. Calibrated at a single length of 380 bytes, the boundary landed at 0.2318. That runs straight through the real distribution at 260 bytes, where the ten sectors fill unevenly and novelty peaks. Recall at 260 bytes was 0.885 for that reason alone. Sampled across the range, it holds at every length.
And the second number qualifies rather than vetoes. Requiring both to land held three real passages, present in the record in exactly that order, as “not my order”. The first decides whether to speak; the second reports whether the measure is the field's own. Both are returned either way.
The second number qualifies. It does not veto. Requiring both to land marked three real passages as “not my order” — and those passages are in the record in exactly that order. So the first number decides whether to speak. The second reports whether the measure is the field’s own. Both come back either way.
Θ = 3 × ½ = 1.5
it sits strictly between 1 and 2, so it can
never be met, only exceeded. "more than 1.5
of 3" is "at least 2 of 3" with no tie case
to adjudicate. the same constant is used in
three places and does the same job in all
three.
A real failure, and what it cost
Bytes outside the corpus's own alphabet are dropped before the comparison. That is correct, and it had a consequence nobody predicted: a prompt written in a script the field has never seen collapses to whatever punctuation survives — usually the trailing space. A space matches every word boundary in the record perfectly, so leftover came back 0.0000, which is the maximum-confidence value, and the field spoke.
Bytes outside the corpus’s own alphabet are thrown away before the comparison. That is correct, and it had a side effect nobody predicted. A prompt written in a script the field has never seen collapses to whatever punctuation survives — usually the trailing space. A space matches every word boundary in the record perfectly. So leftover came back 0.0000, which is the most confident value there is, and the field spoke.
The fix applies the twice: addressable non-delimiter bytes must exceed , and the readable fraction must exceed Θ/3. Both strictly greater, so a tie is impossible for the same reason it is impossible anywhere else. An earlier version of the guard used 3 and 0.5, which were picked; these are not.
The fix applies the twice. Addressable non-delimiter bytes must beat . The readable fraction must beat Θ/3. Both are strictly greater, so a tie is impossible, for the same reason it is impossible anywhere else. An earlier guard used 3 and 0.5, which were picked. These are not.
reproduced today, both waysprompt shipped guards removed
" " nowhere to land speaks, 0.0000
"\t " nowhere to land speaks, 0.0000
"a " nowhere to land speaks, 0.0000
"مرحبا بالعالم " nowhere to land speaks, 0.0000
"你好世界 " nowhere to land speaks, 0.0000
0.0000 is the same score a verbatim quotation
from the record gets. with the two guards taken
back out, all five of these return it and the
field answers all five.
What that yields on the loaded story
One run of the repository's own check, six context lengths (120, 200, 260, 380, 500 and 800 bytes), drawing fresh samples at each. Counts, not rates, so the denominators are visible.
This is one run of the repository’s own check. Six context lengths were used: 120, 200, 260, 380, 500 and 800 bytes. Fresh samples were drawn at each. These are counts, not rates, so you can see the denominators.
| What was asked | Result | Rate | What was fed in |
|---|---|---|---|
| Passages from the record — does it speak? | 1,151 / 1,151 | 1.000 | text drawn from the corpus at six lengths |
| Random printable junk — does it refuse? | 600 / 600 | 1.000 | uniform bytes in 33…122 |
| Its own bytes, shuffled — does it refuse? | 578 / 580 | 0.997 | real passages, byte order destroyed |
| Its own words, shuffled — is it flagged? | 572 / 600 | 0.953 | real words, sentence order destroyed |
These four are the easy directions, and a memory addressed by prefix is built for exactly them. They are reported here because they are what the check measures, not because they are the interesting number. The interesting number is two sections down.
These four are the easy directions. A memory addressed by prefix is built for exactly them. They are reported here because they are what the check measures. They are not the interesting number. The interesting number is two sections down.
Some of these fall out. Some of them were picked.
The project's own writing has at times used one tone for both, and the contrast is more informative than the confidence. Below, the left column is arithmetic that could not have come out differently; the right column is a decision someone made and then measured.
The project’s own writing has sometimes used the same confident tone for both kinds of number. The contrast tells you more than the confidence does. On the left below is arithmetic that could not have come out any other way. On the right is a value somebody chose, and then measured.
φ (√5 − 1)/2 = 0.618033989
φ⁷ 0.034441853 — the null's radius as a
fraction of the field, and the weight of
the outermost co-occurrence arm. one
ratio, used in both places
Φ⁷ 1/φ⁷ = 29.034442 = L₇ + φ⁷
Θ 3 × ½ = 1.5, the doorway
7/16 = 0.4375 — the agreement two
unrelated addresses get by chance,
subtracted as a floor before anything is
scored. it is two lines and they can be
checked by eye:
per face, two random R4 words share a
prefix of depth ≥ k with probability
4⁻ᵏ, so the expected agreement depth is
E[L] = Σ 4⁻ᵏ = 1/3 over k ≥ 1
and θ counts a face only when at least
one of the other two is open as well,
which happens with probability
1 − (3/4)² = 7/16. three faces, by
symmetry:
ν = (1/3) × (1 − (3/4)²) × 3 = 7/16
in floating point the left side comes out
0.43749999999999994. nothing else on this
page is this clean.
W log(N / 2πe), then floored by liftoff:
the window is walked upward until the
field's own thinnings stop explaining
themselves perfectly. on this corpus the
formula gives 5 and the floor gives 8.
at W = 5 every thinning still contains an
exact match, so 1.000 there is scored in
a space with no room to be wrong in
ring radius (q/3)², because splits at the
geometric mean and states sit at √k
mark radius 1.71·(1+φ⁷)/2, from the measured
spacing and the one ratio
ARMS 1 2 3 5 8 13 21 — Fibonacci offsets for
the co-occurrence pass, weights φ¹…φ⁷
DIM 256 cells per tile. the log records
"cutting to 64 took stored reading
0.985 -> 0.316, novelty AUC 0.980 -> 0.649"
quoted, NOT reproduced. re-run here on
Δ/V·001 with the shipped holdout, DIM 64 gives
stored reading 0.9832 (unchanged, N=357),
unseen 0.0169 vs 0.0193 (N=828) and novelty
AUC 0.9881 vs 0.9934 (n=685). the quoted
collapse belongs to a corpus this page
cannot name, so it is not a figure here.
FILL 64 eigenvectors, 30 power iterations,
fixed seed 12345
±3 the clamp on a cell. the 3 is the state
count and that much is arithmetic; using it
as a saturating clamp on a quantised
coordinate is a decision. 11.90% of the
16,896 cells on this corpus hit it
DEPTH 12 address symbols in the trie key
DIRS 10 directions
DENS 800 candidates — a ceiling that never
fires. over 1,453 reads on Δ/V·001 and the
holdout the pool ran 1 to 158, median 33.
setting DENS to 300 is therefore a no-op:
step = floor(pool/DENS) is 1 either way and
stored reading is 0.9832 for both. the
"0.996 -> 0.916" in the log is not
reproducible on the shipped ledger.
delimiters kept in the trie key, even though
that leaves level one with a single
branch. re-measured here, Δ/V·001 fed,
gates.js probes, keep vs skip:
abstention 1.0000 vs 1.0000 N=600
reading, unseen 0.0193 vs 0.0133 N=828
reading, stored 0.9832 vs 0.9832 N=357
keeping is better on unseen material and
costs nothing on the other two
star vote, not mean — and the interaction
this page used to celebrate is not there.
unseen reading, N=828 each cell:
kept skipped
star vote 0.0193 0.0133
centroid 0.0193 0.0109
the star never loses; it ties with the
centroid when delimiters are kept. the
log's 0.036 / 0.024 / 0.008 crossover does
not reproduce on the shipped holdout
And the fitted part earns less than it looks like it should
The embedding in steps 2 to 5 is the only part of the system fitted to data. Replacing it with a deterministic byte hash — no corpus pass, no co-occurrence, no eigendecomposition — and re-running the same four checks on the same story:
Steps 2 to 5 build the map of the bytes. That map is the only part of the system fitted to data. So it was replaced with a plain byte hash. That hash makes no pass over the corpus, no co-occurrence and no eigendecomposition. Then the same four checks were run again on the same story:
| Encoder | Speaks on its own text | Refuses junk | Refuses shuffled bytes | Flags shuffled words | Mean address depth |
|---|---|---|---|---|---|
| Derived from the corpus | 1.000 | 1.000 | 0.997 | 0.953 | 4.27 |
| Byte hash, seed 1 | 1.000 | 1.000 | 1.000 | 0.967 | 4.23 |
| Byte hash, seed 2 | 1.000 | 1.000 | 1.000 | 0.977 | 4.33 |
The geometry is doing the work — the cascade, the doorway, the poles, the ten directions. On these four measures the encoder need only assign distinct vectors to distinct bytes. Deriving positions from company genuinely is a translator, in that it puts bytes keeping the same company near each other; none of these four checks asks whether a is like e, only whether a is not e, and any injective assignment satisfies that.
The geometry is doing the work. That means the cascade, the doorway, the poles and the ten directions. On these four measures the encoder only has to give different bytes different vectors. Working the positions out from company really is a translator: it puts bytes that keep the same company near each other. But none of these four checks asks whether a is like e. They only ask whether a is not e, and any one-to-one assignment does that.
It does not generalise, and feeding it more will not fix that.
It only knows what you gave it. Feeding it more will not change that.
This is the number the rest of the page should be read against. Everything above describes a machine that is very good at material it has been given and close to useless on material it has not, and the gap between those two is not a tuning problem.
This is the number to read the rest of the page against. Everything above describes a machine that is very good on material it was given, and close to useless on material it was not. The gap between those two is not a tuning problem.
The same probes, put to two fields
Three books ship with the repository as a fixed foreign , and its own probe builder cuts each into probes: 400 bytes of context ending on a word boundary, and the word that actually followed. gates.js · probes(book, 300, 400). Those probes were then put to two fields whose only difference is what was fed.
Three books ship with the repository as a fixed foreign . The repository’s own probe builder cuts each book into probes. A probe is 400 bytes of context ending on a word boundary, plus the word that actually followed. gates.js · probes(book, 300, 400). Those probes were then put to two fields. The only difference between the two fields is what was fed to them.
| Probes drawn from | n | Next word right — fed the story only | Next word right — fed the story and that book |
|---|---|---|---|
| Frankenstein | 285 | 4 0.014 | 258 0.905 |
| Pride and Prejudice | 276 | 4 0.014 | 254 0.920 |
| Moby-Dick | 267 | 8 0.030 | 252 0.944 |
The verdicts move the same way. Fed the story alone, the 285 Frankenstein probes come back 175 not mine, 105 my words, not my order, and 5 mine, in order. Fed the story and Frankenstein together, all 285 are mine, in order.
The verdicts move the same way. Fed the story alone, the 285 Frankenstein probes come back 175 not mine, 105 my words, not my order, and 5 mine, in order. Fed the story and Frankenstein together, all 285 come back mine, in order.
Feeding it the book did not teach it to read books. It made that book known, and left the reading of everything else exactly where it was. There is no transfer here, and a system carrying many corpora must not be described as though there were.
Feeding it the book did not teach it to read books. It made that one book known. It left the reading of everything else exactly where it was. There is no transfer here. A system carrying many corpora must not be described as though there were.
Older figures for this circulate and none of them survives a re-run. The project's log records 0.036 for next-word reading on material never seen, and 0.008 for the same measurement with delimiters dropped from the index key. Neither names its corpus. Re-measured on the shipped ledger against the shipped holdout, the pair is 0.0193 kept and 0.0133 skipped — both about two per cent, not 3.6% and not 0.8% — against 0.9832 on material the field holds. The figures in the table above are those runs.
Older figures for this go around, and none of them survives being run again. The project’s log records 0.036 for next-word reading on material never seen, and 0.008 for the same thing with delimiters dropped from the index key. Neither says which corpus it was measured on. Run again on the ledger that ships, against the holdout that ships, the pair is 0.0193 and 0.0133. Both are about two per cent. Neither is 3.6% and neither is 0.8%. On material the field holds it reads 0.9832. The table above is those runs.
105 of those 285 passages of genuine unseen English came back as my words, not my order — the vocabulary is shared, the arrangement is not held. That is the honest thing to say about a book it has never read, and it is what keeps the outright claims down to 5 rather than 285.
105 of those 285 passages of real, unseen English came back as my words, not my order. The words are shared. The arrangement is not held. That is the honest thing to say about a book it has never read. It is also what keeps the outright claims down to 5 rather than 285.
But it is 5, not 0. Across all three books, 14 of 828 unseen passages were claimed outright, and not one of the 14 produced the right next word. The rate depends on the size of the record and on the address collision rate. It is small and it is not zero.
But it is 5, not 0. Across all three books, 14 of 828 unseen passages were claimed outright. Not one of those 14 gave the right next word. The rate depends on how big the record is and on how often two things share an address. It is small, and it is not zero.
On the ten-book benchmark recorded in the repository — 5.94 MB fed, 1,077,603 states, window 11 — the false-claim rate is 0.003, and the single error in 300 was inspected. A phrase from a Dickens novel never fed produced the same address sequence as a phrase in the record. Different bytes, identical addresses.
On the ten-book benchmark in the repository — 5.94 MB fed, 1,077,603 states, window 11 — the false-claim rate is 0.003. The single error in 300 was inspected. A phrase from a Dickens novel that was never fed produced the same address sequence as a phrase in the record. Different bytes, same addresses.
That is one mechanism, and this page used to say it was the only one and that only finer addresses could fix it. Both halves are wrong. Gate 3 puts 336 probes to the field — gates.js · probes(book, 120, 400) on each of the three shipped books — and Δ/V·001 makes three false claims on them, all in Pride and Prejudice. Opened individually on 2026-08-18, one is an address collision — the full twelve-symbol key present in the trie, leftover 0.0000. The other two never reach a full key: they agree to depth 9 of 12 and 7 of 12 and pass only because leftover, at 0.2246 and 0.1469, falls on the near side of the boundary at 0.2853. Those are threshold false positives, not collisions.
That is one mechanism. This page used to say it was the only one, and that only finer addresses could fix it. Both halves are wrong. Gate 3 puts 336 probes to the field — gates.js · probes(book, 120, 400) on each of the three books that ship. Δ/V·001 makes three false claims on them, all in Pride and Prejudice. Each was opened up on 2026-08-18. One is an address clash: the whole twelve-symbol key is in the index and leftover is 0.0000. The other two never reach a whole key. They agree to depth 9 of 12 and to depth 7 of 12, and they pass only because leftover, at 0.2246 and 0.1469, lands on the near side of the boundary at 0.2853. Those are threshold mistakes, not clashes.
And finer addresses do not fix it. Raising DEPTH from 12 to 16 and then to 24 left the count at three in every case. Keying the trie on the whole face-0 address rather than its first symbol made it ten, across all three books — 3.3× worse. The mechanism is not settled, and this page should not pretend otherwise.
And finer addresses do not fix it. Raising DEPTH from 12 to 16 and then to 24 left the count at three every time. Keying the index on the whole face-0 address instead of just its first symbol made it ten, across all three books. That is more than three times worse. Nobody knows the mechanism yet, and this page should not pretend otherwise.
Three more things that are not solved
Interpolation. The field can say a passage is novel and cannot do anything useful with the novelty. Every generative mechanism tried has come back inert. The detector is reliable; what to do in the presence of novelty is open.
Interpolation. The field can tell you a passage is new. It cannot do anything useful with that. Every generative mechanism tried has come back dead. The detector is reliable. What to do when something is new is still open.
Scale beyond what was run. The largest corpus measured is 5.94 MB across nine books. A real long-context corpus is thousands of times that; the window would move from 11 to roughly 18 and that is unmeasured. Nothing here says what happens at that size.
Scale beyond what was run. The largest corpus measured is 5.94 MB across nine books. A real long-context corpus is thousands of times that. The window would move from 11 to roughly 18, and that has not been measured. Nothing here says what happens at that size.
Benchmarks it should not be run on. This is not a language model. The question-answering and long-context suites measure things it does not do, and running them would produce numbers that mean nothing.
Benchmarks it should not be run on. This is not a language model. The question-answering and long-context suites measure things it does not do. Running them would produce numbers that mean nothing.
Memory and provenance. Not prediction.
The shape it fits
Questions of the form was this in the record, and can you show me where. The field returns positions in the source rather than generated text, the whole system is a deterministic function of the bytes it was fed — so a content hash of the source names it completely — and it will say nothing at all rather than approximate. Archives that are their own index, event logs that answer only from what was logged, records where being silent is better than being plausible.
It fits questions of one shape: was this in the record, and can you show me where. The field hands back positions in the source, not text it wrote. The whole system is a plain function of the bytes it was fed, so a content hash of the source names it completely. And it will say nothing at all rather than come close. Think of archives that are their own index, event logs that answer only from what was logged, and records where silence beats a plausible guess.
The property worth building on is not the recall. It is that the failure mode is silence. For anything that moves, heats, doses or pays, a component that goes quiet when it is out of its depth is worth more than one that is right more often and confident always.
The property worth building on is not the recall. It is that the failure mode is silence. Think of anything that moves, heats, doses or pays. There, a part that goes quiet when it is out of its depth is worth more. It beats a part that is right more often and confident always.
The shape it does not fit
Anything whose value comes from generalising. Forecasting, diagnosis from a presentation never seen, control in circumstances never encountered, answering about a case that is not in the record. The number for all of those is the one two sections up, and no quantity of additional corpus will move it — more corpus makes more material known, which is a different thing.
It does not fit anything whose value comes from handling the new. Forecasting. Diagnosis from a presentation never seen. Control in situations never met. Answering about a case that is not in the record. The number for all of those is the one two sections up. No amount of extra corpus will move it. More corpus makes more material known, which is a different thing.
It is also not a compression scheme, not a search engine with ranking, and not a substitute for a model. It holds what it was handed and it can prove it. That is the whole offer.
It is also not a compression scheme, not a search engine with ranking, and not a stand-in for a model. It holds what it was handed, and it can prove it. That is the whole offer.
Terms
- verdict
- The answer about the answer. There are three of them. It is mine and in the same order. Or the words are mine but the order is not. Or it is not mine at all.
- corpus
- The body of text you feed it. That text is the only thing it can answer from.
- tile
- One byte turned into 256 small whole numbers. Each number runs from minus 3 to plus 3. It is the machine’s picture of that byte.
- trit
- The first symbol of a byte’s address. It is what the index is sorted by. The name sounds like three, but it has four possible values.
- address
- A short string of symbols that says where a thing sits in the field. Two things are alike when their addresses start the same way.
- prefix agreement
- How many symbols two addresses share from the start. The more they share, the closer the two things are.
- window
- The small run of bytes just before the spot being read. At that moment the machine looks at that run and nothing else.
- pole
- A reading the machine takes on its own text when the text is fed in. Later readings are placed between two poles. Nobody types a number in.
- doorway
- A rule that only lets a thing through if it beats a number. The number is 1.5 out of 3. So you need at least 2 of 3, and a tie is impossible.
- Θ
- A fixed number: 3 × ½ = 1.5. It sits between 1 and 2, so it can never be matched exactly, only passed.
- ν
- How much two unrelated addresses agree by luck alone. It is 7/16. It is taken away as a floor before anything is scored.
- φ⁷
- The golden ratio multiplied by itself seven times. It is about 0.0344. It sets the size of the small circle at the middle of the field.
- τ
- The step that turns a place in the field into an address. It splits the disc in four, then splits each quarter again, and writes down one symbol each time.
- R4
- A set of four moves. Do any one of them twice and you are back where you started. Do two of them in either order and you land in the same place.
- ἁρμονία
- The engine’s own name in the source for the first number, called leftover. It asks: is this language I hold?
- ῥυθμός
- The engine’s own name in the source for the second number, called novelty. It asks: is this put together the way I hold it?
- holdout
- Books the machine is never fed. They are used to test it on writing it does not have.