From 93c5542b7a2fab8a9de6ad62ef488f8ead0bd6fa Mon Sep 17 00:00:00 2001 From: Transaction Science Date: Mon, 7 Sep 2026 04:37:48 -0400 Subject: [PATCH] register what other bodies ratified: prior carriage, and derived-track operations MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Two ingests of the same shape — name someone else's ratified work rather than restate it, and add only the thing they left unspecified. PRIOR CARRIAGE. WAI pins a prior's IDENTITY and says nothing about its FORM. The digest fixes which bytes; nothing fixes how those bytes are packaged, so a prior is in practice an informal directory — a layout convention between implementations that happen to agree. Two conforming implementations can hold the same digest over differently-arranged artifacts and neither is wrong, because the specification never said what the artifact is. That bites precisely where WAI is strongest: a determinism tier is a claim about reproducing a computation, and a computation whose operand has no wire form is reproducible only among parties already sharing an unwritten convention. ISO/IEC 15938-17 is that form — the first international standard for neural network compression, second edition 2024, covering trained parameters and their incremental updates, with an open reference implementation. Where a prior is carried in it the digest MUST cover the coded bitstream rather than an unpacked directory (a digest over an unpacking is a digest over one implementation's choices), and two priors MUST NOT be treated as interchangeable because their unpacked parameters compare equal. Scope discipline is explicit, because the survey's one unresolved flag sits here: this is CARRIAGE, NOT AUTHENTICITY. Work on signing individual coded data units within that standard is at amendment stage and could not be corroborated from public sources, so nothing here depends on it and an implementation MUST NOT cite this section as authority for a signing claim. Incremental update is likewise not new — it landed in the published second edition. DERIVED TRACKS. Stated plainly at the top because the tree needs it said: a track carrying a process the receiver evaluates is NOT NEW. ISO/IEC 23001-16:2021 ratified derived visual tracks five years ago inside the container the industry already ships. Any WAI text claiming instruction-carriage as its invention is wrong and should be corrected on sight. What that specification leaves unspecified is what WAI adds: a determinism contract per operation, and a signed receipt binding the executed graph to measured joules. So each operation MAY register as a capability and MUST state its tier; an operation involving interpolation, blending or resampling MUST NOT register at decode-equivalence unless the registration also pins the arithmetic — naming an operation does not make it deterministic — and a derived sample's tier is the WEAKEST among the operations it invokes, because a graph is as reproducible as its least reproducible step. Two qualifications kept in the text rather than dropped: the base operation set includes blending operations with no bit-exactness requirement, so the tier work is substantive; and derived visual tracks have negligible deployed player support, so the collision is standards-level, not installed-base. Neither extension makes WAI a renderer, and §3 of derived-tracks says so. Ingest queue items 9 and 12 (#80 §6.4, §3.1). Co-Authored-By: Claude Opus 5 --- wai/extensions/derived-tracks.md | 55 +++++++++++++++++++++++ wai/extensions/prior-carriage.md | 75 ++++++++++++++++++++++++++++++++ 2 files changed, 130 insertions(+) create mode 100644 wai/extensions/derived-tracks.md create mode 100644 wai/extensions/prior-carriage.md diff --git a/wai/extensions/derived-tracks.md b/wai/extensions/derived-tracks.md new file mode 100644 index 000000000..63c6308fa --- /dev/null +++ b/wai/extensions/derived-tracks.md @@ -0,0 +1,55 @@ +# WAI Extension: Derived Tracks + +> Status: Draft. Registers the derivation operations of a ratified container +> track type, so WAI can carry a derivation graph without restating it and +> without claiming to have invented it. +> Keywords **MUST**, **MUST NOT**, **SHOULD**, **MAY** are RFC 2119/8174. + +## 1. Prior art, stated plainly + +A track that carries a **process the receiver evaluates**, rather than the +processed result, is not new. **ISO/IEC 23001-16:2021** — Derived Visual Tracks +in the ISO Base Media File Format — ratified it in 2021, inside the container the +industry already ships. A derived sample is an ordered list of derivation +operations over an ordered list of inputs; inputs may be tracks, track groups, +image items, or the output of a preceding operation, so operations chain. + +WAI's contribution is therefore **not** instruction-carriage. Any WAI text +claiming otherwise is wrong and should be corrected on sight. What that +specification leaves unspecified — and what WAI adds — is a **determinism +contract per operation** and a **signed receipt binding the executed graph to +measured joules**. + +Two honest qualifications. The base operation set includes interpolating and +blending operations with no bit-exactness requirement, so the tier work below is +substantive rather than decorative. And while the container is universally +shipped, derived visual tracks have negligible deployed player support: the +collision is at the standards level, not the installed-base level. + +## 2. Registration + +Each derivation operation **MAY** be registered as a WAI capability, and a +registration **MUST** state the operation's determinism tier per +[`determinism-tiers`](determinism-tiers.md). + +- An operation whose output is fixed by its inputs under integer arithmetic + **MAY** be registered at `decode-equivalence`. +- An operation involving interpolation, blending, or resampling **MUST NOT** be + registered at `decode-equivalence` unless the registration also pins the + arithmetic that makes it reproducible. Naming an operation does not make it + deterministic. +- A derived sample's tier is the **weakest** tier among the operations it + invokes, and an implementation **MUST NOT** report the strongest. A graph is + as reproducible as its least reproducible step. +- A registration **MUST** identify the operation by its four-character code as + defined in the source specification, not by a local name. + +## 3. Scope + +WAI registers the operations and tiers them. It does **not** adopt compositing as +its own responsibility: presentation and rendering are sink-supplied elsewhere in +this tree, and that does not change here. Tiering and receipting a derivation +graph is a statement about reproducibility and cost, not an undertaking to +composite. + +An implementation **MUST NOT** read this extension as making WAI a renderer. diff --git a/wai/extensions/prior-carriage.md b/wai/extensions/prior-carriage.md new file mode 100644 index 000000000..423309402 --- /dev/null +++ b/wai/extensions/prior-carriage.md @@ -0,0 +1,75 @@ +# WAI Extension: Prior Carriage + +> Status: Draft. Names a normative wire form for the artifact a `Prior` refers +> to. WAI pins a prior's **identity** today and says nothing about its **form**, +> so two implementations holding the same hash may hold differently-packaged +> bytes and neither is wrong. +> Keywords **MUST**, **MUST NOT**, **SHOULD**, **MAY** are RFC 2119/8174. + +## 1. Identity without form + +A neural capability's reconstruction depends on a model the wire does not carry — +that is deliberate, and [SPEC.md §1](../SPEC.md) is explicit that the model +behind a neural capability is never transported. WAI pins the model's identity +so a replicate is sound: a `Prior` names an id, a digest, and a determinism +expectation, and `replicate` soundness is gated on it. + +What is missing is one level down. The digest fixes **which bytes**, and nothing +fixes **how those bytes are packaged**. In practice a prior is an informal +directory — a layout convention between implementations that happen to agree. +Two conforming implementations can hold the same digest over differently-arranged +artifacts, and the specification gives no way to say which is right, because it +never said what the artifact is. + +This matters precisely where WAI is strongest: a determinism tier is a claim +about reproducing a computation, and a computation whose operand has no wire form +is reproducible only among parties who already share an unwritten convention. + +## 2. The normative form + +The artifact a `Prior` names **SHOULD** be a coded neural-network bitstream in +the form of **ISO/IEC 15938-17** — the first international standard for neural +network compression, whose second edition (2024) covers trained parameters and +their incremental updates, with DeepCABAC entropy coding and +pruning / sparsification / low-rank preprocessing, and an open reference +implementation. + +- Where a prior is carried in that form, the `Prior` **MUST** say so, and the + digest **MUST** cover the coded bitstream, not an unpacked directory. A digest + over an unpacking is a digest over one implementation's choices. +- Where a prior is carried in another form, the `Prior` **MUST** name that form. + "A model" is not a form. +- An implementation **MUST NOT** treat two priors as interchangeable because + their unpacked parameters compare equal. Determinism claims are made about a + pinned artifact, and equality after unpacking is not the same fact. + +WAI registers the capability and references the bitstream. It does **not** restate +the coding, and the sink supplies the decoder — the same posture as every other +capability in the tree. + +## 3. Scope discipline + +Two things are deliberately not claimed here. + +**This is carriage, not authenticity.** The referenced standard is a wire format +for the artifact; it is not an alternative to WAI's receipt layer, and this +extension does not present it as one. Work on signing individual coded data units +within that standard is at amendment stage and could not be corroborated from +public sources at the time of writing — so nothing here depends on it, and an +implementation **MUST NOT** cite this section as authority for a signing claim. + +**Incremental update is not new.** Coding of incremental and federated updates +landed in the published second edition. An implementation **MUST NOT** describe it +as a forthcoming capability. + +## 4. What this unblocks + +With a form fixed, three things become statable that were not: + +- a determinism tier over a computation whose operand is identified rather than + assumed; +- a prior transported by reference with a digest that means the same thing to + both ends; +- the split-computation case in [`task-fidelity`](task-fidelity.md) §5, which + needs a network-identity hash making two halves provably compose — this section + supplies the identity half, and not the composition half. -- 2.54.0 (Apple Git-157)