Appendices

Definition 1: VerifyPrice(W) and Verification Overhead

For each canonical workload $W$ (for example, a constraint system $\text{PROOF}_{2^{20}}$, the matrix-multiplication SKU MATMUL_4096_FP32_FREIVALDS, or a verified-inference task INFER_LM_70B_256TOK), two quantities matter:

1. How expensive it is to verify a purported result on a reference verifier, and

2. How that verification cost compares to producing the result from scratch.

VerifyPrice(W): verification profile

Fix a reference verifier and adversarial mix of inputs. From a sample of verification runs for workload $W$, the following are estimated:

• $p_{50,t}(W), p_{95,t}(W)$: median and 95th-percentile wall-clock verify time from “artifact received” to “accept/reject”;

• $p_{50,c}(W), p_{95,c}(W)$: corresponding median and 95th-percentile verify cost in a reference unit (e.g., USD of cloud compute);

• $\text{fail}(W)$: observed fraction of artifacts that fail verification (invalid, malformed, or timed out).

The VerifyPrice vector for $W$ is then:

$$\text{VerifyPrice}(W) \equiv (p_{50,t}(W), p_{95,t}(W), p_{50,c}(W), p_{95,c}(W), \text{fail}(W))$$

Canonical form and its three views.

This five-field tuple is the canonical definition of VerifyPrice, and every variant tuple elsewhere in the thesis is a view of it, not a competing definition. There are three, and they are related by a single derivation:

1. Canonical (published) form: $(p_{50,t}, p_{95,t}, p_{50,c}, p_{95,c}, \text{fail})$, as above. Every SLO, red line, and phase gate that names VerifyPrice reads on this form and no other (Chapter 22: Layer 4: Truth & Work).

2. Input view: the per-run record $(t_{\text{run}}, e_{\text{run}}, m_{\text{run}}, b_{\text{run}}, \text{outcome}_{\text{run}})$ that the harness of Chapter 22: Layer 4: Truth & Work writes for every verification — wall-clock time, energy, peak memory, bytes transferred, and the pass/failure code — before any pricing or percentiling.

3. Cost-vector view: the same per-run record as Chapter 26: Extended Telemetry names it, $\text{CostVector}(W,V)_{\text{run}}$, and its front-matter form $c(W) = (t_{\mathrm{cpu}}, m_{\mathrm{peak}}, b_{\mathrm{net}}, e_{\mathrm{joules}}, c_{\mathrm{est}})$, which adds the priced per-run cost $c_{\mathrm{est}}$ as a field.

The derivation from views (ii) and (iii) to the canonical form is per run, then percentiled: each run’s cost is $c_{\text{run}} = (e_{\text{run}}/3.6\times10^{6})\, p_{\text{energy}} + t_{\text{run}}\, p_{\text{opp}}$ with both reference prices pinned and republished on change (Chapter 22: Layer 4: Truth & Work); $p_{50,c}$ and $p_{95,c}$ are then the percentiles of $c_{\text{run}}$ across the window, never recomputed from percentile inputs. Only time and energy are priced. Peak memory $m$ and bytes transferred $b$ are published, not priced: they appear in receipts and in views (ii) and (iii), they bound the reference machine a verifier must be (Chapter 22: Layer 4: Truth & Work), and they enter no cost percentile — a workload that fits the reference verifier’s memory and bandwidth pays nothing extra for them in $p_{\cdot,c}$, and one that does not fit is not a canonical workload on that tier. A dashboard may show any view, but all three must reconcile to the same underlying receipts.

ProduceProfile(W): production profile

The prover’s cost to produce correct outputs for $W$ is described the same way. From a sample of production runs (or cost models), estimate the median and 95th-percentile produce time and cost:

$$\text{ProduceProfile}(W) \equiv (p_{50,t}^{\text{prod}}(W), p_{95,t}^{\text{prod}}(W), p_{50,c}^{\text{prod}}(W), p_{95,c}^{\text{prod}}(W))$$

The denominator is an attack surface, and gets its own contract.

The verification numerator of $r(W)$ is produced under the multi-operator, signed-batch, adversarial-corpus regime of Chapter 22: Layer 4: Truth & Work; the production denominator has no equivalent protection as written, and it needs one, because a prover who inflates reported production cost drives $r(W)$ down and the network looks more verification-asymmetric than it is. The measurement contract for $\text{ProduceProfile}(W)$ is therefore the mirror of the numerator’s:

• Reference production cost model per workload. Production cost is estimated against a published reference model — pinned reference hardware, pinned kernel and stack versions, pinned energy price — exactly as the FP32 acceptance bound pins its reference kernel (Chapter 22: Layer 4: Truth & Work). Self-reported production cost may be published but does not enter $r(W)$.

• Independent estimation. At least two independent estimators (distinct from the prover being measured) produce the reference-model estimate; divergence above 5% triggers the same investigation protocol as verification measurements.

• Published derivation. The mapping from reference hardware, energy price, and runtime to estimated production cost is public and reproducible, so any observer can re-derive the denominator from its inputs.

• Asymmetry acknowledged. Where independent estimation is impossible for a workload, $r(W)$ is published as prover-favorable and unverified, and cannot by itself support a passing reading on chain link 3 (Chapter 8: The Triad and the Monetary Candidate).

The consequence for the SLO below is that a passing $r(W) \leq 0.3$ is a joint claim about both halves of the ratio: verification is cheap under the adversarial harness, and production cost is what the reference model says it is, not what the cheapest prover reports.

Verification overhead $r(W)$

Define separate time- and cost-based overhead ratios:

$$(v/p)_W^{\text{time}} = \frac{p_{50,t}(W)}{p_{50,t}^{\text{prod}}(W)}, \quad (v/p)_W^{\text{cost}} = \frac{p_{50,c}(W)}{p_{50,c}^{\text{prod}}(W)}$$

For convenience, these can be summarized as a single scalar:

$$r(W) \equiv \max\left((v/p)_W^{\text{time}}, (v/p)_W^{\text{cost}}\right)$$

Implementation Note: VerifyPrice Telemetry Schema (Sketch)

The exact encoding of VerifyPrice is implementation-dependent, but for operational dashboards and APIs it helps to standardize a minimal JSON-style schema per canonical workload. A skeletal example:

{
  "schema_version": "verifyprice/1",
  "workload_id": "PROOF_2^20",
  "modality": "M1",
  "window_start": "2026-06-01T00:00:00Z",
  "window_end":   "2026-06-07T00:00:00Z",

  "p50_verify_time_sec": 0.40,
  "p95_verify_time_sec": 0.90,

  "p50_cost_usd": 0.00030,
  "p95_cost_usd": 0.00055,

  "failure_rate": 0.0004,

  "r_time": 0.00035,
  "r_cost": 0.00050,
  "r_max": 0.00050,

  "sample_size": 125000,
  "hardware_profiles": ["open_tee_v1", "gpu_cluster_Y_v1"]
}

This schema is not normative; it is illustrative. The figures are chosen to be consistent with the definitions: $\text{PROOF}_{2^{20}}$ is a succinct (M1) workload, so $r_{\max}$ sits inside the M1 band of $10^{-3}$ (Chapter 22: Layer 4: Truth & Work) — a verify time of $0.4$ s against a production time on the order of $20$ minutes gives $r_{\text{time}} \approx 3.5 \times 10^{-4}$, and the cost ratio is of the same order. A value of $r_{\max} \approx 0.2$ would place a SNARK workload two orders of magnitude outside its band and is the kind of reading the modality check exists to catch. The key properties are:

• Each canonical workload (workload_id) has its own series of VerifyPrice snapshots over sliding windows.

• VerifyPrice is expressed both in time and cost percentiles, with the overhead ratio $r(W)$ reported explicitly.

• Enough context is included to interpret shifts (sample size, hardware profile mix, time window), but no user-identifying data is required.

Clients and observatories can compute VerifyPrice from raw receipts and emit them in this or a similar format. The important thing is that:

1. The mapping from receipts $\to$ VerifyPrice is public and reproducible, and

2. The resulting metrics are exposed in a way that any third party can verify and alert on.

A system that claims “cheap, public verification” but cannot produce machine-readable VerifyPrice series for its canonical workloads is, by construction, asking you to trust what it cannot or will not measure.

$W$ is called verification-asymmetric if $r(W) \ll 1$: checking honest work is much cheaper than re-doing it from scratch, both in time and cost.

A network (or facility) satisfies the VerifyPrice SLO for workload $W$ if, for a published target (e.g., $p_{95,t}(W) < 5$s, $p_{95,c}(W) < 10^{-3}$ USD), it maintains:

• $\text{fail}(W)$ below a small, explicit threshold, and

• $r(W)$ within its modality band — $10^{-3}$ for succinct (M1), $10^{-2}$ for algebraic or probabilistic (M2) with the soundness parameter published, and no ratio target for replicated or attested verification (M3), which does not carry the monetary mechanism (Chapter 22: Layer 4: Truth & Work). The legacy aggregate ceiling $r(W) \leq 0.3$ is retained as a portfolio-level engineering floor and as the fallback for unbanded workloads; no monetary claim reads on it,

over adversarial mixes of inputs and artifacts.

Definition 2: Facility Energy Receipt (FER)

A Facility Energy Receipt (FER) is a signed, machine-readable summary of a site’s energy use and availability over a fixed time interval $\Delta t$. Each FER is identified by a unique hash fer_id and contains at least:

• facility_id: a stable identifier for the site or plant;

• interval_start, interval_end: timestamps delimiting the reporting window;

• energy_in_kwh: total electrical energy consumed at the site boundary over $\Delta t$;

• energy_it_kwh: energy delivered to IT loads (provers, routers, storage);

• heat_reused_kwh: energy captured and reused (for ERE metrics);

• pue, ere, wue: standard efficiency and water-use indicators over $\Delta t$;

• outages: a list of curtailment or outage events during $\Delta t$;

• carbon_intensity_kg_per_kwh: average emissions factor for supplied energy;

• signature: one or more digital signatures attesting to the report’s correctness.

FERs are produced at regular cadence (e.g., every 5 minutes or hour). Other receipts (e.g., PIDL receipts for proofs) can reference a FER via fer_id, allowing allocators, auditors, and protocols to reconstruct the energy context in which a unit of verified work was performed.

Definition 3: PIDL Receipt (Proof Interface Definition Language)

A PIDL receipt is the minimal, canonical record of a verified interaction in the Create/Compute $\to$ Prove $\to$ Settle $\to$ Verify loop. It binds together the claim, the evidence, and the operational context into a single, serializable object.

At a minimum, a PIDL receipt contains:

• receipt_id: a unique identifier (e.g., a hash of the serialized payload);

• claim_id: an identifier or hash of the claim being attested;

• workload_id: a canonical registry identifier (e.g., PROOF_$2^{20}$, MATMUL_4096_FP32_FREIVALDS; Chapter 22: Layer 4: Truth & Work);

• proof_ref: a hash or pointer to the proof or transcript artifact;

• sla_tier: the latency tier under which the work was promised (Bronze/Silver/Gold) and assurance_tier: the modality-indexed assurance tier (Replicated, Replicated+audit, Probabilistic, Succinct; Chapter 22: Layer 4: Truth & Work) — a quote names one of each;

• verify_time_sec, verify_cost_unit: measured time and cost for verification;

• result: an outcome flag (e.g., accept, reject, timeout);

• optional context: hardware_profile, fer_id, settlement_txid, policy/jurisdiction tags, and principal_chain — an ordered list of commitments to the operator boundaries a delegated task crossed on its way to this receipt, each proven by predicate and none carrying an identity (Chapter 7: The Delegation Economy: Who Buys Verification, Chapter 26: Extended Telemetry). The field is optional and additive: a receipt without it verifies exactly as before, and a verifier that does not understand it ignores it;

• signatures: digital signatures from the prover, verifier, and (if applicable) broker or router.

PIDL receipts are designed to be portable and composable: they can be embedded in blocks, stored off-chain with only their hashes committed on-chain, included in higher-level proofs, or presented to auditors and counterparties.

Definition 4: VerifyReach(N, R)

Reachability and path diversity for independent verifiers in network $N$ and region $R$.

For a given network configuration $N$, client region $R$, and a target time budget $T$ (e.g., “within 30 seconds”), VerifyReach summarizes how reliably an honest client can reach at least one honest verifier within $T$ seconds over multiple transport classes.

The VerifyReach KPI for network $N$ in region $R$ is the vector:

$$\text{VerifyReach}(N, R) \equiv (p_{50,\text{conn}}(N,R), p_{95,\text{conn}}(N,R), \text{succ}_1(N,R), \text{succ}_2(N,R), \text{fail}_{\text{mix}}(N,R))$$

Where:

• $p_{50,\text{conn}}$, $p_{95,\text{conn}}$: median and 95th-percentile time-to-first-connection;

• $\text{succ}_1$: fraction of vantage points reaching an honest verifier via the primary transport within 30 s;

• $\text{succ}_2$: fraction reaching one via any transport, fallbacks included, within 60 s — so $\text{succ}_2 \geq \text{succ}_1$ by construction, and the gap between them is what the fallback ladder buys;

• $\text{fail}_{\text{mix}}$: distribution over connection failure causes.

SLOs, as Chapter 18: Layer 1: Reachability sets them (this definition carries no second set):

• $\text{succ}_1(N,R) \geq 0.95$ and $\text{succ}_2(N,R) \geq 0.99$ in uncensored regions; $\geq 0.70$ and $\geq 0.85$ in known-censored regions, measured over the ASNs sampled inside them;

• $p_{95,\text{conn}}(N,R)$ per transport class, because a single figure across classes hides the class that is failing: direct encrypted (BIP-324 [Mehta et al. 2023], QUIC/TLS) $\leq 3$ s; mimicry (look-like-TLS, domain-front-free decoy routing) $\leq 8$ s; onion / I2P $\leq 20$ s; rendezvous and refraction (Snowflake-class WebRTC, Conjure-class [Frolov et al. 2019]) $\leq 45$ s. Each is measured from first packet to an authenticated verifier session, and the class mix that produced the aggregate is published with it. The reference set is Appendix F: Communications Resilience Mechanisms.

