open-standards/wai/extensions/determinism-tiers.md

# WAI Extension: Determinism Tiers for Neural Decode

> Status: Draft. Names the **spectrum** of reproducibility guarantees a neural
> capability can make, so a manifest can declare which one it satisfies and a
> verifier knows what it may check. Positions WAI's byte-exact reconstruction
> (`decode-equivalence`) as the strongest tier above the entropy-stage guarantee
> the base learned-codec field provides. No new wire format; a vocabulary +
> conformance framing over §7.
> Keywords **MUST**, **MUST NOT**, **SHOULD**, **MAY** are RFC 2119/8174.

## 1. Why tiers

Neural decode reproducibility is not binary. A float neural decode is *not*
reproducible at all — round-off diverges across hardware, and one diverging bit
corrupts a learned entropy decode. In response the field has converged on making
the **entropy stage** reproducible while leaving reconstruction to pixels
implementation-defined. Two facts make this concrete:

- **The base standard.** JPEG AI (ISO/IEC 6048) defines its normative bit-exact
  conformance point at the **output of the entropy decoder**, not at
  reconstruction to pixels; its entropy pipeline is integer so that stage
  replicates across devices, while post-entropy processes MAY diverge. One
  codestream may legally reconstruct through up to three synthesis transforms.
- **The learned-codec field.** The mainstream cross-platform fix is **explicit
  parameter transmission** — carrying the entropy/scale parameters in the
  codestream so the entropy decode is consistent across devices *without* requiring
  bit-exact arithmetic. Same target: a reproducible entropy stage, a
  reconstruction that may vary.

WAI supports that guarantee **and a stronger one**. Naming both lets a capability
be honest about which it makes, and lets a receipt or a provenance binding
(§[reconstruction-binding](reconstruction-binding.md)) demand the tier it needs.

## 2. The tiers

### `entropy-consistency`

The **entropy decode** reproduces byte-for-byte across devices — the decoded
symbols / quantized latent have a portable hash — but the reconstruction to the
final medium (pixels, samples) MAY differ between conforming sinks. A sink
achieves this either by **integer entropy arithmetic** (deriving the coding
parameters with fixed-point ops, as WAI's integer decoders and JPEG AI's entropy
pipeline do) or by **explicit parameter transmission** (the codestream carries the
parameters, so no bit-exact derivation is required).

- Conformance criterion: *entropy-equivalence* — a verifier decodes the entropy
  stage and compares the symbols / quantized latent, NOT the pixels.
- This is the guarantee the base learned-codec standard and the mainstream
  cross-platform techniques provide. It is the **floor** for a sound neural
  `replicate` under §7: enough that the decode does not catastrophically desync,
  not enough to hash the rendered result.

### `decode-equivalence`

The **whole decode to the final medium** reproduces byte-for-byte across devices —
the reconstructed pixels (or samples, or attributes) have a portable hash. The
sink pins **one** reconstruction and runs it in integer / fixed-order arithmetic
end to end, entropy *and* synthesis. Where the base codec admits several
conformant reconstructions, this tier fixes one.

- Conformance criterion: the medium's `*-equivalence` (e.g. *decode-equivalence*
  for `wai.image.jpegai`, *sample-equivalence* for `wai.audio.int_codec`,
  *splat-equivalence* for `wai.splat.int_codec`).
- This is WAI's contribution above the field's baseline: it is a determinism
  guarantee **beyond what the base standard requires**, and it is the precondition
  for a hard provenance binding over the *rendered* content — a decoded-pixel hash
  is only portable when the reconstruction is pinned.

A capability satisfying `decode-equivalence` satisfies `entropy-consistency` by
construction; the reverse does not hold.

### What a tier covers

A tier is a property of the **whole path from codestream to the medium that is
hashed, bound, or presented** — not of the decode stage in isolation. A sink that
decodes conformantly and then alters the result has not satisfied the tier,
however faithful the decode itself was.

This is not hypothetical. Two mechanisms in force today change the medium *after*
a conformant decode, and both arrive through the same pipe as the codestream:

- **Post-decode neural filters.** ITU-T H.274 (V4, 01/2026) `nnpfc` / `nnpfa` SEI
  messages activate a neural post-filter after decoding, changing output pixels.
  The filter may be named by URI or carried in-band.
- **Operation-reduction hints.** ISO/IEC 23001-11 (green metadata) carries
  decoding-operation-reduction metadata whose express purpose is to let a decoder
  spend fewer joules by doing less work — deliberate degradation, signalled
  in-band and invisible to a conformance check that stops at the decoder.

The rules:

- A sink claiming a tier MUST evaluate it over the medium it **emits**. If it
  applies post-decode processing that alters that medium, it MUST either not
  apply the processing, or MUST NOT claim the tier for the emitted result.
- An object that honours a decoding-operation-reduction hint MUST NOT claim
  `decode-equivalence`, and a receipt over its output MUST NOT carry a
  reproducible decoded-medium hash. Spending fewer joules by computing less is a
  fidelity choice; a receipt that reports the joules while concealing the
  degradation states a cost without its consideration.
- A capability's registration SHOULD state whether its payload can carry
  post-decode processing directives at all. A capability whose payload cannot is
  unaffected by this section, and saying so is cheaper than leaving it open.

The general rule, which is why this section exists: **a determinism claim covers
what the sink emits.** A hash over a decode that something later modified
describes an artifact nobody saw — the hash verifies, and it attests the wrong
thing.

## 3. Declaring and using a tier

- A capability's registration (§5) states its tier via its `*-equivalence`
  criterion; the WAI capabilities that decode a learned image/audio/3D latent to
  bytes (`wai.image.jpegai`, `wai.neural.int_*`, `wai.audio.int_codec`,
  `wai.splat.int_codec`) are `decode-equivalence`. A capability MAY instead
  declare `entropy-consistency` when it only guarantees the entropy stage.
- **`replicate`-soundness (§7).** An envelope with `intent = replicate` MUST pin a
  prior that meets at least `entropy-consistency`; a float neural decode meets
  neither tier and MUST NOT claim `replicate`. A receipt that carries a
  reproducible decoded-medium hash MUST come from a `decode-equivalence`
  capability.
- **Post-decode processing.** A tier claim is void if the sink alters the medium
  after decode (§2, *What a tier covers*). This applies to the emitted result,
  not to the decoder's internal conformance.
- **Provenance.** The [reproducible-reconstruction binding](reconstruction-binding.md)
  — a C2PA / JPEG-Trust hard binding over decoded pixels — requires
  `decode-equivalence`; over an `entropy-consistency` capability only the
  entropy-stage output is bindable, not the rendered result.

## 4. Framing

Both tiers here are **reproducibility** guarantees: a sink can check them from the
bytes it received. A separate axis exists for media whose correctness is a
downstream model's behaviour rather than a byte comparison — see
[task-fidelity](task-fidelity.md), which is a sibling rather than a third tier
precisely because such a claim is *not* sink-checkable from the bytes.

WAI spans the spectrum rather than competing on one point of it. The
`entropy-consistency` tier is the base learned-codec floor — the guarantee the
field and the underlying standards already make — and WAI supports it directly.
`decode-equivalence` is the tier WAI adds on top: pinning one full reconstruction
so the rendered result, not only the entropy stream, is reproducible and
hashable. Both are stated as capabilities of the standard, not as comparisons.