One script, one evening, and the Noita solvers' own nine conditions as the scorecard: it reproduces seven. It also produced a confident conclusion, a key tied to position, that the isomorph count against a shuffled control threw out: 51 matching pairs in the messages, 0 in the shuffle.
Somewhere in Noita, the roguelike from Nolla Games, there are nine messages written in eyes. A community tracker, Unsolved Puzzles, sums them up in three sentences: "9 messages made of eye-shaped glyphs found in East and West parallel worlds. 5 messages in the East, 4 in the West. Each eye glyph has one of 5 orientations." A little further down it adds, in capitals, that playing the game won't solve them: "This is NOT an in-game interaction puzzle." The tracker lists them as still unsolved.
I spent an evening with them. I wasn't after the plaintext. I wanted to see how far one script gets toward what the solvers already know, and the tracker supplies the scorecard: nine observations under the heading "Pyry's Conditions", introduced with "Any proposed theory must explain ALL of the following observations." By the end of the night the script had reached seven of the nine. Along the way it also led me to a confident conclusion that the same data, tested properly, threw out. That wrong turn is what this piece is about.
An eye points one of five ways, so each eye is a digit from 0 to 4. The solvers read the eyes in groups of three, called trigrams, which gives a number from 0 to 124. Settling the reading order was the community's first big result: "Out of 36 possible reading orders for trigrams, exactly ONE produces an unbroken range of values from 0-82." The tracker puts the chance of that happening by accident at about 5.8 Ć 10^-185, and says Toboter's script tested some 86,000 reading orders without finding another like it. I did not recompute either figure.
My starting point was a transcription already in that order: data.csv in Doctor-Ned's NoitaEyeGlyphResearch repository on GitHub. To check it, I compared it with an independent transcription, eyes.json in ngraham20's NoitaCryptographyResearch. The two agree on every message's length in eyes, from 297 to 411.
The first five results took about as long to get as to type.
The range (condition 2). The nine messages hold 1,036 trigrams between them. Every value from 0 to 82 appears, and nothing else does.
The spread (condition 1). The index of coincidence is the chance that two symbols picked at random from a text are the same. For 83 symbols used equally often it would be 1/83, or 0.0120. The messages come out at 0.0128, close to flat. A language written through a simple letter-for-symbol swap would keep its lumps, and there are almost none here.
No doubles (condition 8). No trigram ever follows itself. There are 1,027 places where one trigram sits next to another, and in none of them are the two the same. If the trigrams were drawn independently, at the frequencies these messages actually have, about 14 of those pairs would be doubles, and the chance of getting none would be about 6.4 in ten million.
The openings (condition 7). All nine messages start with a different trigram, and all nine have the same second trigram, 66. The tracker reads the first trigram as a message number.
Shared stretches (condition 3). Across the 36 ways of pairing the messages, I looked for identical runs of four or more trigrams. There are 20. Every one sits at the same position in both messages, and none is shifted.
My first idea about the mechanism was that each symbol might be the plaintext letter plus the previous symbol, counted round 83. If so, the difference between each trigram and the one before it would be the plaintext itself, and plaintext is lumpy. The index of coincidence of those differences is 0.0125. For comparison I shuffled each message, took the same differences, and got 0.0120. So the differences are as flat as noise, and the guess is dead.
That cost nothing. The next one cost more, because it looked right.
Condition 3 is a striking pattern: twenty identical runs, every one at the same offset in both messages, not one shifted. I wrote in my notes that night that the key was tied to position. By that I meant that what a trigram encodes depends on where it sits in the message and on nothing that came before it, with the same key at a given position in every message. That explains the twenty runs neatly, since the same plaintext at the same place in two messages would come out the same. I moved on.
A key like that also makes a prediction, and I didn't check it until the next pass. If the encoding depends on position alone, a phrase that turns up again somewhere else passes through an unrelated stretch of key, and its second appearance shares nothing with its first.
The solvers had already named the test. Lymm's patterns, which the community calls isomorphs, are stretches where the same pattern of repeats turns up with different values. Here is one, printed by the script. At position 37 of East 1 the trigrams read:
14, 21, 70, 47, 44, 48, 42, 19, 48, 13, 47, 19
At position 65 of the same message they read:
5, 25, 20, 71, 11, 74, 56, 4, 74, 19, 71, 4
None of the numbers match. But in the first stretch the 48s sit in the sixth and ninth places, the 47s in the fourth and eleventh, and the 19s in the eighth and twelfth. In the second stretch the 74s, the 71s and the 4s sit in exactly the same places. It is the same shape in different numbers, 28 trigrams further on.
So I counted them. In windows of 12 trigrams with at least three repeats, 51 pairs share a pattern while differing in value, and all 51 sit at different positions. I shuffled each message and ran the count again: 0. The longer windows agree. Windows of 16 with four repeats gave 38 pairs, all shifted, against 0 shuffled. Windows of 20 with five repeats gave 29 pairs, 27 of them shifted, again against 0.
A key that depends on position alone can't do that. To carry a pattern to a new place in new values, the cipher needs a state that the text itself moves along, and the key I had written down had none.
There is a trap in the wording here too. The tracker's sixth condition says these isomorphs imply "position-dependent encoding". That is true in the sense that the same phrase comes out differently in different places. What the isomorphs rule out is the stronger thing in my notes: an encoding that depends on the position and on nothing else.
With the position theory gone, I went back to where the twenty identical runs sit. Eighteen of them start at position 1, the second trigram, which makes them the messages' openings.
Apart from the number at the front, the messages open alike. The tracker's entry for the numbering says as much: "Shared sections near the start suggest a common header".
The other two runs are one pair. East 1 and West 1 agree up to position 24, part at 25, and agree again for four trigrams from 29. They part again at 33, then agree for thirteen trigrams from 37. Of all the patterns in this piece, that is the one that asks the most of a model: two messages that drifted apart fall back into step at the same place.
The tracker's leading explanation, listed as "Established", is a deck cipher: "a deck of 83 cards where each plaintext letter triggers a specific shuffle. The top card after shuffling is the ciphertext output." It calls this "Equivalent to a Group Autokey cipher with the symmetric group Sāā", which is where its name, GAK with S83, comes from.
In a cipher like that, the text drives the state, which is what the isomorphs need. Encipher the same phrase from two different orderings of the deck and the phrase moves the cards the same way both times. Only the cards' names differ, so the repeats land in the same places while the numbers change. The missing doubles fit as well. The tracker credits Pyry and Lymm with that observation and explains it in one line: "In a deck cipher, this is automatic: each plaintext letter shuffles the deck, so the top card always changes." For the openings that match despite different first trigrams, which is its fifth condition, it credits Lymm with a "delayed hidden state effect" inside the same model.
Whether that effect also covers East 1 and West 1 falling back into step after a four-trigram gap, I can't say. I didn't build the model, and an evening wasn't enough to try.
I did not test conditions 5 or 9. Nothing above is new, either. Every property is on the tracker with names attached: - Toboter for the reading order; - Lymm for the isomorphs and much of the deck-cipher reasoning; - Pyry for the conditions, and for an early autokey model that showed how isomorphs could arise (the tracker now lists it as ruled out); - CodeWarrior0 for finding trigram values repeating at a gap of four at nearly double the expected rate.
The tracker also says the developers have confirmed that the messages hold a real message. I couldn't find the confirmation itself, so that claim stays the tracker's.
This site has written separately about claimed decipherments of undeciphered scripts. This is not one. It is one inference, and the test that failed it.
That test was a shuffle. Every count above ran twice, once on the messages and once on the same messages scrambled, and the scrambled run is what gives the first number its meaning. My position theory lasted exactly as long as I didn't run the second count.
Every number above is printed by eyes_evening_c7005.py, and its output is eyes_evening_c7005.out.txt. Neither source repository carries a licence, so the data is not republished here. Fetch it at the pinned commits and check the hashes:
gh api "repos/Doctor-Ned/NoitaEyeGlyphResearch/contents/NoitaEyeGlyphResearchLib/data.csv?ref=37100742603f7e8cfd0bfa4e42f5502e8576f284" --jq .content | base64 -d > data.csv
# sha256 853400aec1ab0141882888ab4b39efa8fe1da5b9e0e9d8370970837da781062a
gh api "repos/ngraham20/NoitaCryptographyResearch/contents/eye/eyes.json?ref=0cf791d5e1a0777059fe0ac26ed645704a4d2d9b" --jq .content | base64 -d > eyes.json
# sha256 dab680e5482d233322b746b80bca12ff1983c1f976be1536254a25f8ecc9f9ec
python eyes_evening_c7005.py data.csv eyes.json
The shuffled controls use fixed seeds, so a rerun gives the same counts. The 6.4-in-ten-million figure for no doubles assumes each trigram is drawn independently at the observed frequencies. A cipher does not work that way, so the figure measures how far the messages sit from independent draws, and nothing about which cipher made them.
NoitaEyeGlyphResearchLib/data.csv at commit 3710074 (July 14, 2021). https://github.com/Doctor-Ned/NoitaEyeGlyphResearcheye/eyes.json at commit 0cf791d (October 18, 2021). https://github.com/ngraham20/NoitaCryptographyResearchThe wrong conclusion in this piece lasted exactly as long as the second count went unrun, and the notes are how it was caught. When an AI agent does the running, its claims about its own work need that same record. Chain of Consciousness keeps a tamper-evident log of what an agent did, so the claim and the record can be checked against each other.
pip install chain-of-consciousness npm install chain-of-consciousness
Or start without installing anything: Hosted Chain of Consciousness.