SCU Methodology — Version 1 (binding arithmetic spec)

Applies to: every revision published with methodologyVersion = 1. Canonical URL: https://docs.compute.finance/methodology — embedded as methodologyUrl in every revision manifest and committed by contentHash, so the URL never changes. Immutability: once a revision referencing this document is published on-chain, sections 1–7 are frozen; any change to the arithmetic requires a new methodology version. Scope: this document pins the exact arithmetic of methodology version 1. An independent re-implementation built from this document alone MUST reproduce every published index value bit-identically. Manifest canonicalization and hashing (JCS, keccak256, contentHash/metadataHash) are defined by the revision-manifest spec, not here.

The key words MUST and MUST NOT are to be interpreted as described in RFC 2119.

1. Definition

The SCU (Standard Compute Unit) index is the USD cost of a reference LLM workload, computed as the equal-weight (1/N) geometric mean of the blended cost of one representative model per model family:

SCU = floor( (blended_1 × blended_2 × … × blended_N) ^ (1/N) )

No tiers, no provider weights, no outlier cap. Cache and reasoning prices are NOT part of this methodology version.

2. Number encoding

• Every price and every result is an integer in USD with 18 decimals (Usd18). Prices are per 1,000,000 tokens (Usd18PerM): a published price of $1.75 per 1M tokens encodes as 1750000000000000000.
• Integers MUST be parsed from decimal strings into arbitrary-precision integers. Binary floating point MUST NOT appear anywhere on the computation path (see the conformance check in §7).
• Valid values are strictly positive and below 2^256 (uint256 range, decimal string of at most 78 characters, no leading zeros).
• Every value in this methodology is non-negative, so truncating division (Solidity /, JS BigInt /, Rust/Go integer division) and flooring division (Python //) coincide — any of them satisfies the floor steps below.

3. Reference workload and blended cost

The reference workload of methodology version 1 is fixed: 1000 input / 500 output tokens.

blended_m = floor( (1000 × inputPriceUsd18PerM_m + 500 × outputPriceUsd18PerM_m) / 1_000_000 )

The intermediate sum is exact (arbitrary precision). A model whose blended cost truncates to 0 is ineligible and MUST be excluded before index computation — a zero factor would collapse the geometric mean.

4. Geometric mean — floor N-th root

With P = blended_1 × … × blended_N computed exactly (no precision limit):

SCU = the unique integer r such that  r^N ≤ P < (r+1)^N

This is the floor N-th root of the exact product. The pipeline contains exactly two rounding points, both floor: the per-model blended division (§3) and this root. Any algorithm that returns this r is conformant; the reference algorithm is integer Newton descent:

function floorNthRoot(P, N):                 # bitLength(P) = number of binary digits of P
    if N == 1 or P < 2: return P
    if N ≥ bitLength(P): return 1
    x ← 2 ^ ceil(bitLength(P) / N)          # guaranteed ≥ the root
    loop:
        next ← ((N-1)·x + P / x^(N-1)) / N   # integer divisions
        if next ≥ x: break
        x ← next
    while x^N > P:        x ← x - 1          # clamp to the floor invariant
    while (x+1)^N ≤ P:    x ← x + 1
    return x

5. Family rule

• One family, one slot. A family is a provider's distinct product line; family keys follow the provider.product-line scheme (e.g. openai.gpt and openai.gpt-mini are different families). Family keys and model keys match ^[a-z0-9._-]+$.
• Eligibility: a public pricing page, published USD pricing, at least one model; a candidate MUST have a release date and strictly positive prices, and its blended cost MUST NOT truncate to zero. There is NO cache/reasoning-pricing gate.
• Representative selection (deterministic, total order; the latest release wins):
  1. later release date wins;
  2. on an equal release date — higher model key under natural version compare (below);
  3. on a full natural-compare tie — bytewise greater model key wins.

Natural version compare

Split each model key into maximal runs of digits [0-9]+ and letters [a-z]+; separators (., -, _) delimit segments and are discarded. Compare segment by segment:

• both numeric → compare as integers (11 > 7);
• both alphabetic → compare bytewise;
• numeric vs alphabetic → the numeric segment is lower;
• every shared segment equal → the key with more segments is higher (gpt-4.1 > gpt-4).

Selection is NOT part of cryptographic re-derivation (manifests carry no release dates); it is pinned for pipeline reproducibility and basket-governance transparency.

6. Bounds

• 1 ≤ N ≤ 256 families per revision.
• Every encoded value is strictly positive and < 2^256. The published SCU then fits uint256 by construction: blended < 2^256 × 1500 / 10^6 and the geometric mean never exceeds its largest factor.
• The published SCU is strictly positive (the on-chain registry rejects scuUsd == 0).

7. Golden vectors

A conformant implementation MUST reproduce every vector below bit-identically (workload 1000/500; values are decimal Usd18 strings; families listed as (inputPriceUsd18PerM, outputPriceUsd18PerM) → blendedCostUsd18).

Conformance check: evaluating the two-family vector in IEEE-754 double precision (e.g. Math.sqrt) yields …945 — one above the correct floor root …944. An implementation that produces …945 violates §2 and MUST be rejected.

The rows above are normative and self-sufficient. The reference implementation maintains a machine-readable mirror of these vectors, enforced by automated tests.

8. Verification

To verify a published revision: read {scuUsd, methodologyVersion, contentHash, metadataHash} on-chain, fetch the manifest, validate it against the revision-manifest spec, then re-derive blended_m from each family's prices (§3) and SCU (§4) and compare bit-for-bit with the manifest value and the on-chain scuUsd. Hash-chain verification is defined by the revision-manifest spec.