or I ≠ U
The sequel to Quines
Previously, we have played with Quines: programs that print their own source code. Self-reproduction. Little computational ouroboros. A charming party trick, like juggling — but for people who think parentheses are a personality.
This time I want the spicier cousin: not “can I copy myself?” but “can I recognize myself?” Same self-reference energy, but with more side-eye.
Origin story: “I neq U”
I’ve been using the name Inequ since 2005 — short for “I neq U” (and yes, also an anagram of quine, because I am incapable of leaving a good pun alone). In that original post, I framed self-recognition as “the ability to tell if I am different (not equal) to you,” then defined an Inequ as a program that reads text from stdin and exits 0 only if it recognizes that text as the same as itself.
A Quine says say me. An Inequ says see me.
Identity by paperwork
The strictest Inequ is hilariously bureaucratic. You paste some program text into stdin. It compares that text to its own source text. If every character matches — same bytes, same newlines, same everything — it says “yes” (exit 0). Otherwise it says “no” (non-zero), as if you showed up at the airport with a boarding pass that says “Jas?” and expected vibes to carry you through.
This version is shallow, but in a very honest way. It’s the computational equivalent of recognizing yourself only in one specific passport photo: same angle, same lighting, same haunted look in the eyes.
And honestly? That’s already a pretty good mirror.
The mirror test, but for code
We like to imagine “self-recognition” is deep and philosophical. But in real life, it starts out embarrassingly literal. Babies don’t pop out passing the mirror test. They see the mirror and think: hello, other baby; we should either become friends or start a rivalry.
Then, eventually, something clicks: the reflection is tethered to their body and actions. “That’s me” becomes a stable concept, not just a visual coincidence.
The strict Inequ is basically at the toddler stage. It doesn’t recognize itself across transformations. It recognizes itself in one very specific mirror, under perfect conditions, wearing the same outfit, with the same lint on the sweater.
And naturally, we immediately demand more.
“But what if it’s still me… with a haircut?”
The first upgrade people ask for is harmless: could it ignore whitespace? Comments? Line endings? Could it recognize itself after someone prettified it, or after a formatter did what formatters do: destroy your identity in the name of consistency?
This is where the definition of “self” starts doing work. Are you your exact text, or your structure? If you parse both programs into an abstract syntax tree (AST) and compare those, you’ve built an Inequ that can survive cosmetic changes. Congrats: your program can now recognize itself in candid photos.
Then you go one step further and ask the question that sounds reasonable until it ruins your weekend:
What if the input program is different text but the same meaning? Same behavior, different implementation. Same person, different life choices.
Now you’ve crossed the line from “string equals string” into “what does this code do?”
Welcome to the part where computer science becomes less like a clever puzzle and more like a stern cosmic boundary marker.
Rice’s Theorem: the universe’s terms of service
There’s a famous result in computability called Rice’s Theorem. Roughly: any non-trivial general question about what arbitrary programs mean is undecidable.
So the dream Inequ — the one that recognizes itself through refactors, rewrites, and alternate implementations — runs into a wall that isn’t made of poor engineering. It’s made of math. This isn’t “hard like chess is hard.” It’s “hard like you can’t make a square circle.”
It’s “hard like you can’t make a square circle.”
You can absolutely do practical versions in restricted worlds: normalization, canonicalization, testing, proof systems for specific languages, all that good stuff. But the universal “are we the same in meaning?” detector for arbitrary programs is the kind of thing the universe declines to provide on principle.
Which is both annoying and, weirdly, comforting. Even code gets to have limits to self-knowledge.
The tiny sandbox: a self-recognizing regex
My favorite side quest (from that same original thread) is the regex version: can you write a regular expression that matches only itself?
Not “a regex that matches the letter ‘a’ and therefore matches the string ‘a’.”
(By the way, if you think I did not delibrately construct that sentence so I had to have nested quotes, you don’t know me!)
That’s too easy and also matches half your inbox. I mean a regex whose accepted language is basically: just me, myself, and I.
If your regex is too loose, it matches itself… and a bunch of other strings. That’s the “I contain multitudes” identity phase where your definition of “me” is so broad that everyone qualifies.
If your regex is too strict, it excludes itself. That’s the “I have standards” identity phase where you define yourself so precisely you accidentally legislate yourself out of existence.
It’s a perfect miniature of the main problem: self-recognition depends on what differences you’re willing to ignore, and the moment you formalize that, edge cases appear like they were invited.
What does it mean to recognize yourself?
Here’s the part I can’t stop thinking about: self-recognition is not a single question; it’s a stack.
At the bottom: exact textual identity. Crisp, brittle, often useful.
Higher up: structural identity. Ignore formatting and cosmetics. Now you can survive a haircut.
Higher still: semantic identity. Meaning, behavior, equivalence. The grown-up version of “me.” And that’s where theory taps the sign: no universal oracles beyond this point.
“The moment you ask for ‘same meaning,’ computer science quietly takes your hope and puts it in a drawer.”
So when we ask “can a program recognize itself?” we’re really asking: which transformations preserve identity? Which changes don’t count as “becoming someone else”? And the moment you say that out loud, it stops sounding like a programming trick and starts sounding like… a human problem.
Takeaway: identity is compression
Identity is a compression scheme. To recognize yourself, you compress messy, high-resolution reality into a signature you can compare. You pick invariants. You decide what can change without changing “you.”
Quines are self-portraiture: here is me.
Inequ is self-concept: I can tell me from not-me.
And the punchline is that the more human you want that second statement to be, the more the universe reminds you: self-knowledge isn’t free — not for toddlers, not for monkeys, and not for programs.
Question for the comments
If you were designing an Inequ, what would you allow it to ignore before it stops being “you”? Formatting? Comments? Variable names? Refactors? Whole rewrites?
And at what point does “same program” become “same vibes” — and do we ship vibes to production? Is it easy to characterize the largest set of inequ?
I Am Not U was originally published in Recursive Rhymes on Reason on Medium, where people are continuing the conversation by highlighting and responding to this story.