The failure-cause distribution $\text{fail}_{\text{mix}}$ is likewise reported per transport class, over a fixed taxonomy — DNS failure, TCP/QUIC reset, TLS/handshake failure, timeout with no response, active-probe detection, and application-layer block — so that “unreachable” is never published as a single number.

Definition 5: VerifySettle(C)

Time, reliability, and privacy quality of non-custodial settlement on a corridor $C$.

For a given settlement corridor $C$ (e.g., BTC$\leftrightarrow$XMR atomic swaps), VerifySettle($C$) summarizes whether non-custodial settlement actually clears under its advertised SLOs.

The VerifySettle KPI is:

$$\text{VerifySettle}(C) \equiv (p_{50,t}(C), p_{95,t}(C), s(C), r_{\text{safe}}(C), f_{\text{mix}}(C), a(C))$$

Where:

• $s(C)$ (success): fraction of settlements that complete as intended within the SLA window;

• $r_{\text{safe}}(C)$ (refund-safe): fraction of off-happy-path transactions in which every party had a unilateral no-loss exit within the corridor’s bounded $\tau_C$ — its own leg refunded or the counterparty’s leg claimed (Chapter 23: Layer 5: Value & Settlement), with value counted in units of the asset committed and a claimed leg at the rate fixed at setup; computed on the protocol-attributable denominator, which assumes user liveness (user-environment failures classified and excluded), for the SLO, and on the overall denominator, the user-outcome series that counts those failures too, for Red Line 2 and the Phase I gate. Both readings assume chain liveness within the confirmation delay that $\tau_C$ includes, and a chain-liveness failure is not classed as a user-environment failure;

• $f_{\text{mix}}(C)$ (failure mix): distribution of failure causes;

• $a(C)$ (anonset): summary of anonymity-set size and churn.

Notation: $s(C)$ and $r_{\text{safe}}(C)$ are the mathematical symbols; where the body and the boards write success(C) and refund_safe(C) (Chapter 23: Layer 5: Value & Settlement, Red Line 2), those are the same two fields under their dashboard names, and nothing else is meant by either spelling.

A corridor satisfies its VerifySettle SLO if:

• $s(C) \geq \text{target}$ (e.g., 0.95), and

• $r_{\text{safe}}(C) \geq 0.999$ on the protocol-attributable denominator over adversarial mixes, with zero protocol-attributable losses (any such loss is Sev-1; Chapter 23: Layer 5: Value & Settlement), and $\geq 0.995$ overall,

with no hidden custodian or discretionary freeze paths. A hard $1.0$ over every failure class is a figure no corridor with humans on it can hold, and it is met only by corridors nobody uses.

Definition 6: Repression Wedge

The repression wedge is the realized real return on rate-capped instruments when nominal yields are held below inflation:

$$r_{\text{real},t} \equiv \frac{1 + i_{\text{cap},t}}{1 + \pi_t} - 1 \approx i_{\text{cap},t} - \pi_t$$

A negative $r_{\text{real},t}$ indicates that holders of capped instruments are being taxed in real terms via financial repression rather than explicit default.

Definition 7: Liquidation Effect

The liquidation effect measures the effective “tax” on bondholders from negative real rates. The construction follows Reinhart and Sbrancia [Reinhart & Sbrancia 2015], whose annual liquidation effect is the real saving to the sovereign in a year when the real rate on its domestic debt is negative, expressed as a share of GDP:

