# Law Sets And CPU Tiebreaking
An algebraic law set constrains an operation, but it does not automatically
uniquely characterize that operation. Exact behavior is defined by the CPU
reference. Laws catch structural regressions and document algebraic intent; the
CPU reference is always the tiebreaker for point semantics.
## XOR
XOR satisfies this law set:
```text
Commutative
Associative
Identity(0)
SelfInverse(0)
```
These laws describe an abelian group where every element is its own inverse and
the identity is zero. They do NOT uniquely characterize bitwise XOR over `u32`.
For any permutation `phi` of `u32` that fixes `0`, the operation
`f(a, b) = phi^-1(phi(a) XOR phi(b))` satisfies all four laws. If `phi` is not
the identity, `f` is a distinct operation with the same law set.
Therefore, a backend must still match the CPU reference for exact XOR behavior.
The law set is useful and permanent, but it is not a complete specification.
## ADD
Addition with wrapping arithmetic satisfies:
```text
Commutative
Associative
Identity(0)
```
That set is not unique. XOR also satisfies all three laws. Therefore these laws
prove useful structure for `Add`, but they do not fully characterize wrapping
addition. A backend that implemented XOR could satisfy that law set while still
failing point parity against the CPU reference for inputs such as `Add(1, 1) =
2`.
## When Laws Are Insufficient
Operations in this registry should be assumed not to have compact law sets that
uniquely define them. Division, modulo, comparisons, clamping, extraction,
insertion, bitwise operators, arithmetic operators, and buffer operations
require explicit point semantics. Their laws are still valuable because they
catch classes of bugs, but the CPU reference is the tiebreaker for exact
behavior.
The registry must be honest about this. A law set must not be described as
complete unless there is a proof that no distinct operation satisfies the same
laws. Coverage reports should distinguish "all declared laws passed" from
"the backend matched the CPU reference."
## Policy
Make law sets as constraining as possible without declaring false laws. Add
negative examples when proposing new law types so the law is known to
discriminate between operations. Use the CPU reference as the permanent
tiebreaker for all operation behavior.