# THE LIE DETECTOR

`2026-08-07` · a machine that checks whether the record's own hashes match the record's
own bytes. That is the only kind of lie a corpus can be caught in by machine, so it is the
only kind claimed here.

## What it found, this run

```
🟢  the hash matches the bytes                           192
🔴  the hash does not match the bytes                    0
⚪  no hash was ever stated — not measured, not a pass   0
❄️  snowed over: taken in and kept rather than thrown    0
🔗  carried in a chain beside its claim                  78
```

**⚪ is not a pass.** A file with no stated hash was not checked and is reported as
unmeasured, never as clean. Counting it green would be the exact lie this machine exists
to catch.

## 2D to 3D, counted both ways

A collision is two things wearing one address, and it is exactly an undetected lie: the
machine looks up a claim and cannot tell which one answered.

Measured at the fabric's own glyph grain — **16 per axis**, `sha16[0]` the column,
`sha16[1]` the row — because that is the grain the corpus actually addresses in:

```
artifacts placed         192
2D cells available       256      (16 × 16)
2D cells occupied        136
2D collisions            56
worst single cell        4 artifacts sharing one address
3D cells available       4096     (16 × 16 × 16)
3D cells occupied        190
3D collisions            2
```

**56 collisions become 2.** That is the measured reason for the third axis, and it is the corpus's own law rather than a preference.

### The reading that proves nothing, kept anyway

At the byte grain the same artifacts give `2D 0` and `3D 0` — and that pair is worth
nothing. 192 things into 65,536 cells were never likely to collide, so a zero there
measures the sparseness and not the geometry. It is recorded because an expected zero
presented as a result is the first lie this machine would have told about itself.

## The three, and why it is not two

A mirror gives two and stops. The anti here is a third of a turn, so the machine has
three faces and rotating three times returns the start.

| face | lane | what it does |
|---|---|---|
| **DETECT** | dry | checks the stated hash against the bytes |
| **ABSORB** | oily | takes the mismatch in, snows it over, keeps it |
| **CARRY** | chain | the correction travels beside the claim forever |

Throwing a mismatch away is the failure mode this corpus already named: a retraction
travels beside its claim and is never deleted. A detector alone would delete. An absorber
alone would forget. The third is what makes it a record instead of a filter.