# Laws Versus Reference
vyre-conform has two authorities because operation correctness has two
different shapes: point truth and structural truth.
## CPU Reference: Point Truth
The CPU reference answers exact questions:
```text
input bytes -> output bytes
```
For `BitXor(3, 5)`, the CPU reference returns `6`. For `Div(5, 0)`, it
returns `0`. For any generated input, parity verification compares backend
bytes to the CPU reference bytes. This catches implementations that compute the
wrong function even when their output looks mathematically plausible.
## Algebraic Laws: Structural Truth
Algebraic laws describe the shape of the function:
```text
f(a, b) = f(b, a)
f(f(a, b), c) = f(a, f(b, c))
f(a, 0) = a
```
Laws catch bugs on input families, including inputs not explicitly generated
for parity. A backend that passes many point tests can still violate
associativity, identity, monotonicity, boundedness, or another declared law.
That violation is a proof of non-conformance.
## Why Both Are Required
Laws alone may not uniquely identify the intended operation. Addition and XOR
are both commutative, associative, and have identity `0`, so that law set alone
cannot distinguish them. The CPU reference breaks the tie.
The CPU reference alone only checks inputs the suite asks about. An
implementation can match all generated examples and still diverge elsewhere.
Laws constrain behavior across the domain and catch structural defects that
sampled parity misses.
Together they are stronger than either alone. The CPU reference anchors exact
outputs. The laws constrain the function's mathematical identity. Equivalence
classes and boundary values make sure the generated point queries are
distributed across meaningful regions.
## Disagreement
A declared law and a CPU reference must not disagree. The suite self-tests the
CPU reference against every declared law. If the CPU reference violates a law,
there is no valid conformance claim for that operation because the
specification contradicts itself.
When self-test passes, a future backend law failure is a backend failure. When
self-test fails, the operation registry entry is invalid and must be corrected
or versioned before any backend certificate can rely on it.