From 54db9c6f4d90618bc1f2c65d07f600552989c048 Mon Sep 17 00:00:00 2001 From: Transaction Science Date: Mon, 7 Sep 2026 04:21:49 -0400 Subject: [PATCH] energy: the operating point, the residual, and alignment with network-layer identities MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The energy field is contested, not empty. The prescriptive half is a decade old and ratified — ISO/IEC 23001-11 carries decoding-operation-reduction metadata whose purpose is to make a decoder do less work, and a companion carriage part now moves it. WAI's half is the measured one. Neither half currently scores against the other, and that gap is where a joule figure stops meaning anything. DEGRADATION-BLINDNESS (§7.1). A receipt that records joules spent, and nothing about how much work the decode was asked to do, rewards the wrong behaviour: a sink can always spend fewer joules by decoding worse. energy-measurement.md §5's recomputable-work-unit rule blocks the substitution at the byte-exact tier, but not at `entropy-consistency`, and not for the conventional codecs WAI already carries. So the receipt has to carry the operating point, not only the cost. REQUEST / COMMITMENT / DELIVERY (§7.2). Three distinct fields, because the interesting cases are exactly the ones where they differ. A receipt MUST NOT carry `op_delivered` alone — that is the degradation-blind case. `op_committed` MUST be what the receiver stated even where it differs from the request, since a commitment that silently becomes the request is not a commitment. And a sink that honoured a reduction request MUST NOT claim `decode-equivalence`, per the tier rule. This converts a recorded number into a number measured against a promise. The prescriptive standards say what should be spent; the measurement standards say what was; nobody scores the second against the first. THE RESIDUAL (§7.3). Where a complexity descriptor and a measured binding cover the same reconstruction, the receipt MUST carry the signed difference between predicted and measured energy — over the same work unit, never without the acquisition class of the measured term, and never suppressed for being large. The large ones are the informative ones, and suppressing them turns a falsifiable claim into an unfalsifiable one. A complexity descriptor is a prediction about energy, and until something records what actually happened against it, the prediction can never be wrong. §7.3 closes that loop inside the artifact rather than in a report. COMPANION CAPABILITY (§7.4). Green-metadata semantics register the way wai.meta.hdr10plus and wai.meta.dovi do — name the descriptor class, sink supplies the decoder, no carriage adopted. ISOBMFF/DASH carriage is somebody else's layer. NETWORK-LAYER ALIGNMENT (energy-measurement §2.1). WAI's HwShunt/ModelBased/ Estimator is a private vocabulary, and coarser than the graded accuracy hierarchy an adopted IETF GREEN draft defines for device energy. An implementation reporting under both SHOULD derive rather than assign independently, MUST say which identity it derived from, MUST NOT let a derivation improve the class, and MUST declare the tolerance the class implies — a class without a tolerance is a label. WAI does not adopt that model; the scopes differ (device vs per-object) and conflating them would breach §4. What is required is that two vocabularies for one property do not contradict each other. Ingest queue item 3 and item 8 from the landscape survey (#80 §5.3 a–e). Co-Authored-By: Claude Opus 5 --- wai/extensions/energy-binding.md | 83 ++++++++++++++++++++++++++++ wai/extensions/energy-measurement.md | 23 ++++++++ 2 files changed, 106 insertions(+) diff --git a/wai/extensions/energy-binding.md b/wai/extensions/energy-binding.md index 37e04960f..980b6bc67 100644 --- a/wai/extensions/energy-binding.md +++ b/wai/extensions/energy-binding.md @@ -165,3 +165,86 @@ as though it were the second. The gap between them is the whole of *who says so*, and it is orthogonal to everything §3 makes checkable: a perfectly reproducible reconstruction signed by nobody in particular is still a claim from nobody in particular. + +## 7. The operating point, and why a joule figure alone is not enough + +### 7.1 Degradation-blindness + +A receipt that records the joules a decode spent, and nothing about how much work +it was asked to do, is **degradation-blind**. A sink can always spend fewer joules +by decoding worse, and a figure that cannot distinguish *efficient* from +*degraded* rewards the wrong behaviour precisely where the number is meant to +carry weight. + +This is not hypothetical. ISO/IEC 23001-11 carries decoding-operation-reduction +metadata whose purpose is to make a decoder do less; the sender requests a +reduction, and the receipt as specified today records only what was spent. +`energy-measurement.md` §5's recomputable-work-unit rule blocks the substitution +at the byte-exact tier, but not at `entropy-consistency`, and not for the +conventional codecs WAI already carries. + +The rules below make the operating point part of the claim, so the joule figure +is scored against something rather than merely reported. + +### 7.2 Request, commitment, delivery + +Where a sender requests an operating point and a receiver acts on it, the receipt +**MUST** seal all three of: + +| field | meaning | +|---|---| +| `op_requested` | the operating point the sender asked for | +| `op_committed` | the operating point the receiver said it would use | +| `op_delivered` | the operating point actually used | + +An operating point is a class-scoped descriptor — frame rate, spatial resolution, +a complexity target — and this extension does not define its vocabulary. What it +fixes is that the three are **distinct fields**, because the interesting cases are +exactly the ones where they differ. + +- A receipt **MUST NOT** carry `op_delivered` alone. A delivered figure with + nothing to score it against is the degradation-blind case §7.1 describes. +- `op_committed` **MUST** be recorded as what the receiver stated, even where it + differs from the request. A commitment that silently becomes the request is not + a commitment. +- Where `op_delivered` differs from `op_committed`, the receipt **MUST** record + both and **MUST NOT** claim the commitment was met. +- A sink that honoured an operation-reduction request **MUST NOT** claim + `decode-equivalence` for the result — see [determinism-tiers](determinism-tiers.md) + §2, *What a tier covers*. + +This converts a recorded number into a number measured against a promise. Neither +the prescriptive standards nor the measurement standards provide that pair: one +says what should be spent, the other what was, and nobody scores the second +against the first. + +### 7.3 The residual + +When a declared complexity or operating-point descriptor and a measured energy +binding both cover the same reconstruction, the receipt **MUST** carry the +**residual** — the signed difference between the energy the descriptor implies +and the energy measured. + +- The residual **MUST** be computed over the same work unit as the measurement + (`energy-measurement.md` §5), or it compares two different things and means + nothing. +- A residual **MUST NOT** be reported without the acquisition class of the + measured term. A residual against an `Estimator` figure is a difference between + two predictions. +- An implementation **MUST NOT** suppress a residual because it is large. The + large ones are the informative ones; suppression converts a falsifiable claim + into an unfalsifiable one. + +The residual is what makes the predictive half checkable. A complexity descriptor +is a prediction about energy, and until something records what actually happened +against it, the prediction is never wrong. This closes that loop in the artifact +rather than in a report. + +### 7.4 Companion capability + +Green-metadata semantics are registered the way +[`wai.meta.hdr10plus`](../research/media-codec-registry.md) and `wai.meta.dovi` +are: the capability names the descriptor class — complexity metrics, quality +recovery, display adaptation — and the sink supplies the decoder. **No carriage +is adopted**: ISOBMFF and DASH carriage of green metadata is somebody else's +layer, and WAI naming a descriptor does not make WAI responsible for moving it. diff --git a/wai/extensions/energy-measurement.md b/wai/extensions/energy-measurement.md index e5205aa30..dbf7a14f3 100644 --- a/wai/extensions/energy-measurement.md +++ b/wai/extensions/energy-measurement.md @@ -59,6 +59,29 @@ documenting them, and returns *no rate at all* — never `0` — when unmetered, because a zero reads as "this work was free", which is a stronger and false claim than "nobody measured". +### 2.1 Relationship to network-layer energy identities + +The three classes above are WAI's own vocabulary, and they are coarser than the +graded `data-source-accuracy` identity hierarchy an adopted IETF GREEN +working-group draft defines for device and sub-component energy. That hierarchy +is the network layer's answer to the same question this section asks: *how was +this number obtained?* + +- An implementation that also reports under a network-layer energy model + **SHOULD** derive its acquisition class from that model's identity rather than + assigning one independently, and **MUST** state which identity it derived from. + Two vocabularies for one property, assigned separately, will disagree. +- A derivation **MUST NOT** improve the class. Where a network-layer identity + maps ambiguously, the **weaker** WAI class applies. +- An implementation **MUST** declare the tolerance its acquisition class implies. + A class without a tolerance is a label; the point of grading provenance is to + say how much the figure can be leaned on, and that requires a number. + +WAI does not adopt the network-layer model, and this section does not restate it. +The scopes differ — that model is device- and sub-component-scoped, WAI's figures +are per-object — and conflating them would breach §4's attribution rules. What is +required is that the two do not contradict each other about the same measurement. + ## 3. The reference protocol: bracketed marginal measurement On-die energy counters report the draw of a whole package or SoC, not of one -- 2.54.0 (Apple Git-157)