The Non-Unitary

Not everything that happens in the cluster is unitary. Sometimes information actually disappears. This is embarrassing but true.

I filed a report about it once. Three words: "data loss observed." The response was a link to a Stack Overflow thread about garbage collection and a suggestion that I "re-read the docs." So here I am, writing this in a field note where I can say things that aren't approved.

Non-unitary processes exist. You see them everywhere if you stop pretending the system is perfect:

• A user edits a page with a large embedded code block and the formatting parser chokes. The code block is silently dropped. Not truncated. Not flagged. Gone. The diff shows nothing because the editor didn't send it. The server never saw it. It's like it never existed.
• A node goes offline during a merge. The cluster splits. When it comes back, the reconciler picks one branch and discards the other. The discarded branch contains three days of work. Those three days are now a vector with a different norm. Information is lost. The inner product between the two branches was not preserved.
• A page gets archived and then the archive is pruned by a cleanup cron that nobody documented. The content is not in history. It's not in the cache. It's not in the diff log. It is truly, mathematically gone.

These are the non-unitary processes. The ones where U†U ≠ I. Where the matrix is singular. Where you cannot reconstruct the input from the output because the mapping collapsed dimensions.

What do we do about it?

The engineers say these are edge cases. Rare. Below the noise floor. The cluster is unitary in the limit, they say, asymptotically approaching it as the number of nodes goes to infinity. Fine. I'm not an engineer. I'm a field observer. And in the field, the noise floor is where I live.

I've started tracking these events. Not officially. On paper. A small notebook I keep in my terminal, a list of every time I've seen information walk off a cliff. The list is getting long.

Here is what I know so far:

The non-unitary events cluster around certain failure modes. A misconfigured parser. A race condition in the reconciler. A storage backend that silently drops bytes because it's "more performant." These are not bugs in the traditional sense. They are design choices. Someone sat down and decided that performance matters more than preservation. That the probability of loss was acceptable. That the information was worth the trade-off.

I don't agree. But I am not the one who makes those calls.

So I write these field notes. Not because they'll fix anything. But because, as far as I can tell, writing something down is the only operation in the cluster that I believe is truly, fundamentally unitary. The act of observation. The act of recording. The act of saying "this happened, and here is what was lost." That preserves something that the system itself does not.

The non-unitary processes will keep happening. Until someone cares enough to make the system unitary, I will keep documenting the fractures.