Decode This
Can You Decode This?
Figure out what it is teaching you.
0101010101010101100000001000111110110011
1011110010010101010101010110000000100011
1110110011101111001001010101010101011000
0000100011111011001110111100100101010101
0101011000000010001111101100111011110010
That is the whole message. It consists of two hundred bits, no header, no key, no clue about which alphabet it uses or which end is up. There is nothing else coming. Everything below this paragraph is a spoiler. If you want the experience rather than a summary, stop here and spend five minutes with it. An editor (with auto-highlighting of matching strings) helps. Alternatively, a pencil works. At this point, nothing else does.
The first thing you notice
You notice that it repeats.
The line breaks above are decorative. They are set to 40 bits wide, so they cut across the structure rather than revealing it. Lay the two hundred bits end to end and a period appears at once: one fifty-bit passage, played four times. That is the first thing any receiver learns, and it matters, because repetition is the simplest proof of intent. A pulsar is periodic but not structured. A structured signal usually isn’t periodic. A rotating star gives you the first and a failing amplifier gives you a cruder version of it, but neither gives you both at once: fifty bits of internal structure, sent clean, then sent again, until it stops. Physics does not hand you that by accident. Someone wanted it noticed.
Repetition also serves a practical purpose. A signal that has traveled any real distance arrives damaged. Sending the passage four times means a receiver that loses a bit to noise can recover it by majority vote against the other three copies. We paid for three-quarters of the message to get that insurance, and it was worth the cost.
So we set the repetition aside and focus on one cycle:
01010101010101011000000010001111101100111011110010
Two bits at a time
The opening is impossible to miss. Sixteen bits alternate perfectly: zero one zero one zero one, and then it stops, leading to something else.
Alternation is the shortest string that is clearly artificial while also expressing its own length. It conveys two messages: I am not noise, and I repeat every two bits. The second message is the important one. The biggest challenge for anyone reading a raw bitstream is figuring out where the units begin and end. A bitstream has no spaces. Before you can understand what the symbols mean, you need to know how long a symbol is. The beacon resolves that question first.
However, there is a trap, and it’s worth going into intentionally. If you start reading the alternating sequence one bit late, you will see ten ten ten instead of zero one zero one. The period is clear, but the phase is not. Alternation can’t show you where the first unit starts, only how wide it is.
Two factors clarify the phase. The first is convention, which is weak but real: the message has a starting point somewhere, and the sensible choice is to begin reading at the first bit you receive. The second factor is much stronger and is a purposeful design feature. When you read the message in the correct phase, the pattern zero one appears thirty-two times, all within two continuous beacon runs and not elsewhere. If you read it one bit late, the same pattern shows up twenty-four times, scattered throughout like litter. One of these readings is clearly structured; the other looks disordered. You don’t need to be told which one is right; it’s obvious. The message is designed so that the wrong phase appears incorrect.
Four symbols, one of them punctuation
Two bits create four possible units, and the message uses all four.
The unit 01 appears only in the beacons. It performs structural work and never shows up as content, which is what makes the beacons clear. Unit 10 appears at regular intervals throughout the body. Once you find it, you’ll see it always sits between groups of exactly three other units, never next to itself and never in a run. That is a separator. It marks boundaries and carries no content of its own.
That leaves 00 and 11 as the only two units that appear inside the groups. Two symbols, in a message about which you know nothing else, do all the real work.
It’s important to consider the cost of this. We have a four-symbol alphabet, and we’ve used half of it for punctuation. One symbol indicates where the message commences and how wide the units are. Another indicates where the rows break. Only two symbols carry meaning. A compression engineer would call this a disaster, and they would be correct. We are not compressing. We are doing the opposite of compressing, and that opposite has a name.
Rows of three
Strip the beacons and the separators, and one cycle of the body is this:
00 00 00
00 11 11
11 00 11
11 11 00
Four rows, three units each, and the rows follow a specific order. The first two columns cover every combination of the two symbols exactly once, in the same sequence you would use when counting: two of one kind, then one of each kind, then the other kind and one, and finally, two of the other kind. The third column changes but doesn’t show any clear pattern of its own.
This layout clearly presents a hypothesis. The first two columns methodically investigate their possibilities while the third responds to them. This creates a function. The first two units are inputs, the third is an output, and the setup shows the output for every input.
Write 00 as 0 and 11 as 1, and it turns into a truth table:
0 0 -> 0
0 1 -> 1
1 0 -> 1
1 1 -> 0
Stop at three rows
Cover the fourth row and look at what you have.
0 0 -> 0
0 1 -> 1
1 0 -> 1
Zero plus zero equals zero. Zero plus one equals one. One plus zero equals one. This suggests that the output is one when either input is one. That is inclusive OR, and it works perfectly for all three rows. If you have any programming experience, this is likely the first thing you write down.
Another interpretation fits all three rows just as well: the output is one when the inputs differ. This is exclusive OR, and nothing you’ve seen so far distinguishes it from the first interpretation.
The math here is precise and fundamental to the issue. There are sixteen possible functions from two binary inputs to one binary output. Each of the three rows you’ve seen defines one cell in the output column. Three defined cells leave one cell open, resulting in exactly two functions still possible. These examples took you from sixteen options to two. They couldn’t lead you to just one, and no amount of cleverness on your part could bridge that gap because the gap lies in the evidence.
You sensed something in the moment before you read this paragraph. It’s the feeling that the entire project is based on. You had a rule. It worked. You couldn’t tell if it was the right rule. Examples don’t define meaning; they narrow it down. This narrowing is real and powerful, but it always stops short of certainty until you run out of cases to present.
The fourth row
1 1 -> 0
Inclusive OR is dead, since it predicted one, but the message states zero. Exclusive OR predicted zero, and the message agrees. Now, exclusive OR is not just the better choice; it is the only survivor of sixteen. The table is now finished. There are no fifth cases, no input combinations left unspecified, and no space for a rival to hide. The function is clear.
This asymmetry makes all of this possible. A two-input binary function has exactly four points in its domain, and those four points can be listed. When the domain is finite, you can completely close the gap by showing everything, not just approximately. You do not define the function. You cannot define it because definition needs shared language, and there is none. You show it, and if you show all of it, showing and defining become the same act.
Also, note what the message never contained. It never had the word XOR, the word exclusive, or any name at all. There is no dictionary in it, and no place for a dictionary to hide. You recovered the function instead of its label, which is the only thing worth recovering because the label is a fact about English, while the function is a fact about logic.
What the message did not tell you
Here is a wrinkle that is worth considering.
We stated that 00 means false and 11 means true. We made this claim for clarity, but nothing in the message confirms it. What if we had it backward? What if 11 means false and 00 means true? If we switch the substitution, the table looks like this:
1 1 -> 1
1 0 -> 0
0 1 -> 0
0 0 -> 1
The output is one when the inputs agree. This is not exclusive OR; it is the equality function. If you cover the last row of that version, the two remaining options are AND and equality, rather than OR and exclusive OR.
The message does not show which function it teaches, and it cannot, because the two symbols are unlabeled. However, look at what survives the ambiguity. Under either interpretation, the fourth row eliminates the candidate that questions whether some marked state is present and keeps the candidate that asks whether the two inputs are the same or different. Both interpretations teach difference detection. The labels change, but the structure remains the same.
That is what really bridges such a wide gap. Not the names, which we created, and not the assignment of symbols to truth values, which is just a convention we follow. The relationship between the parts survives, and that relationship is the content. Everything else is just a layer of interpretation that the receiver can arrange in whatever order they like.
Two hundred bits to teach four
Count the payload. The inputs were expected once you recognized the counting pattern. The beacons and separators do not convey any logic. What the message actually provides is the output column: 0, 1, 1, 0. Four bits.
Two hundred bits were sent, and four bits of content were produced. The other 196 bits served as scaffolding, punctuation, framing, and repetition. These bits were used entirely to help four bits be discoverable by a receiver with no shared language, notation, convention, or prior contact with us. Fifty to one, and this ratio does not indicate a failure in the design. It is the design.
This is why we call it anti-cryptography. A cipher and a beacon are the same type of object pointing in opposite directions. Both focus on the distance between a signal and an agent without the key, and both are designed to control that distance precisely. The cryptographer aims to make the distance impossible to overcome, measuring success by how many centuries of computation an interceptor would need. We want to make the distance disappear, measuring success by how many minutes a stranger needs, using nothing but the signal and a pencil: same axis, opposite ends. The cryptographer hides the key within the recipient. We seek to craft a message that openly displays its key, so that an unknown mind will stumble upon it.
You did the whole thing in a couple of minutes without knowing what you were doing or that anyone intended you to. You found a period, inferred a unit width, resolved a phase, identified a delimiter, and recognized a function. You formed a hypothesis, held it while it was underdetermined, and discarded it when a counterexample arrived. That is the entire method. Nothing else in this series is different in kind from what you just did, only in scale.
From here, the ladder ascends. With difference detection, you can create equality. With equality, you can teach numbers by showing counts. With numbers, you can teach addition the same way we taught exclusive OR, by exploring part of it and allowing the receiver to generalize. Then comes quantification and the first real challenge of the entire task, as the domain stops being finite, and you can no longer close the gap by listing. Next are variables, then the structure of a proof, and finally, the physical constants that allow a message to describe the world it came from.
This is one step on a ladder that reaches much higher.