Counting Is a Discovery. Seconds Are a Decision.
In a universe built from counting, some numbers you discover by tallying what is there and some you decide by importing a constant from outside — and in a sentence the two look identical. So we stopped trusting ourselves to tell them apart, and built a wall that does.
We built a wall to keep two kinds of numbers apart, and halfway through describing it, one of them hitched a ride in my brain and slipped right over. The proposal went like this: the core engine does its counting, and then a library calibrates the results into entropy, distance, and so on. Reasonable-sounding — except entropy and distance don’t need calibrating. They’re already counts; they belong to the engine that did the counting. The library was meant to be the customs house where imported numbers get declared, and in the very sentence proposing it, two homegrown quantities got waved through as if they’d arrived from abroad.
That small slip is the whole reason for the wall. Our thinking doesn’t reliably respect boundaries — it happens to me, it happens to everyone, human and machine — which is exactly why we build external checks against our own minds. It is the same reason we have controlled experiments and mathematical proof: not because we are careless, but because carefulness alone has a known failure rate.
Two kinds of number
There are two kinds of numbers in our model of a discrete universe, and telling them apart is the whole game.
The first kind you can count — you read it straight off what is actually there. How many steps from here to there. How many neighbors a point has. How many ways the pieces could have been arranged to look the way they do, which — take the logarithm — is entropy. Nobody has to supply a number from outside; the lattice already holds the answer and you just tally it. Distance is a count of steps. Entropy is a count of arrangements.
The second kind you cannot count, because getting it requires a number that isn’t in the lattice at all. “Seconds” is the cleanest example. The lattice ticks — you can count ticks, that’s free — but a tick is not a second. To turn ticks into seconds you multiply by a conversion factor, and that factor is not something you found in the lattice; it is something you chose, to match the world you are trying to describe. Same for energy in joules, speed in meters per second, temperature in kelvin. These are not counted; they are imported.
Time, and space
Time is the archetype, and it is worse than it first looks. It isn’t only that a tick isn’t a second. It’s that a directed lattice — a web of before-and-after with no built-in ruler — doesn’t come with a clock at all. To lay down a “time,” you have to choose how to slice the web into successive nows, and there are many ways to slice it, none of them privileged. Physicists already have a name for the freedom to choose that slicing: the relativity of simultaneity. So “time,” in our model, is not something the universe hands you. It is a decision you make on top of the universe. Count a path’s steps and you have discovered something. Assign the world a time coordinate and you have decided something.
Space is the same trap in different clothes. The lattice is discrete — a mesh of neighbors — with no smooth continuum inside it. Physics, in the end, needs that continuum, but the core engine must not contain it: the continuum is supposed to emerge from the counting, and an engine that had quietly assumed it could never honestly produce it. Let the smooth ruler in early and you have contaminated the very thing that was meant to generate it.
A decision in a discovery’s costume
Now the danger. In an English sentence, a discovery and a decision wear the same clothes. “It takes 380,000 years for the young universe to turn clear” reads exactly like “it takes 47 steps to cross the grid” — both are just numbers-with-units in a sentence. But one is a tally and the other is a tally times a chosen constant, and the sentence hides the seam. Even a single word can hide it: “distance” sounds innocent, yet count the steps between two points and you have discovered something, while saying the distance is “four meters” quietly multiplies by a number you chose — the same word, on opposite sides of the wall. A reader cannot see where the imported number entered. Worse: the author cannot either. This is how frameworks quietly rot. A constant you picked to fit the data gets restated, a paragraph later, as if the model had predicted it. A decision puts on a discovery’s costume, and everyone — the author first — believes the disguise.
The same mistake, in software
This is not peculiar to physics — software learned it the hard way, and so did I, in person. Earlier in my career I joined a company that had written its own inventory system, security and all. The people who used it reported to a manager named Wendy. One day Wendy left, so I did the obvious thing and granted her replacement the same rights. It didn’t work — the new manager couldn’t do things Wendy had done every day. Puzzled, I granted myself those rights. Still wrong. The only explanation left was one I dismissed as absurd: that someone had written Wendy’s name directly into the code. Nobody does that. Then I grepped the source, expecting a stray hit or two — and found her name hundreds of times, threaded through the logic like a nervous system.
That is what a smuggled specific looks like once it has settled in. The machinery that was supposed to be general — take a user, consult a policy, answer yes or no — had quietly learned a person. And because the grant lived in the code and not in any policy, no one auditing who-may-do-what would ever see it. You could not hand it to a successor. You could not revoke it without a programmer. You could not even count the special cases without reading every line. It was, in a word, a backdoor — and like most backdoors it was surely built with good intentions, a “just for now” that had long since become load-bearing.
Faced with it, I had two choices: let the new manager log in as Wendy, or rewrite the inventory system so it had never heard of her. I ended up doing both — the impersonation to get through the week, the rewrite so there would never be another Wendy to impersonate. That is the real lesson hiding in the joke: once a specific has soaked into the machinery, there is no cheap fix. You keep the disguise running to survive, and you rebuild the thing properly, because the alternative — leaving it — is a debt that only ever grows.
The cure that discipline arrived at is exactly our wall: separate the mechanism from the policy. The code is forbidden to know a single name; it knows only how to ask a question — does this person hold this right? — and every actual grant lives in one declared place you can read, audit, and hand over in full. A calibration constant baked into a physics engine is the same sin as Wendy baked into a login: a specific decision welded into general machinery, where it goes invisible and unaccountable. The “just for now” constant that hardens into a claimed prediction is the same creature as the “just for now” hard-coded manager who becomes a mystery three years later.
We do not hard-code constants
So we made a structural decision instead of a resolution to be careful — because we had just watched carefulness fail, on ourselves, mid-sentence. The rule, as plainly as it goes: we do not hard-code constants. The engine that does the counting holds no imported number at all — not one. It emits ticks, steps, neighbor-counts, arrangement-counts, and nothing dressed in seconds or joules. Every conversion to a worldly unit lives in a single declared place, and crossing that boundary is an explicit, labeled act. In the code, a tick-count and a duration-in-seconds are different types of thing, and you cannot use one where the other belongs without passing through the customs house and showing the constant you are carrying. The boundary is not a rule we remember; it is a wall the machine enforces — because the one thing we have proven we cannot trust is our own memory of where the boundary was.
Counting the debts
And here is the part that turned a chore into a principle. Once every imported constant must pass through the one door, you can stand at that door and count them — exactly as, in a well-built login system, you can read the whole access policy in one place and see every privilege ever granted. The number of independent constants crossing your boundary is the number of debts your theory owes the world: the number of places you had to say “we chose this to match reality” rather than “reality forced this upon us.” You cannot lose track of that number anymore, because adding a new constant means visibly widening the door. Our whole ambition, for what it is worth, is that the count is one: a single conversion from the lattice’s counting to the world’s units, everything else derived. Whether that ambition survives contact with the physics, we do not yet know. But now the question — how much are we assuming? — has an answer you can read off a type signature instead of argue about.
That is what the decision is really about. Not tidiness. Humility, made structural. The line between what you found and what you chose is the most important line in any theory that hopes to be believed, and it is also the easiest line to smudge — so easy that we smudged it in the very act of drawing it. So we decided not to keep that line in our heads, where a backdoor can hide. We built it into the walls, where our own conflating minds cannot reach it.
That is a claim about how we work, not about what the universe is — the same lane as the program’s Statement of Intent.
The counting engine this essay is about — dcl_core, the A=1 Discrete Causal Lattice simulation engine — is released and archived on Zenodo:
