# Deterministic state

> Deterministic state means the same canonical inputs, configuration, build, and time basis always produce the same state — and when inputs contradict, the system holds rather than guessing a winner.

Category: Systems
Also searched as: reproducibility, determinism, replayable systems
Source: Mediator Solutions — https://mediatorsolutions.io/learn/#deterministic-state
License: free to read, learn, cite, and apply, with attribution to Mediator Solutions.

## What it is

A system that produces different answers from the same inputs cannot be audited, because there is nothing stable to check. Deterministic state fixes the inputs, the configuration, the build, and the time basis so a result reproduces exactly. On contradiction — duplicate identifiers with conflicting payloads — the safe state is a hold and exclusion, not an arbitrary choice.

## Why it matters

A system that answers differently from the same inputs cannot be audited, because there is nothing stable to point at; every dispute becomes a matter of whose run to believe. Determinism is what makes a result defensible rather than merely asserted. The hardest discipline is the fail-closed rule: on contradiction, holding and excluding feels like inaction, and the pressure is always to pick a plausible winner and move on — which is exactly how a convenient fiction becomes the record of truth.

## When to use it

- Building any system whose outputs must be auditable or defensible after the fact.
- A result will be disputed, and you need something stable to point at.
- Contradictory inputs arrive and the system must decide what the record of truth is.

## Principles

- Same canonical inputs, configuration, build, and time basis produce the same state.
- Time is an explicit input, so time-dependent state reproduces to the same snapshot.
- On conflict, hold and exclude rather than selecting an arbitrary winner.
- Computation uses exact arithmetic where correctness demands it — integer minor units for money, not floating point.

## Practice

1. Make every input to a computation explicit, including the time basis.
2. Pin configuration and build so a result can be re-derived later.
3. Define the conflict rule up front: contradictory inputs produce a hold.
4. Re-run from the same basis and confirm the state is identical.

## Where it fails

- **Convenient-fiction winner** — On contradiction, the pressure is to pick a plausible winner and move on, which writes a guess into the record as if it were truth.
- **Non-reproducible answer** — The same inputs produce different outputs across runs, so no result can be defended and every dispute becomes whose-run-to-believe.
- **Fail-open drift** — Holding on contradiction feels like inaction, so the system is quietly changed to always produce something, losing the integrity it existed to protect.

## In practice

Two sources report different balances for the same account. A fail-open system picks one and proceeds; the record now contains a guess. A deterministic, fail-closed system refuses to resolve the contradiction, holds the state as unresolved, and surfaces both inputs for a human to adjudicate. The second system is slower in the moment and correct in the record — and because it is deterministic, the same inputs will always produce the same hold, which is what makes the eventual resolution auditable.

## Verification

A result re-derives exactly from its recorded inputs, configuration, build, and time basis; contradictory inputs produce a documented hold rather than a silent choice.

## Reference

### Minimum receipt for a decision

- Timestamp
- Operator
- Input
- Transformation
- Output
- Approval state
- Source state
- Hash if available
- Next action

### Decision state labels (DRAFT is not CANONICAL)

- DRAFT
- PROPOSED
- VERIFIED
- APPROVED
- HELD
- QUARANTINED
- REJECTED
- CANONICAL

---

Previous: https://mediatorsolutions.io/learn/#objection-taxonomy
Next: https://mediatorsolutions.io/learn/#evidence-and-provenance