$$\text{Liquidation}_t \approx \max(0, -r_{\text{real},t}) \times \frac{\text{Domestic Gov't Debt}_t}{\text{GDP}_t}$$

Reinhart and Sbrancia report that advanced economies saw negative real rates in roughly half of the years over 1945–1980, with the annual liquidation effect averaging on the order of 1–5% of GDP per year across the economies in their sample; those are their figures, quoted here as the historical scale of the mechanism, and no red line reads on them.

Definition 8: Physical VerifyPrice

Two series, two names.

Two series are easily run together under one name. The constitutional SLO — the verification-cost series of Definition 1 measured in real resources on reference hardware, exogenous to token price, the series Red Line 1 reads — is the Real-Resource VerifyPrice SLO (Chapter 22: Layer 4: Truth & Work). Physical VerifyPrice names only this definition: the cost of auditing the physical-infrastructure claims behind a unit of verified work, the series Red Line 10 reads. The two are not merged, because a network can verify proofs cheaply while its facilities are opaque, and the converse. Chapter 22: Layer 4: Truth & Work and the glossary carry the same distinction.

The claims being audited.

A Facility Capacity Receipt (FCR, Chapter 17: Layer 0: Verifiable Machines & Energy) is a signed, auditable receipt that extends the Facility Energy Receipt of Definition 2 with grid, cooling, redundancy, hardware-diversity, jurisdictional, and infrastructure-resilience claims; it is the object whose fields Sovereign Optionality and Delivered Verified Capacity aggregate. Physical VerifyPrice extends VerifyPrice(W) (Definition 1) from proof/compute claims to these FCR claims. For a facility profile $F$, it is the vector

$$\begin{aligned} \text{PhysicalVerifyPrice}(F) \equiv \big( & p_{50,t}^{\text{FCR}}(F),\ p_{95,t}^{\text{FCR}}(F),\ p_{50,c}^{\text{FCR}}(F),\ p_{95,c}^{\text{FCR}}(F),\\ & \text{ChallengeSuccess}(F),\ \text{OpenDiscrepancies}(F)\big) \end{aligned}$$

where $p_{\cdot,t}^{\text{FCR}}$ and $p_{\cdot,c}^{\text{FCR}}$ are time and cost percentiles to independently verify $F$’s FCR claims (energy profile, outage/curtailment history, hardware-profile integrity, jurisdictional routing), $\text{ChallengeSuccess}(F)$ is the fraction of third-party audit challenges that resolve without dispute, and $\text{OpenDiscrepancies}(F)$ is the count of unresolved claim mismatches. A Work Credit is high-assurance only if VerifyPrice(W), PhysicalVerifyPrice(F), and the relevant DVC bound clear their respective SLOs; none of those conditions makes the credit monetary. See Chapter 22: Layer 4: Truth & Work, Chapter 17: Layer 0: Verifiable Machines & Energy.

Definition 9: VerifyFlow

VerifyFlow is the market-realization counterpart to VerifyPrice, VerifyReach, and VerifySettle. Where those three measure whether the stack supplies triad capacity under adversarial conditions, VerifyFlow measures the external financial representation and price-transmission state of the native monetary object. It is a pair of vectors, one per wrapper and one per asset:

$$\mathrm{VerifyFlow}_i \equiv \bigl(L_i,\; A_i,\; \Delta A_i,\; \varepsilon_i,\; \kappa_i,\; C_i,\; H_i,\; D_i\bigr)$$ $$\mathrm{VerifyFlow}(X) \equiv \bigl(Q^{RC},\; Q^{RD},\; \mathrm{MPR},\; \mathrm{CCR},\; \mathrm{SER},\; \mathrm{WNG},\; \mathrm{RCR},\; \mathrm{NUS}\bigr)$$

Component definitions appear in Chapter 26: Extended Telemetry; the estimating equations and their measurement contract appear in Appendix H: Formal Model of Market Realization, Wrapper Flows, and Price Capture. VerifyFlow is explicitly not a protocol SLO: no VerifyFlow value falsifies the monetary thesis by itself. Its function is to determine whether observed price carries any information about native adoption (Chapter 13: Why Hold the Base Asset?).

This appendix collects the thesis’s named instruments into one table — what each measures, in what unit, from what data, how often, on which public board it surfaces, which red line reads it, and at what threshold — and then lists the operational checklists by domain. The table is the reconciliation: a metric that appears in the body but not here, or here with a different definition, is a defect to report. Definitions are drawn from the body and the formal appendices (Appendix A: Formal Model of Verification Asymmetry & VerifyPrice, Appendix H: Formal Model of Market Realization, Wrapper Flows, and Price Capture); where a threshold is a red-line trigger it is the red line’s own figure, and where the body publishes no number the cell says so rather than inventing one.

Instrument Table

Operational Checklists by Domain

The table above holds the named instruments. Operators also need the ordinary telemetry beneath them, grouped here by domain. None of these carries a red line by itself; each feeds one of the instruments above or one of the twelve boards (Chapter 26: Extended Telemetry).

Prover markets:

Queue depth, clearing price per proof type, cancellation rates, p50/p95 VerifyPrice.

Compute consensus pilots:

MatMul throughput (GFLOPs/s), verifier cost ratio $r(W)$ with its modality band, invalid-work rejection rate under adversarial load, adversarial acceptance-suite pass rate (Chapter 22: Layer 4: Truth & Work).

Privacy settlement:

Atomic swap success %, time-to-finality, stuck-flow causes by $f_{\text{mix}}$ category, wallet UX friction metrics.

Decentralization & capture risk:

• Nakamoto coeff. (by stake/hash/prover share); top-N concentration; Gini.

• Entry latency: time-to-first-proof/mined-block for a new node.

• Geographic/ASN diversity; % over Tor/VPN; relay/MEV-builder diversity.

Liveness & safety:

• Reorg/orphan rate; effective finality time (p50/p95); incident MTTR/MTBF.

• SLA attainment (% proofs/settlements meeting latency/uptime targets).

• DoS/churn resilience: success % under adversarial load mixes.

Verify/produce economics:

• Verifier cost ratio (verify/produce) by workload; energy per proof/inference.

• Hardware mix & utilization (GPU/CPU/ASIC) vs. throughput; cost/FLOP ($/GFLOP-verified).

• Failure taxonomy: prover faults, invalid proofs, circuit timeouts.

Privacy rails health:

• Anonymity-set size & churn (shielded pool/epoch); linkability regressions found.

• Swap slippage & fees (p50/p95); cross-venue route diversity; failure-mix root causes, classified under the fixed $f_{\text{mix}}$ taxonomy of Appendix A: Formal Model of Verification Asymmetry & VerifyPrice, Definition 5, rather than free text.

• UX friction: successful first-run rate, steps/clicks to complete, abandonment rate.

Bridges & cross-chain settlement:

• Atomicity violations (0-conf leaks, partial completes); retry rate; liquidity depth per route.

• Watchtower/guardian coverage; light-client verification share vs. multisig.

Provenance & policy demand:

• C2PA [C2PA spec] attach rate, strip rate by platform; “verified views” share.

• Proof volume indexed to policy milestones (EU AI Act [EU 2024] dates); % budgeted vs. ad-hoc spend.

Security & abuse:

• Sybil detection hit rate; staking/miner collusion alerts; MEV/censorship events.

• Key/attestation hygiene: validator/prover key rotations, slashing/penalties.

Token & issuance telemetry:

• Realized issuance vs. schedule; FeeCoverage (retained fees, burns excluded) of security budget; % rewards tied to useful work.

• Velocity vs. locked/collateralized supply; SoV signals (holder age bands, exchange outflows).

Customer success:

• Enterprise proof spend: $/month, SLA breaches, churn; Net Proof Retention (NPR) — for the cohort of customers that were paying for proofs in a base period, their proof spend in the current period divided by their base-period spend, computed on receipt-tagged budgets and excluding new customers; NPR $> 1$ means the existing base grew its verification demand net of churn and down-sell, the proof-market analogue of net revenue retention.

• Time-to-integration (SDK$\to$prod); support tickets per 1k proofs/settlements.

Hardware honesty:

• Share of receipts tied to open or sampled hardware profiles (by workload and volume).

• Lot-sampling coverage: percentage of lots and devices subject to destructive audits (SEM/optical imaging, side-channel tests), and maximum time since the last audit per profile.

• Incidents and deprecations: count and severity of profile-level compromises, time-to-deprecation, and migration progress away from affected profiles.

At the top of the stack, the application layer, you work with a small vocabulary:

• “Prove this computation.”

• “Prove this provenance.”

• “Settle this payment under these privacy and finality constraints.”

• “Anchor this result to hardware with this security profile.”

The SDK turns those sentences into types. A claim is a first-class object: ComputationClaim, ProvenanceClaim, SettlementClaim, optionally decorated with requirements. The compiler and runtime then map those claims to whatever combination of proving backends, settlement rails, and verifiable machines currently clear the SLA at the best VerifyPrice.

Core types:

class Policy:
    max_verify_time_sec: float
    max_verify_cost_usd: float
    privacy_level: str              # e.g. "encrypted_io", "public"
    finality_target: str            # e.g. "1m", "30m", "2h"
    allowed_hardware_profiles: list # e.g. ["open_tee_v1", "pure_zk_only"]

class ComputationClaim:
    fn: Callable
    inputs: Any
    policy: Policy

class ProvenanceClaim:
    media_bytes: bytes
    device_profile: str
    policy: Policy

class SettlementClaim:
    payments: list  # [Payment(recipient, amount, asset), ...]
    policy: Policy

class Receipt:                       # = PIDL receipt, Def. 3 (app:verifyprice)
    receipt_id: str                  # hash of the serialized payload
    claim_id: str                    # hash of the claim being attested
    workload_id: str                 # canonical tag, e.g. "PROOF_2^20"
    proof_ref: str                   # hash/pointer to proof or transcript
    sla_tier: str                    # latency: "bronze" | "silver" | "gold"
    assurance_tier: str              # "replicated" | "replicated_audit" | "probabilistic" | "succinct"
    verify_time_sec: float
    verify_cost_unit: float          # in the published reference unit
    result: str                      # "accept" | "reject" | "timeout"
    hardware_profile: str | None
    fer_id: str | None               # Facility Energy Receipt, if bound
    settlement_txid: str | None
    policy_tags: dict                # jurisdiction / policy context
    signatures: list                 # prover, verifier, [broker/router]
    schema_version: str              # "pidl/1"

The Receipt type is the PIDL receipt of Appendix A: Formal Model of Verification Asymmetry & VerifyPrice, Definition 3, field for field; the SDK adds no fields the receipt does not carry, so a receipt exported from one application verifies in another and aggregates into the same VerifyPrice series (Chapter 22: Layer 4: Truth & Work). proof_bytes travels alongside the receipt, addressed by proof_ref, rather than inside it.

SDK surface:

sdk = ProofSDK(networks=[...])  # PoUW chains, zk rollups, open-TEE clusters

claim   = sdk.make_claim(...)
receipt = sdk.prove_and_settle(claim, pay_with=user_wallet)
result  = sdk.verify(receipt)   # -> {accept: bool, metadata: ...}

Everything else—choice of proving backend, choice of settlement rail, choice of hardware profile—is a routing decision made under the hood, constrained only by the policy you declared.

Error model.

Every call either returns a Receipt whose result is accept, or raises. Failures are typed, not silent: PolicyUnsatisfiable (no backend clears the declared Policy at the current VerifyPrice — the SDK never quietly relaxes a policy to find a route); ProofRejected (a receipt with result = reject, returned inside the exception so the rejection itself is evidence); VerifyTimeout (result = timeout, counted in $\text{fail}(W)$); and, for settlement claims, SettlementAborted, which carries the refund receipt — a settlement that fails must end in refund_safe, and an abort path that cannot produce a refund receipt is a Red Line 2 incident, not an SDK error. Rejected and timed-out receipts are emitted to telemetry exactly as accepted ones are; a client that drops them corrupts the failure-rate field of every series it feeds.

Versioning.

Receipts, policies, and hardware-profile identifiers are versioned independently and each carries its own tag: schema_version on receipts (pidl/1), a policy_version on policies, and the trailing _vN on profile strings (Appendix E: Hardware Profiles). The SDK follows semantic versioning; a change to receipt fields or to the meaning of a policy field is a major version. A verifier must reject a receipt whose schema version it does not recognize rather than verify the subset it understands, and observatories publish VerifyPrice series per schema version until a migration completes, so a schema change is never mistaken for a cost change.

Example 1: Proofed medical inference on verifiable machines

policy = Policy(
    max_verify_time_sec = 1.0,
    max_verify_cost_usd = 0.001,
    privacy_level = "encrypted_io",
    finality_target = "30s",
    allowed_hardware_profiles = ["open_tee_v1", "pure_zk_only"]
)

@proofed(policy=policy)
def diagnose(image: EncryptedImage) -> Diagnosis:
    return model.predict(image)

# In request handler:
claim   = sdk.make_computation_claim(fn=diagnose, inputs=enc_image, policy=policy)
receipt = sdk.prove_and_settle(claim, pay_with=clinic_wallet)
result  = sdk.verify(receipt)

Example 2: Camera provenance anchored in open hardware

# On capture (running on "open_camera_v1" device):
raw_bytes = camera.capture()

policy = Policy(
    max_verify_time_sec = 0.5,
    max_verify_cost_usd = 0.0005,
    privacy_level = "hide_location_and_identity",
    finality_target = "5m",
    allowed_hardware_profiles = ["open_camera_v1"]
)

prov_claim = sdk.make_provenance_claim(
    media_bytes=raw_bytes,
    device_profile="open_camera_v1",
    policy=policy
)

receipt = sdk.prove_and_settle(prov_claim, pay_with=newsroom_wallet)
bundle = MediaBundle(media=raw_bytes, provenance_receipt=receipt.export())

Example 3: Private payroll over neutral rails

policy = Policy(
    max_verify_time_sec = 3.0,
    max_verify_cost_usd = 0.002,
    privacy_level = "shielded_settlement_with_auditable_receipts",
    finality_target = "2h",
    allowed_hardware_profiles = ["pure_zk_only"]
)

# Amounts are in the base asset (placeholder symbol NATIVE). A stablecoin
# leg here would be a Value-Capture Condition 1 bypass (part-ii,
# lem:value-capture) and appears in none of the reference applications.
payroll_batch = [
    Payment(recipient=alice_addr, amount=1000, asset="NATIVE"),
    Payment(recipient=bob_addr,   amount=1200, asset="NATIVE"),
]

settle_claim = sdk.make_settlement_claim(payments=payroll_batch, policy=policy)
receipt = sdk.prove_and_settle(settle_claim, pay_with=treasury_wallet)

The asset choice in that batch is not incidental. The Value Capture Lemma’s first condition (Chapter 13: Why Hold the Base Asset?) is that users cannot pay in fiat, stablecoins, or other tokens at equivalent service quality, and Chapter 13: Why Hold the Base Asset? names dollar stablecoins as the incumbent bypass channel; a reference application that settled payroll in one would be demonstrating the failure mode the thesis is instrumented to detect. NATIVE is a placeholder for whatever the base asset’s ticker becomes; the reference applications carry no other settlement asset.

Plant architecture for verifiable work

Objective: deliver verifiable, dispatchable, and composable power to proving and inference clusters so that proof units and verified FLOPs remain cheap to check and neutral to route.

Electrical topology (MV $\to$ LV):

• Medium-voltage interconnect with dual utility feeds where available; 2N or N+1 step-down to rack power.

• UPS/BESS for ride-through and proof-preserving shutdowns.

• Power-quality SLOs (voltage/frequency/THD) bound worst-case verifier latency inflation.

Thermal topology:

• Air to liquid (direct-to-chip/immersion) as default for high-density provers.

• Heat-reuse loops to district heating, greenhouses, or absorption chillers to improve ERE.

• Publish PUE and ERE: if heat is monetized, ERE $< 1.0$ is both possible and economically material.

Network & provenance:

• Redundant backhaul with clock discipline (PTP/Stratum) so receipts carry tight timing jitter bounds.

• Facility attestation path: meters and controllers sign energy/thermal telemetry.

Control plane:

• Workload-aware orchestration couples grid signals $\to$ job scheduler.

• Interruptible Bronze proofs pause first; Gold proofs ride through with BESS and on-site firming.

Energy procurement & grid posture:

• Portfolio, not a point bet: long-dated PPAs, nodal index exposure, behind-the-meter firming, and BESS.

• Co-location with stranded or curtailed energy (hydro spill, wind/solar curtailment, flare-gas).

• Demand response as a feature: treat prover/inference farms as dispatchable loads.

• Carbon & provenance: bind certificates into FER format so “kgCO$_2$e per proof” is auditable.

SLA tiers that map power quality to receipts:

• Bronze (interruptible): Shed priority 1. Eligible for demand-response; refunds/penalties via SLA escrow if p95 VerifyPrice breached. Typical use: PoL audits, non-urgent prover workloads.

• Silver (curtailable with notice): Shed priority 2 with N+1 firming; curtailment windows posted ahead of time. Typical use: batch MatMul-PoUW, rollup proving backlogs.

• Gold (firm): 2N electrical path or N+1 + BESS ride-through; zero curtailment except force majeure. Typical use: settlement-critical proofs, receipt ledger finalization.

What a lab would need to specify.

The architecture above is a pattern, not a plant. Nothing in this appendix carries a budget, and none should be read into it; the numbers belong to a site study, not a thesis. Before a reference facility can be costed, the following have to be fixed, and the investment addendum (Chapter 32: Kardashev Labs: Build and Measure) is where the first of them are:

• MW scale. The IT load the reference plant is designed for, stated as a range with the prover and verifier shares separated, since verification is threatened by hardware obtainability and proving by bulk power (Chapter 17: Layer 0: Verifiable Machines & Energy) and the two do not scale together.

• PUE and ERE targets. Design-point and worst-season figures for each, with the heat-reuse path that makes ERE $< 1.0$ achievable named or the target set above 1.0; both are FER fields (Appendix A: Formal Model of Verification Asymmetry & VerifyPrice) and the targets are what the receipts will be read against.

• BESS sizing. Energy (MWh) and power (MW) capacity, ride-through duration at Gold load, cycling assumptions, and whether the battery is sized for proof-preserving shutdown only or for firming as well.

• PPA tenor and structure. Contract length, fixed versus indexed pricing, curtailment terms, and the share of load covered by contract versus nodal exposure; the portfolio posture above becomes a set of instruments only once tenors are chosen.

• Mapping of SLA tiers to FER/FCR fields. For each of Bronze, Silver, and Gold: which outages entries count as curtailment against the tier, the interconnection class and backup-duration fields of the FCR (Chapter 17: Layer 0: Verifiable Machines & Energy) a facility must report to offer the tier, and the SLA-escrow rule that reads them, so that “Gold” is a field-level claim a receipt can falsify rather than a marketing label.

• Grid and jurisdiction. Balancing authority, interconnection queue position, and the curtailment or rationing posture of the host jurisdiction toward verification workloads, since the last is what Red Line 13 reads.

• Local approvals. The land-use, water and noise approvals the site depends on and the body that grants each, since a local veto binds one site at a time whatever the host jurisdiction’s posture (Chapter 5: Threat Model).

This thesis treats “hardware profiles” as first-class objects: they describe machines in the same language used for proofs and receipts.

Concept

A hardware profile is a public description of a class of devices that are interchangeable for security and performance purposes. It is not a single physical unit; it is the specification for what counts as a valid unit of that type.

Informally: a profile says, “devices that meet this description behave like this, within these error bars, under this sampling regime.”

Hardware profiles serve to:

• express trust and threat-model assumptions at the protocol and application layer;

• bind proofs and receipts to the types of machines that produced them; and

• make the honesty (and failure rates) of machines measurable over time.

Naming

Profiles are identified by short, stable strings. Three broad kinds:

1. Open-hardware profiles — devices whose RTL/microarchitecture and sampling regime are publicly documented.

   • open_tee_v1 — first open TEE design with published RTL, side-channel budget, and lot-sampling plan. No such device yet exists; the profile string names the specification a lab would build to (below).

   • open_signer_v1 — simple key-storage/signing chip with open RTL and sampling.

   • open_camera_v1 — camera/capture pipeline with documented sensor path, secure element, and sampling method.

2. Logical or pure-cryptography profiles — paths that do not rely on special hardware.

   • pure_zk_only — verification/proving path relying only on general-purpose CPUs/GPUs and cryptographic assumptions.

   • software_only_v1 — profile used for testing or where hardware attestations are unavailable.

3. Vendor or mixed profiles — existing devices not fully open but characterized and sampled.

   • vendor_tee_X_v1 — proprietary TEE profile with documented side-channel and attestation scheme, and the vendor’s stated scope for physical attacks; memory-bus interposers costing under $1,000 have extracted attestation keys and forged attestations [Chuang et al. 2026].

   • gpu_cluster_Y_v1 — particular GPU farm configuration with known performance and sampling behavior.

Hardware Profile Specification

Each profile has a specification that is part of the public “bill of materials” for the stack. At a minimum:

• profile_id: string (e.g., “open_tee_v1”)

• device_class: what the device is used for (e.g., “TEE”, “signer”, “accelerator”, “camera”)

• trust_mode: “open”, “mixed”, “opaque”, or “logical”

• design_commit: identifiers for design artifacts (hashes of RTL, GDS, firmware images)

• side_channel_budget: qualitative/quantitative bounds

• sampling_plan: how lots and devices are checked

• attestation_scheme: how devices prove identity and state

• security_target: high-level security goal

Hardware Profiles in Receipts and Policies

Profiles appear in three main places:

1. Policies — Developers express requirements using profiles:

   allowed_hardware_profiles = ["open_tee_v1", "pure_zk_only"]

2. Receipts (PIDL) — Every PIDL receipt includes a hardware_profile field.

3. Telemetry — The observability layer aggregates metrics by profile.

Example Profiles

open_tee_v1:

• device_class: “TEE”

• trust_mode: “open”

• design_commit: hashes of RTL, layout, firmware

• sampling_plan: random lot sampling, SEM/optical inspection

• intended use: high-value proving, key storage, secure computation

open_camera_v1:

• device_class: “camera”

• trust_mode: “open”

• sampling_plan: device sampling and destructive testing per lot

• intended use: origin-anchored capture for media provenance

pure_zk_only:

• device_class: “logical”

• trust_mode: “logical” (no hardware assumptions)

• intended use: contexts where hardware trust is unacceptable

What a Lab Would Need to Specify

The profiles above are specifications for describing machines. They are not machines, and this appendix attaches no prices to any of them; a bill of materials with costs belongs to a procurement study against the ladder of Chapter 17: Layer 0: Verifiable Machines & Energy, not to a thesis. What can be stated here is the shape of what a lab would have to specify before the first receipt could carry an open profile string honestly.

L0-A reference prover and verifier: component list, no prices.

The reference verifier is the machine every VerifyPrice figure is measured on (Laptop tier, Chapter 22: Layer 4: Truth & Work), so its bill of materials is a public artifact even though every part in it is commodity. The reference prover is the machine the production denominator of $r(W)$ is priced against (Appendix A: Formal Model of Verification Asymmetry & VerifyPrice).

• Reference verifier: commodity x86-64 or ARM host meeting the Laptop-tier specification (4 cores, 16 GB, SSD, 100 Mbps); a pinned operating-system image and kernel version; the reference verifier software build, reproducible from source (Chapter 19: Layer 2: Distribution & Execution); an external power meter at the wall for the energy field; a hardware RNG source for the adversarial-mix sampler; and a signing key on a commodity secure element for result attestation. Nothing in it is open silicon: L0-A is the characterized commodity rung, and the profile says so.

• Reference prover: commodity GPU or CPU cluster node with the pinned kernel and driver stack that sets the FP32 acceptance bound (Chapter 22: Layer 4: Truth & Work); metered rack power distribution for the per-run energy figure; a pinned firmware inventory (hashes published); and the same reproducible software build.

• For both: the design_commit is the set of hashes of every image the machine runs; the sampling_plan is electrical test and firmware-hash comparison on a random sample of units per lot, since counterfeit dies, binned-down parts, and firmware substitution are the high-sensitivity defect classes (Chapter 17: Layer 0: Verifiable Machines & Energy).

Proving-cost roadmap: the metric, today’s reading, and the bet.

The lab’s headline cost series is stated in a unit a buyer can price: US dollars per $10^{9}$ zkVM cycles for general programs, and per $10^{9}$ constraints for circuit-native workloads, measured on the reference prover above as cost—hardware amortization plus metered energy, in the per-run price model of Chapter 22: Layer 4: Truth & Work—and published beside the market price on open proving markets, which is a different number and must not be substituted for it. The distinction is load-bearing at the outset because the market reading today sits below any plausible cost floor. The open proof markets that launched in 2025 (Boundless [Boundless 2025]; the Succinct Prover Network [Succinct 2025]) clear reverse auctions in which posted prover supply exceeds order flow: Boundless reported [Shankar 2026] roughly USD 0.02 per $10^{9}$ cycles in February 2026 against some 400 trillion cycles per day of posted capacity, with auction clears near zero at times, and Succinct [Succinct 2026] prices in prover gas units at an auction-set rate plus a dynamic base fee. A price set by oversupplied provers competing for subsidised order flow is evidence about the auction, not about the cost of proving, and the lab’s series is the cost. Boundless announced in October 2026 that its proving protocol would pause on 5 November [Boundless 2026], which is consistent with that reading. This paragraph deliberately fixes no figure for that cost; the first quarterly reading does. The author’s prior, stated so it can be wrong, is that all-in cost on commodity GPUs sits one to two orders of magnitude above the February 2026 auction clear, which is what oversupply predicts.

Two series ride beside the headline. The first is the proving overhead $p(W)/p_{0}(W)$: the production cost of a result with its proof over the cost $p_{0}(W)$ of executing the same workload natively with no proof, per registered SKU. It is the number the buyer actually pays for verifiability and the one the capturable wedge (Chapter 22: Layer 4: Truth & Work) is measured against; a workload’s M1 SKU becomes economic when that overhead falls inside the buyer’s differential $\Delta$ for it, and not before. The second is the same overhead for the M3 alternative—a committee of $k$ re-executing the work, whose overhead is roughly $k$ and falls only as hardware does.

The nearest public reading of these series comes from Ethereum’s effort to prove its own blocks in real time, a workload the Ethereum Foundation fixed with a working definition: proving latency of at most 10 s for the 99th percentile of mainnet blocks, using on-premises hardware costing at most USD 100,000 and drawing at most 10 kW [Gold 2025]. By the Foundation’s own account, proving latency then “dropped from 16 minutes to 16 seconds” and “costs collapsed 45$\times$” [Kadianakis 2025], a public cost slope for M1 on a fixed workload, reported by the body that set the target rather than measured on the reference prover. It is a slope in cost, not in overhead. Thaler put zkVM provers at “overhead factors approaching one million times the cost of native execution” in March 2025, a figure he said had held for about a year, and noted that GPU acceleration and pre-compiles yield speedups that “don’t necessarily reflect progress on fundamental overheads” [Thaler 2025]; both readings can be true at once, which is why the overhead series is published beside the cost series and not inferred from it. Nor has the slope found a committed buyer. The Foundation’s plan begins with proof-verifying clients that validators may choose to run [Gold 2025], and optional execution proofs (EIP-8025) are listed as declined for inclusion in the Hegotá upgrade [Beiko et al. 2025], so the L1 has not committed protocol demand for the proofs that effort produced.

The modality bet is then a statement about slopes. The monetary mechanism rides on M1 and M2 (Chapter 22: Layer 4: Truth & Work); the bet is that M1 proving overhead per unit of useful work falls faster than the M3 committee’s, so that the set of workloads for which succinct verification is economic widens over time rather than staying fixed at the small-circuit end. Its checkpoints are dated to the lab’s deliverables (Chapter 32: Kardashev Labs: Build and Measure): first published reading at $T_{0}+6$; first annual slope at $T_{0}+12$; and a pre-registered kill condition at eight quarters—if the measured decline in M1 overhead over that window is no steeper than the decline in the M3 committee’s, the bet is lost for that workload class, the class stays M3 in the registry (Chapter 22: Layer 4: Truth & Work), and the affected _ZKML-style destination SKUs remain targets rather than becoming constitutional. A projection with no such condition would be a forecast, and this appendix publishes instruments.

The first L0-C open components.

Open PDKs exist today only at mature nodes, so the first open components are the ones whose job is trust rather than throughput (Chapter 17: Layer 0: Verifiable Machines & Energy). A lab would specify, in this order:

• Root of trust (RoT): an open RISC-V measured-boot and key-storage core, with published RTL, a documented attestation scheme, and a side-channel budget; this is what open_signer_v1 names.

• Random number generator (RNG): an open entropy source and conditioner with a published health-test specification [Turan et al. 2018], since every sampling plan and every adversarial mix in the thesis draws on it.

• Metering: an open power and capacity meter whose firmware signs the FER fields (Appendix A: Formal Model of Verification Asymmetry & VerifyPrice), so that “energy_it_kwh” is attested by a component the operator does not control alone.

Side-channel budget metric.

A profile’s side_channel_budget is stated in a form an independent lab can reproduce: Test Vector Leakage Assessment (TVLA), as the pass/fail leakage test at a stated trace count and statistical threshold, with the ISO/IEC 17825 test procedure as the reference method. The published budget names the trace count at which the device is claimed to pass, and a device is re-tested at that count on every sampled lot.

Sampling plan reference.

Lot acceptance follows a published acceptance-sampling standard — ANSI/ASQ Z1.4 [DoD 1989] (the successor to MIL-STD-105) — with the acceptable quality level, inspection level, and switching rules stated in the profile; the rule-of-three converse and the sensitivity term of Chapter 17: Layer 0: Verifiable Machines & Energy then convert the plan into a published upper bound on undetected compromise for the high-sensitivity defect classes, and into a deterrent statement, not a bound, for dopant-level trojans [Becker et al. 2013].

P2P transport set:

• v2 Encrypted P2P (BIP-324 [Mehta et al. 2023]) as default for all full nodes and relays; expose QUIC/TLS fallbacks.

• Onion/I2P modes first-class in clients; auto-failover if clearnet handshakes exhibit DPI resets.

• Handshake camouflage for relays in high-interdiction ASNs — with the caveat that fully encrypted, uniform-random-bytes transports (Noise, obfs4-class) are themselves a fingerprint the Great Firewall has blocked heuristically since 2021 [Wu et al. 2023], so camouflage must include look-like-something transports, not only look-like-nothing ones.

What a lab would need to specify: the transport list.

The transport set is stated as classes so that VerifyReach can publish $p_{95}$ per class (Appendix A: Formal Model of Verification Asymmetry & VerifyPrice, Definition 4), and each class names a reference implementation a lab would integrate rather than write:

• Direct encrypted: BIP-324 [Mehta et al. 2023] v2 transport (reference: Bitcoin Core [Bitcoin Core 2024]); QUIC/TLS 1.3 with Encrypted Client Hello pinned.

• Fully encrypted obfuscation: obfs4-class pluggable transports (reference: Tor pluggable transports). Retained for jurisdictions that do not run entropy-based blocking; published as its own class because it fails first where they do.

• Mimicry (look-like-TLS): transports whose wire image is a valid TLS session to a plausible host — uTLS-style fingerprint mimicry and WebTunnel-class HTTPS tunnels (reference: Tor WebTunnel) — so the flow is indistinguishable from ordinary web traffic to a passive observer.

• Rendezvous: Snowflake-class WebRTC through ephemeral volunteer proxies, with a domain-fronted or AMP-cache broker (reference: Tor Snowflake), for the case where every fixed endpoint is blocked.

• Refraction: Conjure-class refraction networking, in which the client connects to an unused address in a partner ISP’s space and a station in the path redirects the flow (reference: Refraction Networking / Conjure [Frolov et al. 2019]); the highest-latency and highest-partnership-cost class, and the fallback of last resort.

• Onion routing: Tor and I2P as first-class transports, not fallbacks, for receiver privacy as well as reachability [Dingledine et al. 2004].

The client’s failover order is a published policy, not a heuristic, and every fallback taken is recorded in $\text{fail}_{\text{mix}}$ so that a region quietly living on refraction is visible on the board.

Receiver-private routing for payments:

• BOLT12 Offers [NoBS Bitcoin 2024b] (receiver-private, reusable invoices) in wallets and merchant stacks.

• Path-blinding where supported.

• Federated ecash [Fedimint Project 2024–25] and shielded pools as optional “last-mile” sinks/sources.

Settlement survivability:

• Adaptor-signature atomic swaps [Gugger 2020] for BTC$\leftrightarrow$XMR corridors with typed failure & refund flows; the BTC$\leftrightarrow$shielded-ZEC corridor is gated on shielded-pool signing work that does not yet exist (Chapter 23: Layer 5: Value & Settlement).

• Wallet UX exposes “abort & refund” as a first-class path.

Topology & anti-eclipse hardening:

• Peer-set diversity targets (geo/ASN spread), randomized peer rotation, inbound slot quotas.

• Gossip-path multiplicity to reduce single-jurisdiction capture.

• Light-client modes that verify receipts over any reachable path (browser, mobile, enclave).

Triad
Privacy, Proofs, and Compute — three cryptographic service capacities that may support a monetary candidate. Whether they should share one asset is tested by the Triad Coherence Test, not assumed.

Triad Coherence Test
The test of whether the three triad services should share one asset at all. Privacy settlement, portable proof, and verified compute are different goods with different users, bottlenecks, collateral needs, political risks, and duration warehouses; a common asset is justified only if shared security, settlement, liquidity, and transaction-cost benefits exceed cross-subsidy, governance, and wrong-way-risk costs. Three architectures are under test — (A) one native monetary asset, (B) a neutral reserve plus service-specific credits, (C) shared settlement plus modular domain collateral — and none is pre-selected; Architecture A is a candidate, not the thesis. See Chapter 8: The Triad and the Monetary Candidate.

Conditional chain
The nine-link argument by which the thesis establishes its claim rather than asserting it: utility demand $\rightarrow$ standardized work $\rightarrow$ cheap-to-check receipts $\rightarrow$ stress-deliverable service $\rightarrow$ markets $\rightarrow$ fee flows $\rightarrow$ a scarce asset (only under non-bypassable accrual) $\rightarrow$ a persistent, self-custodied, loss-bearing, regime-responsive holder constituency $\rightarrow$ a possible store-of-value premium. Every arrow is a conditional; each link names where it is defended and what would sever it, and Chapter 8: The Triad and the Monetary Candidate rates them. Red Lines 1–15 read on links 2–8; Red Lines 16–18 read on link 9. See Chapter 8: The Triad and the Monetary Candidate.

VerifyPrice(W)
A public KPI vector measuring the cost and time to verify workload $W$. Canonical form $(p_{50,t}, p_{95,t}, p_{50,c}, p_{95,c}, \text{fail})$; the input and cost-vector tuples elsewhere are views of it (Appendix A: Formal Model of Verification Asymmetry & VerifyPrice).

VerifyReach(N,R)
Metrics for network reachability under censorship conditions.

VerifySettle(C)
Metrics for settlement success and safety on corridor $C$.

Value Capture Lemma
The bridge from service use to asset accrual in the reference design: demand for triad capacity reaches the native asset through five channels the design relies on together—required fee medium, supply reduction via burns, collateral lockup, issuance discipline, and non-bypassability. Each is necessary to this design’s route, not to value capture in general. It establishes a cash-flow claim and a collateral lockup, not monetary premium. See Chapter 13: Why Hold the Base Asset?.

$r(W)$
Verification overhead ratio: the maximum of the median time ratio and the median cost ratio, $r(W) = \max\bigl(p_{50,t}(W)/p^{\text{prod}}_{50,t}(W),\; p_{50,c}(W)/p^{\text{prod}}_{50,c}(W)\bigr)$, verification over production. Read against a modality band (M1: $10^{-3}$; M2: $10^{-2}$; M3: no ratio target), with the legacy $0.3$ ceiling retained as an engineering floor on which no monetary claim reads. See Appendix A: Formal Model of Verification Asymmetry & VerifyPrice, Chapter 22: Layer 4: Truth & Work.

VerifyPower
Token-quoted VerifyPrice, a market signal and not a constitutional target: $\text{VerifyPower}(\text{token}; W^{\ast}) = q_{\text{fee}}(W^{\ast}) \cdot P_X / p_{50,c}(W^{\ast})$ for a single pinned reference workload $W^{\ast}$, where $q_{\text{fee}}$ is the fee schedule in units of the native asset and $P_X$ its USD reference price, so the token price appears explicitly on the right-hand side. A vector has no reciprocal; the scalar is constructed by naming the workload and the field. The token-side image of the AffordabilityRatio, published together with it. See Chapter 22: Layer 4: Truth & Work.

AffordabilityRatio
$\text{VerifyCost}(W)/\text{MedianFee}(W)$, the operational SLO that verification stays affordable as a fraction of typical transaction cost; target $\leq 5\%$ for all workload classes, with a settlement variant (verification cost $\leq 1\%$ of median USD-referenced transaction value). Its perverse direction — improving when fees rise — is held in check by three guards: component disclosure, USD-referenced units for the settlement variant, and a monotonicity rule crediting only improvements achieved on a flat or falling fee. Operational, not constitutional. See Chapter 22: Layer 4: Truth & Work.

Base Asset
The protocol’s bearer fee and settlement unit and the only instrument tested as a monetary candidate. Fees, burns, collateral, or governance use establish neither moneyness nor a durable holder anchor by themselves.

Work Receipt (WR)
A PIDL artifact proving that a specific unit of work was completed under attested conditions: claim hash, proof hash, workload ID, SLA tier, timestamps, hardware profile, prover signature. Copyable, verifiable by anyone, not scarce. It proves the past and confers no future rights; Work Receipts are evidence, not money; verified delivery against a Work Credit issues one and extinguishes the credit. See Chapter 12: Work Credits: Reserved Service Claims.

Work Credit
A typed, prepaid claim on reserved future service, owed by a named provider or pool: issued against an admissible capacity commitment with sale and reservation atomic, extinguished by verified delivery, which issues a Work Receipt. Outstanding claims are bounded by stress-adjusted deliverable capacity. It may be workload-, location-, hardware-, SLA-, and time-specific; it is not presumed to be a store of value. See Chapter 12: Work Credits: Reserved Service Claims.

Bypass Risk
The risk that users consume triad capacity (proofs, privacy, compute) through channels that do not require the native asset—e.g., fiat-denominated cloud services, stablecoin payment to operators. If bypass channels dominate, the SoV thesis fails.

Differential value ($\Delta$)
The marginal buyer’s willingness to pay for the protocol’s differential properties—cryptographic checkability, neutrality, credible non-discretion, non-custodial exit—over the best bypass channel. Bounds the sustainable fee: $f \le \Delta - (c_p - c_b)$, where $c_p$ and $c_b$ are the protocol’s and the bypass channel’s all-in costs. Also written $\Delta(R)$ when its dependence on regime pressure is at issue. A scalar wedge in price units, not the difference operator. See Chapter 13: Why Hold the Base Asset?.

Fee incidence
The question of who bears a protocol fee. With free entry and roughly constant returns, long-run supply is horizontal at marginal cost, so the fee is passed to buyers and operator economic profit is unchanged: a fee is a wedge on turnover, not a claim on residual profit. With installed capacity fixed, part of the fee is instead absorbed as quasi-rent to deployed hardware, which affects entry. See Chapter 13: Why Hold the Base Asset?.

Capturable wedge ($\omega$)
$\omega = s - \gamma$, where $s$ is the normalized bypass spread $(P^{\text{prot}} - P^{\text{byp}})/P^{\text{byp}}$ and $\gamma$ is the verification cost share (proving plus redundancy) as a fraction of $P^{\text{byp}}$. The measurable proxy for $\Delta$: what remains of the price the protocol commands after paying for the verification that justifies it. Normalized because the absolute spread shrinks mechanically with compute deflation. Read by Red Line 14, Condition A.

Realized take rate ($\tau$)
Gross native fees in USD divided by settled protocol turnover in USD — gross, not net of the burned share, because $\tau$ measures what buyers pay; burns are already inside gross fees and adding them would count destruction as payment (Chapter 25: Layer 6: Governance & Telemetry, Red Line 14). Computable by any third party from chain data. Compared against $\omega$ rather than against a guessed threshold, which is what makes Red Line 14’s first condition self-normalizing.

Regime-Contingent Convenience Yield
The channel through which a triad asset could earn monetary premium: the holder-side service flow arising from the state-contingency of $\Delta(R)$—the bearer’s ability to transact, prove, hold, and exit when the substitutes for proofs, courts, and custodians have stopped working—conditioned on credible non-discretion and bearer holdability. It accrues by virtue of holding rather than as a distribution, so a valuation of distributions omits it; a valuation of possession need not, and a benefit of ownership is not yet monetary use. Against Bitcoin converted on the day it reduces to a balance that stays spendable when acquisition fails (see Access Experiment). Red Line 16 reads its corridor increment. Named by analogy to the convenience-yield mechanism of Kaldor (1939) and Working (1949), not by any claim that a triad asset is a storage commodity. Explicitly not the countercyclicality of the fee stream, which is a negative-beta discount-rate effect a DCF captures exactly; and explicitly not produced by burns, collateral, or fee share, which yield a cash-flow claim and a collateral lockup. Unsized. See Chapter 13: Why Hold the Base Asset?.

Collateral unit-elasticity
The property that a collateral requirement specified as a share of capacity value locks a value rather than a quantity: required units are $N = \chi K / P$ for collateral ratio $\chi$, capacity value $K$, and price $P$. Consequences: a level effect rather than a growth effect, a bound of $\chi K$ set by an accounting identity, wrong-way risk in large drawdowns, and an effect on the liquidity state $\Lambda_t$ rather than the monetary impulse $\theta_t$. See Chapter 13: Why Hold the Base Asset?.

Utility-Token Trap
The pattern where a network provides useful services but the native token fails to capture economic value because operators extract all surplus, users pay in alternative currencies, or governance inflates supply. The thesis’s value-capture conditions are designed to prevent this outcome.

Information-insensitivity
The property that no counterparty gains from acquiring private information about the particular unit or position being tendered, so it is accepted at face value without due diligence. The working definition of money-likeness in the collateral and short-term-funding literature. Scoped throughout this thesis to unit quality rather than to fundamentals: an information-insensitive asset can be violently volatile. See Chapter 13: Why Hold the Base Asset? and Sources [Dang et al. 2020].

No questions asked (NQA)
Acceptance of an asset at par without investigation of the specific unit [Holmström 2015]. The observable consequence of information-insensitivity, and what Red Line 17 tests through haircut dispersion. See Chapter 13: Why Hold the Base Asset?.

Symmetric knowledge
The route to no-questions-asked acceptance in which producing information about the collateral’s unit quality costs approximately nothing and the result is public, so no counterparty can acquire an informational edge by producing it — whether or not anyone does. The mechanism is deterrence on the claimant, not audit by the counterparty: a misrepresentation any party could falsify at zero cost is not worth attempting, so verification is constantly available and almost never used, and the object to measure is its cost, not its rate. Contrasted with symmetric ignorance, the historical route, in which producing that information is prohibitively expensive so nobody does — which holds only until somebody does, that being the run. See Chapter 13: Why Hold the Base Asset?.

Haircut dispersion
The cross-lender spread in required over-collateralization against the same asset at a common timestamp. Preferred over haircut level because it nets out price volatility; read relatively — native asset against an opaque comparable quoted by the same lenders, across independently maintained underwriting approaches — because lenders also differ in funding, balance sheet, and terms, and a shared model can produce agreement without knowledge. Primary series for Red Line 17. See Chapter 13: Why Hold the Base Asset?.

Free-choice denomination share
The fraction of contracts, among those the protocol did not require to be denominated in the base asset, whose price terms are nonetheless written in it. Reported by count, notional, tenor and counterparty tier, and never aggregated with the mandated complement, which is a routing rule rather than evidence. Primary series for Red Line 18. See Chapter 13: Why Hold the Base Asset?.

Verification modality (M1/M2/M3)
The three ways of establishing that work was done correctly, differing by orders of magnitude and in kind: succinct proof (M1; target $r(W) \leq 10^{-3}$, stretch $10^{-5}$), algebraic or probabilistic check with published soundness error (M2; target $r(W) \leq 10^{-2}$, Freivalds-style matrix verification [Freivalds 1977] the canonical case), and replicated or attested execution (M3; no ratio target, because the ratio is not the operative quantity). Only M1 and M2 deliver the symmetric knowledge the monetary mechanism requires; M3 supports service delivery, Work Credits and SLA tiers but not the pledgeability claim, because a position resting on a committee requires a view about that committee. See Chapter 22: Layer 4: Truth & Work.

Stage A index ($R_t$)
The regime-pressure index of the three-stage demand model: $R_t$ indexes financial repression, surveillance, synthetic media, and AI concentration, and generates demand for triad capacity, $D_t^{\text{triad}} = g(R_t)$. Compute demand is deliberately not a component of $R_t$ — it is a demand driver in its own right, entering alongside regime pressure — so that the demand function is not partially defined in terms of its own output. Also the argument of $\Delta(R)$, and the series by which regime-pressure episodes are identified for Red Line 16 and Warning 13, under criteria published before the reading. See Chapter 13: Why Hold the Base Asset?.

Phase gates
The observable thresholds that make the adoption curve auditable. Each phase has entry gates (for I$\to$II: VerifyPrice for $\geq 3$ canonical workloads with $\geq 6$ months of history within SLO, one corridor with zero protocol-attributable refund failures, overall refund_safe $\geq 99.5\%$ and success $\geq 95\%$, VerifyReach for major regions, $\geq 1000$ receipts/day; for II$\to$III: FeeCoverage $\geq 30\%$ of the security budget sustained 12–24 months, budgeted workloads exceeding speculative ones, VerifySettle surviving a policy shock; for III$\to$IV: collateral use in $\geq 3$ independent venues, SLOs holding through macro stress, FeeCoverage $\geq 50\%$) and failure gates that regress to the prior phase. Calendar horizons are intentionally omitted. The 30% gate is a phase-regression gate, distinct from Red Line 5’s 10%. See Chapter 29: Adoption Curve & Ecosystem Dynamics.

Capital cycle (installation/deployment)
Perez’s sequence for technological surges: an installation phase financed by increasingly speculative structures, a clearing Turning Point that reprices installed capacity, and a deployment phase operating on the repriced substrate. Adopted for the transfer mechanism only — the clearing event’s transfer of installed capacity from weakly financed owners to stronger users at lower capital cost — as a cross-cutting clock on Chapter 29: Adoption Curve & Ecosystem Dynamics, not as a periodization or a forecast. The thesis’s instruments, not the frame, govern where they conflict. See Sources [Perez 2002].

Turning Point (capital cycle)
The clearing event that ends an installation phase: financing structures written against utilization assumptions that did not arrive are repriced, and the installed base changes hands. Not a prediction of this thesis and not timed by it. Its relevance is that the fee base measured by Phase III fee coverage is plausibly a post-Turning-Point quantity (Chapter 29: Adoption Curve & Ecosystem Dynamics), and that Condition B of Red Line 14 is the trip wire for the deployment phase failing to materialize. See Sources [Perez 2002].

PIDL
Proof Interface Definition Language — the minimal receipt schema for proofs and settlements.

PaL
Proofs-as-a-Library — SDK that compiles claims to proofs.

PRK
Privacy Rails Kit — executes non-custodial, refund-safe settlement over privacy corridors.

User-outcome series
The overall reading of a corridor’s refund-safety metric: every off-happy-path transaction stays in the denominator, and a party that had an exit and did not take it counts as a failure, published with the value lost and its root-cause class; the protocol-attributable reading sits beside it (Chapter 23: Layer 5: Value & Settlement).

FER
Facility Energy Receipt — signed summary of a site’s energy use over a time interval.

FCR
Facility Capacity Receipt — extends FER data with infrastructure resilience, grid, cooling, jurisdictional, and hardware-diversity metrics. See Chapter 17: Layer 0: Verifiable Machines & Energy.

Delivered Verified Capacity (DVC)
Scenario-specific maximum surviving flow from energy and fuel through firm electricity, transformer and switchgear, cooling and water, hardware, network, workload, proof, verification, settlement, and usable service. Reports the active binding constraints, substitution latency, and common-cause dependencies. See Chapter 17: Layer 0: Verifiable Machines & Energy.

Physical VerifyPrice
The cost of auditing the physical infrastructure claims (FCR) behind a unit of verified work: time, cost, challenge-success rate, and open discrepancies (Chapter 22: Layer 4: Truth & Work, Appendix A: Formal Model of Verification Asymmetry & VerifyPrice). Read by Red Line 10.

Real-Resource VerifyPrice SLO
The constitutional cost band on verifying a workload’s receipts, measured in real resources on reference hardware and exogenous to token price (Chapter 22: Layer 4: Truth & Work). Read by Red Line 1. Distinct from Physical VerifyPrice: a network can verify proofs cheaply while its facilities are opaque, and the converse.

Sovereign Optionality ($\mathcal{O}_s$)
A capacity-weighted composite of substitutability attributes—fuel diversity, firmness, interconnection, jurisdictional dispersion, and hardware mix—computed from Facility Capacity Receipt fields. It correlates with the number of independent physical pathways by which verified work can continue under disruption, but does not literally count them; the pathway-count question is answered by Delivered Verified Capacity. The network-level figure $\mathcal{O}_s^{\text{net}}$ is the capacity-weighted mean across facilities less a concentration penalty (an average of two capacity-share Herfindahl–Hirschman indices, over jurisdictions and over balancing authorities). Feeds risk haircuts and Red Line 13. See Chapter 17: Layer 0: Verifiable Machines & Energy.

Topological Scarcity Lemma
A nominal stock does not secure a monetary service; the relevant quantity is stress-deliverable flow through the narrowest non-substitutable edge connecting input to holder utility. See Chapter 8: The Triad and the Monetary Candidate.

Pressure–Capacity Corridor
The relation $\Pi_{\mathrm{monetary}}(R)\propto\Delta(R)\times A_{\mathrm{full\mbox{-}stack}}(R)\times H(R)$. Its likely shape is an inverted U because differential demand rises as substitutes weaken while stack availability and holder agency can fall under extreme pressure. See Chapter 8: The Triad and the Monetary Candidate.

Disruption-Adjusted VerifyPrice
The probability-weighted cost of verification across physical disruption states, rather than the observed cost under benign conditions. Used to price whether a resilience premium is buying anything. See Chapter 17: Layer 0: Verifiable Machines & Energy.

Energy Interdiction
The adversary class in which curtailment, rationing, tariff discrimination, interconnection denial, or long-lead equipment scarcity is used to raise the physical cost of verification without any prohibition on cryptography. See Chapter 5: Threat Model.

PoUW
Proof of Useful Work — consensus mechanism where block rewards are earned by producing verifiable receipts of useful compute.

SLO
Service Level Objective — published targets for system performance and availability.

Bronze/Silver/Gold
The latency tiers for canonical workloads — prove-side p95 to attested result of 60 s / 10 s / 2 s at fee multipliers $1.0\times$ / $1.3\times$ / $1.6\times$ (Chapter 22: Layer 4: Truth & Work). Assurance is a separate axis indexed by verification modality (Replicated, Replicated-plus-audit, Probabilistic, Succinct), and a quote names one of each. The same three words name the power-firmness classes of Appendix D: Energy & Plant Architecture (interruptible / curtailable-with-notice / firm), which map onto the latency tiers but are not the same object; and “Gold assurance” in Chapter 17: Layer 0: Verifiable Machines & Energy is the Layer 0 sampling-evidence tier, unrelated to either.

MatMul-PoUW
Proof of Useful Work construction based on matrix multiplication verification.

ZK Money
An analytical lens or legacy label for service instruments referencing Privacy + Proofs. Those claims are not presumed money; only the separate base asset is a conditional monetary candidate.

Attestation Money
An analytical lens or legacy label for proof-capacity and provenance-attestation demand. Older material calls it “Truth Money”; it does not promote proof claims into money.

AI Money
An analytical lens or legacy label for service instruments referencing Compute + Proofs (verified FLOPs, inference capacity). Work Credits beneath the lens remain typed service claims.

Layer 0
Verifiable Machines & Energy — open hardware and sampled supply chains as base reality.

Layer 1
Reachability — communications and transport resilience.

Layer 2
Distribution & Execution — software supply and runtime.

Layer 3
Identity & Claims — pseudonymous credentials without doxxing.

Layer 4
Truth & Work — proof systems, PoUW, VerifyPrice.

Layer 5
Value & Settlement — privacy rails and non-custodial flow.

Layer 6
Governance & Telemetry — keeping neutrality and resilience measurable.

Market Realization Plane
The external financial machinery—exchanges, custody, ETFs, treasury vehicles, index products, derivatives, dealers, passive mandates, systematic and agentic allocation rules—through which claims on the native monetary object are represented and priced. Orthogonal to the stack, not a layer within it. See Chapter 13: Why Hold the Base Asset?.

Native instrument
A protocol-internal asset, typed service claim, evidence artifact, staking or LP position, corridor claim, or capacity voucher. Touching the protocol does not make the instrument monetary.

External financial wrapper
A conventional market product written on the asset (spot ETF, ETP, treasury company, custodial balance, future, option, swap, leveraged or inverse ETP). Holding it exercises nothing. Unqualified “wrapper” means this.

Value capture vs. price capture
Value capture routes native demand through the monetary object via fees, burns, and collateral. Price capture is demand for exposure to the asset’s price, which can occur with no protocol use at all. Neither implies the other. See Chapter 13: Why Hold the Base Asset?.

VerifyFlow
The fourth verification family: telemetry for the external financial representation and price-transmission state of the native asset. See Appendix A: Formal Model of Verification Asymmetry & VerifyPrice, Chapter 26: Extended Telemetry.

Flow elasticity ($\varepsilon$)
The responsiveness of a wrapper’s shares outstanding to changes in its value per share. $\varepsilon \approx 0$ means holders sit still; $\varepsilon \approx -1$ means they trim to a constant dollar position. Measured, not structural. See Appendix H: Formal Model of Market Realization, Wrapper Flows, and Price Capture.

Net mechanical gain ($\kappa$)
$L(L-1) + \varepsilon L^2$; the coefficient converting an underlying return into a wrapper’s total return-coupled exposure demand. See Appendix H: Formal Model of Market Realization, Wrapper Flows, and Price Capture.

Wrapper Recycling Ratio (WRR)
$-\varepsilon L/(L-1)$. Equal to 1 when holder flows fully offset gross rebalancing; below 1 the wrapper amplifies; above 1 it is countercyclical. Domain $L \notin \{0, 1\}$, inverse products included. Undefined at $L = 1$: an unlevered wrapper has no rebalancing trade to recycle, so the spot ETF publishes $\varepsilon$ itself (for which $\kappa = \varepsilon$) and the board never carries a WRR column for it. See Appendix H: Formal Model of Market Realization, Wrapper Flows, and Price Capture.

Wrapper Dominance Ratio (WDR)
A reported pair, never divided into one scalar: the stock form, $\mathrm{CustodialExposureShare}_t = E^{\text{wrapper}}_t / (E^{\text{wrapper}}_t + E^{\text{native}}_t)$, bounded in $[0,1]$; and the flow form, $\mathrm{WrapperActivityRatio}_{t,h} = V^{\text{wrapper}}_{t-h:t} / V^{\text{native}}_{t-h:t}$ over a published horizon $h$, unbounded above. Exposure is measured at an instant and usage over an interval, so a single ratio would scale with the window. A rising stock share with a rising activity ratio indicates the asset may be financializing faster than it is becoming money; Red Line 9 requires both components to rise, and publishes the split when they diverge. See Chapter 13: Why Hold the Base Asset?.

Mechanical Pressure Ratio (MPR)
Published in two forms that are never averaged, ranked, or combined. Gross, $\mathrm{MPR}^{\text{gross}} = \sum_j |Q^{\text{mkt}}_j| / V_X$, counts every dollar of liquidity consumed on both sides and measures pressure; net, $\mathrm{MPR}^{\text{net}} = |Q^{\text{mkt}}| / V_X$, nets offsetting flows first and measures direction. $V_X$ is the asset’s executable liquidity over the same window; $Q^{\text{mkt}}$ is realized market demand, the dealer-intermediated image of exposure demand $Q^{\text{exp}} = Q^{RC} + Q^{RD}$. Read by Market Realization Warning 3. See Chapter 26: Extended Telemetry.

Custodial Control Ratio (CCR)
Base asset controlled by custodians and wrappers, divided by circulating supply. A stock, not a flow instrument; one of the two exposure components Red Line 9 reads in its full form. See Chapter 26: Extended Telemetry.

Synthetic Exposure Ratio (SER)
Delta-adjusted derivative exposure divided by liquid free float. See Chapter 26: Extended Telemetry.

Recursive Claim Ratio (RCR)
Exposure held in wrappers whose underlying is itself another wrapper or derivative, divided by total wrapper exposure, delta-adjusted on both sides over the same window as SER. One minus RCR is the share of wrapper exposure that bottoms out in the native asset directly. See Chapter 26: Extended Telemetry.

Native Use Share (NUS)
The share of observable economic activity touching the asset that actually settles through the protocol-native monetary loop: numerator, the USD value of native-loop settlement (fee-paying, proof-carrying, or corridor) over the window; denominator, all activity on public venues and wrappers reporting the asset over the same window. The universe is pre-declared with the metric; activity invisible to public data is excluded from both sides and acknowledged as a coverage limit, not assumed zero. See Chapter 26: Extended Telemetry.

Return-coupled vs. return-decoupled flow
Return-coupled flow ($Q^{RC}$) responds to the return itself and shapes volatility and persistence. Return-decoupled flow ($Q^{RD}$) arrives largely independent of the day’s return and shapes destination and level. See Appendix H: Formal Model of Market Realization, Wrapper Flows, and Price Capture.

Wrapper–Native Growth Gap (WNG)
$\Delta \ln E^{\text{wrapper}} - \Delta \ln U^{\text{native}}$, computed on unit-de­nom­i­nated quantities over a trailing four-quarter window (asset-price revaluation stripped from both sides), with the USD-denominated series published alongside. Persistently positive means financial exposure is outgrowing monetary use.

Red Line
A protocol failure condition that falsifies or weakens the store-of-value claim if it persists without credible remediation: verification breaks, settlement safety breaks, native value capture fails, issuance becomes discretionary, censorship routes dominate, native use can be bypassed, or the link-9 monetary mechanisms fail to read. Eighteen are named, each with a severity label — kills (the chain’s hinge is severed) or weakens (one leg of support is removed and the thesis survives only in restated form). See Chapter 30: Risk Analysis & Failure Modes.

Market Realization Warning
A second, weaker class of signal generated by the Market Realization Plane and deliberately not a red line: it means price has become an unreliable signal, and it suspends the right to cite price as evidence about the protocol without necessarily saying anything about protocol function. A wrapper unwind can destroy price while damaging nothing; treating that as falsification would be as sloppy as treating a rally as confirmation. Triggers include a break in flow elasticity, a sign change in $\kappa$, MPR exceeding market-depth bounds, wrapper creations dominating native spot demand, and dealer swap capacity binding. Thirteen are named. See Chapter 30: Risk Analysis & Failure Modes.

Service-Good Realization
The pattern in which triad capacity is consumed at scale while the asset shows no insurance signature across repeated regime-pressure episodes and the monetary bid accrues elsewhere. Prescribes reclassification to verified-capacity service asset, not retirement. Filed as Market Realization Warning 13 because its corroborating clause reads on price; Red Line 15 separately covers the native collateral–capacity spiral. See Chapter 30: Risk Analysis & Failure Modes.

Participation Line
The household or organizational threshold below which a person or firm lacks the redundancy to act freely across time—to fail, retry, transact, move, learn, refuse coercive terms, or survive shocks. Below it, legal rights remain on paper while agency disappears in practice, and financial repression becomes politically durable. Approached along the exhaustion gradient. See Chapter 3: The World Forces New Monetary Primitives.

Homestead Ratio
The share of verified compute, proof generation, and AI-service capacity supplied by open-admission, non-hyperscaler, geographically diverse, independently verifiable operators. Its complement is read by the Enclosure Risk Flag and Red Line 11. See Chapter 5: Threat Model.

Agency preservation (ninth SoV requirement)
The system should equip users to act privately, verifiably, and non-custodially without becoming a surveillance or dependency layer. Privacy, identity, reputation, and compliance features must be designed as tools in the user’s hands: selective disclosure rather than global inspection, receipt-based reputation rather than biographies, and non-custodial settlement rather than managed accounts. A system that makes users legible but not free has failed the political-economy test even if its cryptography is sound. Enforced on both the formal-access and the capability layer; read by Red Line 12. See Chapter 4: First Principles: What a SoV Must Survive.

Exhaustion gradient
The approach path to the participation line: a household remains formally inside the system (banked, employed, housed, consuming) while its capacity to accumulate declines, so aggregates register nothing until a delinquency or unemployment threshold is crossed. Dollar-weighted measures lag person-weighted depletion by construction. See Chapter 3: The World Forces New Monetary Primitives.

Household transmission
The layer converting aggregate growth into household income, security, shelter, and savings. Its characteristic failure is depletion beneath resilient aggregates: consumption sustained by drawdown rather than income. Formally, operating surplus $O_i = Y_i + I_i + T_i - E_i - DS_i < 0$ financed by depleting resilience stock $R_i$. See Chapter 33: The Closed Sovereign Stack.

Distributed resilience
The requirement that system resilience be assessed jointly across the sovereign layer ($R_{\text{state}}$: energy, industry, defense, administration) and the household layer ($R_{\text{household}}$: shelter, savings, family formation, shock absorption), because a state can remain stable while financing continuity from household buffers — $R_{\text{state}} \neq R_{\text{household}}$. Fragility transferred downward returns through politics and defaults. See Chapter 33: The Closed Sovereign Stack.

Representation discipline
The publication rule that every aggregate over households or holders discloses its weighting rule, because dollar-weighted and person-weighted summaries of the same observations can move in opposite directions: $\bar{x}_{\text{dollar}} - \bar{x}_{\text{person}} = \operatorname{Cov}(C_i, x_i)/\bar{C}$. A verified aggregate can be accurate and describe almost no participant; the weights are the explanation, and they are published. See Chapter 26: Extended Telemetry.

Capability vs. formal access
Formal access is a valid balance and the legal right to transact; capability is command over the necessities of an independent life. A ledger can supply the first while the second fails, because making claims harder to alter does not broaden who can acquire them. The ninth SoV requirement is enforced on both layers. See Chapter 4: First Principles: What a SoV Must Survive, Chapter 34: Objections & Responses.

Capital Survival Ratio (CSR)
Whether successive investor cohorts in a wrapper preserved capital, as distinct from whether the product preserved AUM. See Chapter 26: Extended Telemetry.

Policy Concentration Ratio
The share of net asset demand governed by the largest common rebalancing templates, treasury algorithms, robo-advisers, or agent policies. Ownership can be decentralized while behavior is not.

Delegation hop
A transfer of a task specification across a principal–agent boundary, returning an artifact; lossy in intent in both directions (Chapter 7: The Delegation Economy: Who Buys Verification).

Trust perimeter
The set of processes a party can sanction by means outside the protocol. A hop crosses a perimeter when the child’s operator is reachable only through the protocol.

Cross-Perimeter Share (CPS)
The fraction of delegation hops in a measured population that cross a trust perimeter; the demand variable for portable receipts. Not computable until receipts carry a field committing to the operator boundaries crossed.

Standing
The locus of ownership, consent, liability, and revocation over an acting process; enforceable through the stack when a person holds the key root, the delegation ceiling cannot be raised by the agent, and revocation is a protocol operation (Chapter 7: The Delegation Economy: Who Buys Verification).

Principal Map
An overlay on the native-demand and native-holder boards that classifies each flow and cohort by ultimate principal—human with standing, firm, agent policy, or unknown—and publishes the unknown residue rather than reassigning it (Chapter 26: Extended Telemetry).

Control Overlay
Seven fields recorded for each operator a board already counts (operator and ultimate controller, admission and refusal authority, jurisdiction, revenue and residual claims, creditor and rescue rights, replacement path, and user rights after replacement), so that capacity under one controller, creditor, or jurisdiction is not counted as independent; what cannot be established is published as unknown (Chapter 26: Extended Telemetry).

Human-Revocable Share (HRS)
The fraction of agent-controlled native balances whose key root is held by a human with standing and whose revocation is a protocol operation.

Native Policy Concentration Ratio (NPCR)
The Policy Concentration Ratio computed over native positions (collateral, liquidity, reserves) rather than wrapper flows; published with exit correlation.

Standing inversion
The failure kind in which agents acquire de facto standing while human title over them ceases to bind (Chapter 5: Threat Model).

Compositional adversary
A failure mode with no malicious actor: locally rational agents whose incompatible operating rules combine into concentration, procyclicality, recursive leverage, and uninformative prices. See Chapter 5: Threat Model.

Collateral Loop
The reflexive circuit in which asset values support tax receipts, receipts support fiscal capacity, fiscal capacity and central-bank support sustain Treasury market functioning, and Treasury yields sustain asset values. See Chapter 3: The World Forces New Monetary Primitives.

Collateralized Sovereign Stack
A description of the incumbent macro order, in which a state’s effective fiscal capacity depends on the market value of the asset complexes it regulates. A diagnosis, not an architecture; distinct from the seven layers this thesis specifies. See Chapter 3: The World Forces New Monetary Primitives.

Sovereign Credit Safety vs. Collateral Stability
Credit safety is the probability of nominal repayment; collateral stability is the reliability of the instrument’s price at the horizon over which it is used as margin and reference. An obligation can have the first and lack the second. See Chapter 3: The World Forces New Monetary Primitives.

Automatic vs. Marginal Buyer
The automatic buyer supplies demand by formula. The marginal buyer absorbs residual duration and therefore sets the price. Quantity of bids and quality of risk absorption are different objects. The two are one chain where the automatic buyer obtains its benchmark duration synthetically and leveraged intermediaries supply the other side. See Chapter 3: The World Forces New Monetary Primitives.

Description Becomes Instruction
The condition in which an index that reports the market—how much eligible debt is outstanding, at what value, with what duration—comes to direct the portfolios managed against it, so that the seller of credit determines the portfolio of the buyer of credit. The human-institutional form of a holder base that is instances of one rule. See Chapter 3: The World Forces New Monetary Primitives, Chapter 5: Threat Model.

Duration-Absorption Capacity
The capacity of unlevered, automatic, and levered absorbers together to take incremental sovereign interest-rate risk (in DV01) in a period, bounded by repo funding, dealer balance sheet, margin, and volatility. The ratio of incremental DV01 to this capacity, not the debt ratio, is where the state model locates the binding constraint. See Chapter 3: The World Forces New Monetary Primitives, Chapter 29: Adoption Curve & Ecosystem Dynamics.

DV01
The dollar change in value produced by a one-basis-point change in yield. The relevant unit for whether a buyer is warehousing interest-rate risk. See Chapter 3: The World Forces New Monetary Primitives.

Duration of the Claim vs. Duration of the Project
Duration of the claim is the interest-rate exposure of a promised cash flow, which a repression-resistant store of value must not be. “Duration-neutral” means no contractual nominal duration; it does not mean insensitive to discount rates, liquidity, or expected utility. Duration of the project is the years between committing present resources and receiving the output of a long-lived physical asset. See Chapter 3: The World Forces New Monetary Primitives.

Duration Warehouse
An institution capable of converting present savings into long-lived productive capacity without being forced to liquidate, refinance, or reprice at the worst moment. A diagnosis of the incumbent order, not a layer of the cypherpunk stack. See Chapter 3: The World Forces New Monetary Primitives, Chapter 34: Objections & Responses.

Buyer-Quality Checklist
Persistence of funding, investment horizon, match to an enduring liability, capacity to bear losses without forced liquidation, and countercyclical willingness to add risk when prices fall. Published as fields, not as a multiplicative index. See Chapter 26: Extended Telemetry.

Native Monetary Buyer Map
Telemetry separating just-in-time fee acquisition, operator sell-through and inventory, burns and net issuance, self-custodied reserve demand, wrapper demand, leverage, holding period, loss-bearing capacity, and countercyclical accumulation, with every reserve outflow classed as forced liquidation, operating turnover, or exercise (spending on the service during stress, which counts for the mechanism). See Chapter 26: Extended Telemetry.

Access Experiment
The pre-registered test of whether holding the base asset in advance beats the best feasible Bitcoin-funded strategy — acquisition on the day, provider-side conversion, reserves plus service reservations — for a given workload and stress state, on equal budgets fixed before the disruption. Failure condition: Bitcoin-funded procurement reproduces the service within the same constraints without material disadvantage. A pass is not yet a reserve (Premise 7). A Phase I deliverable, not a counted red line. See Chapter 13: Why Hold the Base Asset?.

Corridor Increment
$\theta_{16}$: the adjusted holder-service reading in the pre-registered moderate-pressure band minus the reading in the benign state. Red Line 16 trips when its upper uncertainty bound lies below the pre-registered minimum economically meaningful increment. See Chapter 30: Risk Analysis & Failure Modes.

Underwriting-Model Provenance
Each Red Line 17 panel lender’s declaration of whether its haircut model is independently maintained, shared, templated, data-dependent, or copied. Agreement under a shared model is not evidence of symmetric knowledge; fewer than five independent approaches reads unidentifiable. See Chapter 30: Risk Analysis & Failure Modes.

Project Note
Explicit duration-bearing infrastructure credit with stated maturity, covenants, default states, and loss priority. Proofs may audit it; no par, redemption, or emergency-support promise may transfer to the base asset. See Chapter 34: Objections & Responses.

Sovereign Maturity Transformation
Financing long-lived public assets and commitments with short-term public liabilities. Duration is transferred onto the rollover calendar, not extinguished. See Chapter 3: The World Forces New Monetary Primitives.

National-Champion Pathway
The conversion of private firms into protected quasi-public infrastructure because the state’s fiscal or security position depends on them. Also enclosure by rescue. See Chapter 5: Threat Model.

Numeraire-Dependence
The property that a measured price path is jointly determined by the asset and by the unit it is quoted in, so the same series can support opposite conclusions about real command over resources. See Chapter 13: Why Hold the Base Asset?.

Open Technology vs. Open Sovereignty
Open-source or open-weight software is sovereign only where users can independently obtain the power, hardware, data, communications, privacy, and settlement to run it. Openness at one layer is compatible with concentration beneath it. See Chapter 33: The Closed Sovereign Stack.

Strategic Tempo
The conversion of physical resilience into control over when a disruption becomes binding, and thence into bargaining power. See Chapter 33: The Closed Sovereign Stack.

Kardashev Labs
The build-and-measure institution this thesis proposes to construct and instrument the stack; it issues no monetary instrument and holds no protocol treasury. See Chapter 32: Kardashev Labs: Build and Measure.

This appendix develops the flow machinery behind the Market Realization Plane (Chapter 13: Why Hold the Base Asset?) and VerifyFlow (Chapter 26: Extended Telemetry). It is deliberately quarantined here: the main body needs the distinction between value capture and price capture, not the derivations.

Attribution.

The flow machinery below—flow elasticity, holder recycling, and the return-coupled versus return-decoupled distinction—is adapted from Michael W. Green’s work on how product mechanics and holder behavior set prices, in particular A Semi-Theory of Almost Everything (Tier1 Alpha, July 2026) [Green 2026a]. Two of the results it builds on are older and are cited to their sources: the daily-reset rebalancing identity of Appendix H: Formal Model of Market Realization, Wrapper Flows, and Price Capture, that a fund with leverage $L$ must trade $L(L-1)$ times its assets times the underlying return and that this holds for inverse as well as long leverage, is Cheng and Madhavan (2009); the volatility-drag result of Appendix H: Formal Model of Market Realization, Wrapper Flows, and Price Capture, that a daily-reset product’s compound return carries a $-L^{2}\sigma^{2}/2$ variance penalty and is path-dependent, is Avellaneda and Zhang (2010). What is drawn from Green is the flow and recycling framing that sits on top of those identities: that holder flows into and out of the product are themselves return-coupled, and that the two mechanical trades can offset. The market-impact form is the square-root “law” of execution cost from the market-microstructure literature, in which impact scales roughly with the square root of order size relative to available liquidity; it is not Gabaix and Koijen’s aggregate demand-elasticity multiplier, which does not appear in this model. Gabaix and Koijen (2021) is relied on only for the broader inelastic-markets premise—that flows move prices at all, because aggregate demand for financial assets is far less elastic than textbook treatments assume—which is why a flow-based telemetry layer is worth publishing. The thesis’s own contribution is the generalization from equity market structure to monetary telemetry: the claim that these quantities must be published as a distinct verification family (VerifyFlow) precisely so that price movement is not mistaken for monetary adoption. Any errors in that generalization belong to the thesis, not to its sources.

A caution before the mathematics. These equations describe transmission and magnitude. They do not explain why a narrative ignites a behavioral shift in the first place. Flow elasticity in particular is measured, not explained. Treating any parameter below as a structural constant is a modeling error.

Symbol collisions.

Two symbols in this appendix are also used elsewhere in the thesis with unrelated meanings, and the reader should not carry either across. $\varepsilon$ here is flow elasticity, a dimensionless regression coefficient; in Chapter 22: Layer 4: Truth & Work $\varepsilon_r$ is the relative acceptance tolerance of the FP32 MATMUL bound. $\kappa$ here is the net mechanical gain coefficient; in Chapter 17: Layer 0: Verifiable Machines & Energy $\kappa_f$ is facility $f$’s share of verified capacity, the weight in the network-level Sovereign Optionality aggregate. Within this appendix both symbols carry only the market-realization meanings defined below.

Flow Elasticity

For wrapper $i$, estimate the responsiveness of shares outstanding to changes in value per share:

$$\Delta \ln S_{i,t} = \alpha_i + \varepsilon_{i,t}\,\Delta \ln \mathrm{NAV}_{i,t} + u_{i,t}$$

where $S_{i,t}$ is shares outstanding, $\mathrm{NAV}_{i,t}$ is value per share, and $\varepsilon_{i,t}$ is flow elasticity. Interpretation: $\varepsilon \approx 0$ means holders largely sit still; $\varepsilon \approx -1$ means holders redeem roughly enough after gains to maintain a constant dollar position.

The regression has three parts and each is allocated to a different place downstream, so the decomposition must be stated rather than assumed. The $\varepsilon$-driven component is return-coupled and belongs in $Q^{RC}$ below. The intercept $\alpha_i$ captures baseline creation or redemption that occurs regardless of the day’s return — distribution growth, model-portfolio adoption, scheduled contributions — and therefore belongs in the return-decoupled term $Q^{RD}$, not in $Q^{RC}$. The residual $u_{i,t}$ stays unexplained and is published as its own series, never absorbed into either aggregate: $Q^{RD}$ consumes $\alpha$ only. Assigning $\alpha_i$ to $Q^{RC}$ would overstate momentum amplification; absorbing $u_{i,t}$ into either term would launder unexplained variation into a named flow. The published triple $(\hat\varepsilon, \hat\alpha, u)$ is the complete accounting; the aggregates consume two of the three.

Identification: the regression is simultaneous, and the bias is not benign.

$\Delta \ln \mathrm{NAV}_{i,t}$ is not exogenous to $\Delta \ln S_{i,t}$. Creations and redemptions force dealer hedging, hedging passes through the impact function of Appendix H: Formal Model of Market Realization, Wrapper Flows, and Price Capture, and impact moves the underlying — which moves the NAV being used as the regressor. The OLS estimate of $\varepsilon$ therefore suffers simultaneity bias, and its direction is the dangerous one: flows that amplify the move induce a correlation between share changes and NAV changes that OLS books as elasticity, so naively fitted $\hat\varepsilon$ overstates amplification precisely when amplification is present, and the fitted values then feed $\kappa$ and WRR downstream. Three disciplines follow. First, prefer instruments for $\Delta \ln \mathrm{NAV}$ that are exogenous to wrapper flow — underlying-index constituent news, macro release days, cross-venue price dislocation — over the raw regression. Second, where instruments are unavailable, publish the OLS estimate as an upper bound on amplification rather than as a point estimate. Third, never recycle a fitted $\hat\varepsilon$ back into the stress harness of Appendix H: Formal Model of Market Realization, Wrapper Flows, and Price Capture without reporting both the instrumented and OLS values; a harness whose elasticity was fitted on the same amplification it simulates will find it.

The second bias runs the other way, and it decides when the upper bound is safe to publish.

For a continuously traded underlying, the wrapper’s official NAV is computed on a stale or synchronized print, not on the price at which flows actually cleared. The regressor is then a noisy measurement of the true underlying return, and classical errors-in-variables attenuation pulls $\hat\varepsilon$ toward zero — understating amplification. The two biases are opposite in sign: simultaneity inflates $\hat\varepsilon$, staleness attenuates it, and which dominates is not a property of the estimator but of the underlying’s liquidity and the wrapper’s pricing convention. The upper-bound publishing rule above is therefore conditional, not absolute. A fourth discipline: publish alongside $\hat\varepsilon$ a staleness diagnostic — the divergence between the wrapper’s pricing print and the underlying’s contemporaneous venue price — and treat the OLS value as an upper bound only where that divergence is small. Where staleness is material, the OLS estimate bounds nothing in either direction, and the reading must be published as unidentified rather than as a bound.

Because a daily-reset leveraged wrapper’s NAV return is approximately $L_i r_t$ for underlying return $r_t$:

$$\frac{\Delta S_{i,t}}{S_{i,t}} \approx \varepsilon_{i,t} L_i r_t$$

Leveraged Rebalancing and Flow-Induced Exposure

A daily-reset fund must trade to restore its target exposure. The gross required rebalance is

$$Q^{\text{rebalance}}_{i,t} \approx L_i(L_i - 1) A_{i,t} r_t$$

where $A_{i,t}$ is fund assets. Note that $L(L-1) > 0$ both for $L > 1$ and for negative leverage such as $-2$ or $-3$: long and inverse leveraged funds both mechanically chase the underlying move. The inverse product is not a stabilizer.

Separately, creations and redemptions carry exposure equal to leverage times the dollar flow:

$$Q^{\text{flow}}_{i,t} \approx \varepsilon_{i,t} L_i^2 A_{i,t} r_t$$

Combining the two gives total return-coupled mechanical exposure:

$$\boxed{\;Q^{RC}_{i,t} \approx \bigl[L_i(L_i-1) + \varepsilon_{i,t} L_i^2\bigr] A_{i,t} r_t\;}$$

Net Mechanical Gain

Define the net mechanical gain coefficient

$$\boxed{\;\kappa_{i,t} = L_i(L_i-1) + \varepsilon_{i,t} L_i^2\;}$$

so that $Q^{RC}_{i,t} = \kappa_{i,t} A_{i,t} r_t$. The sign and magnitude of $\kappa$ determine whether a wrapper amplifies or absorbs the move it sits on.

The Recycling Boundary

A wrapper fully offsets its own gross mechanical trade when $\kappa_i = 0$, which implies a critical elasticity

$$\boxed{\;\varepsilon_i^{*} = -\frac{L_i - 1}{L_i}\;}$$

Illustrative recycling boundaries. Holder behavior stops being a vague qualitative concern and becomes an observable regime boundary.

This is the single most useful conversion in the appendix: it turns “holder behavior matters” into a number that can be measured, plotted, and breached. By construction, a $3\times$ product is self-neutralizing at $\varepsilon^{*} = -0.667$. If a $3\times$ product’s elasticity sits near that boundary and weakens toward $-0.40$, the same product becomes a material momentum amplifier, and the underlying’s behavior can shift from mean-reverting toward higher volatility with greater trend persistence.

Wrapper Recycling Ratio

A more legible operator metric normalizes elasticity by its own boundary:

$$\boxed{\;\mathrm{WRR}_{i,t} = -\varepsilon_{i,t}\,\frac{L_i}{L_i - 1}\;}$$

where $\mathrm{WRR} = 1$ means holder flows fully offset gross rebalancing; $\mathrm{WRR} < 1$ means the wrapper amplifies the underlying move; and $\mathrm{WRR} > 1$ means holder flows more than offset it and become countercyclical. Those readings hold where $L(L-1) > 0$ — that is, for $L > 1$ and for every inverse product $L < 0$, which together are the daily-reset classes that exist in practice — because by the identity below the sign of $\kappa$ is then the sign of $(1 - \mathrm{WRR})$. A fractional-leverage product with $0 < L < 1$ would reverse the reading and is not covered; at $L = 1$ the ratio is undefined (next paragraph). This belongs on the public Market Realization & Wrapper Board.

The ratio and the gain coefficient are one object, and stating the identity prevents misreadings of both:

$$\boxed{\;\kappa_{i,t} = L_i(L_i - 1)\bigl(1 - \mathrm{WRR}_{i,t}\bigr)\;}$$

so the unnormalized quantity and its normalized image always move together, and any dashboard showing one can be checked against the other.

The unlevered case is the dominant one, and WRR is undefined there.

$\mathrm{WRR}$ divides by $L_i - 1$, so it does not exist for an unlevered wrapper ($L_i = 1$) — and the spot ETF, the instrument most likely to become this asset’s largest wrapper, is exactly that. The degeneracy is not a defect in the metric; it is the metric correctly reporting that an unlevered wrapper has no rebalancing obligation and therefore nothing to recycle. What remains meaningful at $L_i = 1$ is the elasticity itself: holder flows into a spot wrapper scale with $\varepsilon_{i,t} A_{i,t} r_t$ through the $Q^{RC}$ term, with no rebalancing component to offset. The publication rule is therefore: leveraged and inverse wrappers publish $\kappa$ and WRR; unlevered wrappers publish $\varepsilon$, for which $\kappa = \varepsilon$ (dimensionless, since $L(L-1) = 0$ and $L^{2} = 1$) so that $Q^{RC} = \varepsilon A r$; and the board never carries a WRR column for $L = 1$. A reader who wants a single cross-class reading should use $\kappa_{i,t} A_{i,t} r_t$ directly, which is defined everywhere.

Wrapper-Class Applicability

The machinery above was derived for fund-like wrappers with shares outstanding, NAV, and creation/redemption mechanics — the equity-ETF structure it was adapted from. Not every wrapper class that matters for a bearer asset has those observables, and applying an equation to a class that lacks its inputs does not produce a number; it produces a fabricated one. The publication contract is therefore class-conditional:

Wrapper-class applicability of the VerifyFlow apparatus. A class without the observables an equation consumes does not get a fabricated reading; it gets the substitute construction named in the last column, or nothing.

Two consequences. First, the perpetual-futures substitute matters most in practice: for a crypto-native asset, perps are plausibly the largest leveraged wrapper class, and the funding-rate-to-price response is the closest available analog to elasticity — publish it, but do not label it $\varepsilon$, because it is not estimated from the same regression and does not carry the same interpretation. Second, the convenience-yield instruments of Chapter 26: Extended Telemetry already read on the derivative complex (funding, basis); the two families meet exactly here, and a reading published by one should reconcile with the other where both touch the same venue.

Return-Decoupled Allocation Flow

Not all flow responds to returns. A thematic or passive wrapper can receive creations largely independent of the current day’s return, arriving on up days and down days alike. For underlying asset $j$:

$$\boxed{\;Q^{RD}_{j,t} = \sum_k w_{jk,t}\, F^{\alpha}_{k,t}\;}$$

where $F^{\alpha}_{k,t}$ is the return-decoupled component of net creation into wrapper $k$ and $w_{jk,t}$ is that wrapper’s exposure weight to $j$. For leveraged or derivative wrappers, $w_{jk,t}$ must be a delta-equivalent exposure weight rather than a portfolio accounting weight, or the allocation flow will be understated by roughly the leverage factor.

The input discipline is the decomposition rule of Appendix H: Formal Model of Market Realization, Wrapper Flows, and Price Capture, applied here as a boundary: $F^{\alpha}_{k,t} = \alpha_k A_{k,t}$, the intercept component of the creation regression only. The residual $u_{k,t}$ is published as its own series and enters no aggregate; the $\varepsilon$-driven component is excluded because it is already inside $\kappa_i$ and therefore inside $Q^{RC}$. Feeding raw net creation into $Q^{RD}$ would count the same dollars twice — once as elasticity-driven exposure and once as allocation — and would propagate the overstatement into MPR, the stress harness, and any red line that reads on them. The two equations of this appendix therefore partition demand by return-dependence: $Q^{RC}$ owns the $\varepsilon$-component; $Q^{RD}$ owns $\alpha$; the residual $u$ is published and consumed by nothing. Where a wrapper’s creation series cannot yet be decomposed, publish raw $F_{k,t}$ flagged as undecomposed so the aggregation layer can exclude it from $Q^{RD}$ rather than silently double-count it.

The two flow types do different work. Return-coupled flow governs volatility, momentum, persistence, and reversal severity. Return-decoupled flow governs destination and level: which assets receive the structural bid, how concentrated it becomes, and which prices are accepted without valuation-sensitive selling. For a triad asset, return-decoupled flow could arrive from a spot ETF, a crypto index product, a corporate treasury mandate, an automated wealth-allocation model, a retirement default, an agentic treasury system, or a regulated “digital hard asset” basket — all potentially enormous for price and nearly irrelevant to native triad usage.

Market Impact and Liquidity

Flow becomes price only through a liquidity-dependent impact function. The standard empirical form has impact growing roughly with the square root of trade size relative to available liquidity:

$$\boxed{\;I_{j,t} = Y_j \sigma_{j,t} \operatorname{sgn}(Q_{j,t}) \sqrt{\frac{|Q_{j,t}|}{V_{j,t}}}\;}$$

where $Y_j$ is an impact coefficient, $\sigma_{j,t}$ is volatility, $Q_{j,t}$ is exposure demand, and $V_{j,t}$ is executable liquidity over the relevant horizon. Splitting impact into permanent and temporary components with permanence share $\rho_j$:

$$\Delta \ln P_{j,t} = \theta_{j,t} + \rho_j I_{j,t} + (1-\rho_j)\, I^{\text{temp}}_{j,t} + \eta_{j,t}$$

where $\theta_{j,t}$ is the return the asset would have earned absent wrapper flow, $\rho_j I_{j,t}$ is the share of the period’s impact that persists into subsequent prices, and $I^{\text{temp}}_{j,t}$ is the transient component: the same-period impact that reverts, defined as the current period’s impact $I_{j,t}$ less the reversal of the previous period’s transient, $I^{\text{temp}}_{j,t} = I_{j,t} - I^{\text{temp}}_{j,t-1}$ under one-period decay, so that transient terms telescope to approximately zero over a window and only $\rho_j \sum_t I_{j,t}$ accumulates into the level. Where no decay model is estimated, collapse the two terms and publish $\rho_j I_{j,t}$ alone, with $\rho_j$ flagged as the only fitted parameter; a temporary term whose decay is not specified is not a measurement.

Fitted permanence is case-specific. Import the structure; estimate $Y_j$, $\rho_j$, and $V_{j,t}$ asset by asset.

Volatility Drag on Leveraged Wrappers

For a daily-reset wrapper with leverage $L$ on an underlying with arithmetic drift $\mu$ (the expected simple return per unit time, so that the underlying’s own log growth is $\mu - \sigma^{2}/2$) and volatility $\sigma$, the continuous approximation to compound growth is (Avellaneda & Zhang, 2010 [Avellaneda & Zhang 2010], for the first two terms)

$$\boxed{\;g_L \approx L\mu - \frac{L^2 \sigma^2}{2} - (L-1)r_f - f\;}$$

where $r_f$ is the financing rate on the levered portion and $f$ is the product’s expense ratio. The first two terms are the standard continuous approximation; the last two are the carry the wrapper actually bears and are frequently omitted, which flatters leveraged products in exactly the high-rate environments where they are most costly to hold. The $L = 1$ case reads correctly and should be read carefully: the Itô term $-\sigma^{2}/2$ does not vanish, because it is the ordinary gap between arithmetic and geometric return that any holder of the underlying bears; what vanishes is the leverage-excess drag $-(L^{2} - L)\sigma^{2}/2$, together with the financing term. That excess is the quantity attributable to the wrapper rather than to the asset, and it is what the recycling boundary and WRR of Appendix H: Formal Model of Market Realization, Wrapper Flows, and Price Capture are about; those instruments, like the rebalancing identity, apply to daily-reset products with $L \notin \{0, 1\}$, since an unlevered or non-resetting wrapper has no rebalancing obligation and no excess drag.

The variance penalty grows with the square of leverage. At sufficiently high volatility a leveraged wrapper destroys capital even when the underlying has a positive average return. This is the formal basis for the classification in Chapter 8: The Triad and the Monetary Candidate: a daily-reset leveraged wrapper cannot inherit the underlying asset’s store-of-value status, because its terminal value depends on the path and not merely the endpoints. It is a path-dependent trading instrument that happens to reference a monetary object.

Dealer Hedge Decomposition

Product-level exposure demand is not equal to spot orders. Decompose realized hedging by instrument — physical holdings, futures, total-return swaps, options — and track delta- and gamma-adjusted exposure per counterparty, average derivative maturity, collateral and margin requirements, and evidence of counterparty caps. A migration from swaps toward options is a candidate signal that dealer balance-sheet capacity is binding, with the attendant gamma feedback when dealers are short calls. Treat this as a hypothesis to test per asset, not a law.

Measurement Contract

VerifyFlow Measurement Contract

• Use daily or intraday shares outstanding, NAV, price, AUM, holdings, leverage, and derivative disclosures.

• Chain reverse splits and corporate actions before estimating anything.

• Estimate elasticity over multiple rolling windows, never a single fixed window.

• Use structural-break tests rather than assuming fixed holder behavior.

• Address the simultaneity of elasticity estimation explicitly: instrument $\Delta \ln \mathrm{NAV}$ or publish the OLS value as an upper bound on amplification, and only where the staleness diagnostic of Appendix H: Formal Model of Market Realization, Wrapper Flows, and Price Capture shows wrapper pricing tracks the contemporaneous underlying.

• Report exposure demand separately from realized spot orders.

• Delta-adjust swaps and options.

• Publish top-$N$ counterparty and constituent concentration.

• Separate return-coupled and return-decoupled flows.

• Compare market-exposure growth against native protocol-use growth (WNG).

• Publish confidence intervals and model residuals.

• Report failed hypotheses rather than silently dropping them.

That last clause is not decoration. A flow model that only publishes the specifications that worked is indistinguishable from a narrative, and this thesis has no standing to demand receipts from protocols while exempting its own econometrics.

Reference Stress-Harness Sketch

For each scenario in Chapter 26: Extended Telemetry: enumerate wrappers and their $(L_i, A_i, \varepsilon_i)$; compute $\kappa_i$ and $\mathrm{WRR}_i$; simulate a return path; accumulate $Q^{RC}$ and $Q^{RD}$; map aggregate $Q$ through the impact function given $V$; propagate the resulting return back into the next period’s rebalance and creation terms; and record MPR, WNG, and native-use series alongside price. The output of interest is never the simulated price. It is whether the native series moved at all.

Boundaries and Caveats

• This machinery is evidence about market transmission. It is not evidence that Privacy, Proofs, or Compute will earn monetary premium.

• Parameters fitted in one market (equities, semiconductors) do not transfer. Re-estimate everything.

• Unlevered wrappers are not adversaries by construction. The failure mode is the inability to distinguish accessibility, custody concentration, native use, synthetic leverage, and price-insensitive demand.

• Price is never a protocol control target. The purpose of this appendix is to explain price formation, not to defend a price.

• Market realization is orthogonal to the stack. Nothing here becomes a Layer 7.

Buyer Quality and Price Provenance

The vectors above measure product mechanics. They do not measure buyer quality. The Treasury long end makes the gap precise (Chapter 3: The World Forces New Monetary Primitives): a recurring dollar inflow can absorb less duration as prices fall, because market-value weights shrink, and the residual then clears with whoever is left. The same structure can appear in a monetary wrapper whose creations continue while the holders behind those creations are default-enrolled, unlevered, and duration-unaware—or leveraged, short-horizon, and one mark from a forced sale.

VerifyFlow therefore adds a buyer-quality checklist, not a new elasticity (Chapter 26: Extended Telemetry). For any material source of demand, record persistence of funding, investment horizon, match to an enduring liability, capacity to bear losses without forced liquidation, and whether incremental risk absorption rises or falls after a drawdown. Do not publish a multiplicative “anchor quality” index. The dimensions are the contribution; collapsing them into a scalar would recreate the scoreboard problem this appendix exists to prevent.

Approximate new DV01 absorption by an index receiving inflow $F_t$ is

$$A_t \approx F_t \sum_j w_{j,t}\, D_{j,t}\, 10^{-4}$$

where $w_{j,t}$ is the market-value weight of instrument $j$ and $D_{j,t}$ its modified duration. As $w_{j,t}$ falls with price, $A_t$ can decline even as $F_t$ is unchanged. That identity is why “inflows remain healthy” is not evidence that the residual is shrinking.

The measurement contract of this appendix applies here without modification: publish the classification of each buyer, the fields that support it, and the cases in which the classification failed. A flow model that reports only that demand arrived, and not what kind of demand it was, has not instrumented the plane.