← Research Library

R-20 · 38 min · Paper

Resolve the Law, Not the Catalogue

Published Nov 12, 2026

Abstract

Part II of this series proved that an authorized action can be defined by an equation with no term for the agent, and established four conditions under which a verdict computed from carried inputs equals the verdict the equation defines. Every theorem in that paper, however, evaluates a given authority: A enters the equation as a free variable, supplied by the same adversarial carrier the theorems otherwise disarm. The carrier cannot corrupt the verdict under an authority. Nothing yet prevents it from staying silent about an authority altogether. We show that the central attack of Part II — silence over carried facts — recurs one level up, as silence over applicable law, and that it defeats a relying party that satisfies all four of Part II's conditions. We call the missing function resolution: the map from an action, a context and a time to the complete set of authorities whose verdicts must be satisfied, computed from sources the carrier does not choose. We give resolution a model — applicability claims, recognition edges, supersession, and closure statements, signed assertions that a list of in-force authorities is complete — and four further conditions, C5–C8, each necessary by an attack built from genuine, correctly signed artifacts alone. We prove the sense in which they are sufficient: choice-of-law indifference, the extension of carrier indifference from the facts an agent carries to the law it acknowledges, with completeness that is accountable rather than metaphysical — relative to pinned resolution roots and an append-only record, in the same way Part II's verdicts are relative to pinned trust. Hart answered the uncertainty of primary rules with a secondary rule of recognition. Part II mechanized one half of that rule: whether a presented rule is valid. This paper mechanizes the other half: what the valid rules are. Infrastructure for the first half lets strangers verify law they already know. Only the second lets them coordinate on law they have never met.

R-19 · Paper

Authorize the Act, Not the Agent →

Part II, which this paper extends: it verifies a given authority; this paper resolves which authorities govern an act at all.

R-09 · Design Note

Root Legitimacy for Machine-Executable Institutional Authority →

The root-governance question this paper inherits in stronger form: who may operate resolution roots.

R-18 · Position Paper

What Remains Human →

The human roles the construction gives form to, joined here by a fifth: the Registrar, who signs closure.

P-02 · Proof

The proofs: Resolution →

A commit means every law that applies, as far as the relying party's pinned registrars state it, was checked and allowed it, whatever the agent chose to mention.

Lean 4 · 33 vectors and 34 registrar-log cases · found 2 gaps in SPEC-014 0.1.0

Concept

1. Introduction

1.1 The coordination principle, continued

Part II opened with a historical claim: institutions scale to strangers only after infrastructure lets strangers rely on the same rules without trusting one another. Its examples — written codes, double-entry ledgers, standard measures — share a property the paper used but did not name. Each one made the rules findable before it made them checkable. Hammurabi's stele was erected in public; its force came as much from where it stood as from what it said. A subject who could not locate the rule could not rely on it, however verifiable its text.

Hart's analysis, which Part II adopted, makes the same point precisely [Hart 1961]. The first defect of a régime of primary rules is uncertainty — and Hart is explicit that the uncertainty is about which rules are the rules: “if doubts arise as to what the rules are or as to the precise scope of some given rule, there will be no procedure for settling this doubt.” The remedy, the rule of recognition, does two jobs at once. It supplies a test of pedigree — is this purported rule valid law of this system? — and it supplies an enumeration — what does the law of this system, here, now, consist of? Jurisprudence rarely separates the two, because for people they are served by the same institutions: gazettes, registers, codifications, citators.

For machines they come apart. Part II mechanized the test of pedigree completely: a chain from a sealing key to a pinned root, order-independent resolution, revocation on the key, currency from the relying party's own record. A relying party that has never met an issuer can decide whether a presented authority is genuine and current. What no part of the construction answers is the enumeration. Given an action, a context and a moment — what is the set of authorities whose verdicts must all be satisfied before this change is legitimate?

1.2 Where Part II stopped, exactly

The stopping point is visible in the predecessor's own text, three times.

First, in the equation. V = Eval_A(a, F, t) is celebrated for the term it omits — “it has no subject: the party asking is not an input” — but A itself is a parameter, singular and given. §3.1 lists the carrier's adversarial choices: the action, the facts, “which version of the rules to present,” the certificates and their order, the system to address. Which rules at all is not on the list. The six obligations discipline every choice the carrier makes within an authority. The choice of staying silent about an entire authority is never modeled, because an Act, as defined in §3.4, carries exactly one A.

Second, in the relying party. §3.2 equips ρ with “its own record of which version of each authority is in force” — of each authority it already knows. The definition quietly assumes the hard part: that ρ's list of authorities is the right list. For a single institution enforcing its own policy on its own ledger, the assumption is harmless; the Sovereign wrote the list. The moment the relying party must also honor law it did not author — a sanctions régime, a data-protection act, a sectoral rule that attaches to the transaction and not to the ledger — the list itself becomes the attack surface.

Third, in the open problems. §9.1 concedes that bilateral pinning “does not by itself create the many-to-many recognition that card networks or ICAO's public key directory provide,” and files the residue under root governance [R-09]. But recognition at scale — whose keys to trust — is only half of what a directory does. ICAO's PKD distributes trust anchors; it is the visa régimes and treaty tables, a separate and older infrastructure, that tell the border officer which rules apply to this traveler today. Part II borrowed the passport's verification architecture and stopped before the body of law that tells the border what to check. The paper verified the document. Nothing yet resolves the law.

1.3 The attack, one level up

The deepest result of Part II concerns silence. “Over facts an adversary carries, a verifier that reads silence as falsity lets the carrier decide which exceptions exist.” The remedy was evaluator-level: Kleene's third value and one gate, so that omission yields at most INCOMPLETE and disclosure is the dominant strategy.

Now raise the level. The carrier assembles the Act, and the Act names the authority. A relying party that evaluates the authorities it is handed — or the ones it happens to know — reads absence of an authority as inapplicability of its law. That is the same logical error in the same adversarial position: silence rewarded, one layer up. Access control met the fact-level version as attribute hiding. The law-level version has a older name. It is the oldest compliance strategy in existence: do not ask, so that you cannot be told no.

The attack needs no forgery. Every artifact the carrier presents is genuine, correctly signed and current; every obligation of Part II holds; the verdict under the presented authority is honestly AUTHORIZED. The wrong is complete before verification begins, in the composition of the set. We make this precise in §4 as applicability hiding, and show it defeats a relying party satisfying C1–C4 whenever the applicable set is not fixed by construction.

Part II closed its introduction: “An agent that holds no authority cannot be a confused deputy. At worst it is a confused courier.” True — under the law it acknowledges. A courier that may choose which law exists is not confused. It is forum-shopping.

1.4 Resolve the law, not the catalogue

The remedy must sit where Part II's remedies sit: outside the carrier's reach. We define resolution as a function the relying party evaluates, over infrastructure the carrier does not choose:

R_ρ(a, c, t) → (𝒜, π)  |  CONFLICT  |  INCOMPLETE

a    the action      as in Part II
c    the context     the properties that attach law to an act:
                     place, parties, subject matter, sector
t    the time        the moment of action
𝒜    the applicable set   {(authority id, version, root), …}
π    the provenance  why each member applies, and why the set is complete

The catalogue — a directory a developer browses to pick an authority — is what exists today, and it reproduces the assumption of §3.2: whoever consults it already knows what to look for. Resolution inverts the direction of the question. Not “where is the EU AI Act?” but “what governs this act, here, now — and how do I know the answer is all of it?” The second half of that question, completeness, is the entire difficulty, and §5 shows it admits only one honest reading: completeness relative to pinned trust and an append-only record — accountable completeness — exactly as Part II's verdicts are sound relative to a pinned root, not absolutely.

1.5 Contributions

  • The stopping point, named (§1.2, §3). A is a free variable in Part II's equation, carried by the adversary; the enumeration half of Hart's rule of recognition is unmechanized; applicability hiding is the recurrence of attribute hiding at the level of law.
  • A model of resolution (§3): applicability claims scoped like witness certificates, recognition edges, supersession, closure statements, and three-valued resolution — RESOLVED, CONFLICT, INCOMPLETE — with CONFLICT a first-class outcome routed to people, never silently ordered away.
  • Four further conditions and their necessity (§4). C5 resolution independence, C6 claim authority, C7 currency of the set, C8 closure or silence. For each, an attack from genuine artifacts alone that succeeds when that condition, and only that condition, is dropped.
  • Sufficiency (§5): the four conditions give choice-of-law indifference — a commit implies the full resolved set was satisfied, whatever subset the carrier chose to mention — and the containment result: a lying applicability claimant can add law (contained to wrongful refusal, the safe direction) but cannot hide law: removing law takes a withdrawal, supersession or revocation, and each holds the answer open until the registrar signs a closure that omits it.
  • A construction (§7) mapped member by member onto infrastructure that already ships — the signed catalogue as a per-publisher closure statement, the hash-chained exchange log as the transparency record, chain-of-trust as recognition edges, extends as composition — and the delta a NOMOS-SPEC-014 would have to specify.
  • The honest limits (§6, §9): what resolution surfaces but must not settle — overlapping sovereignty, genuine interpretive ambiguity — and the open problems, beginning with the one this paper inherits squared: who operates resolution roots.

1.6 Relation to the series

Part I [R-07] established authority as a compiled object. Part II established how that object travels with an action and is verified by a stranger. This paper establishes how a stranger knows which objects govern an act at all — the layer that must exist before Part II's machinery has its full meaning outside a single institution's walls. R-09's root-governance question is inherited here in stronger form (§9.1). R-18's human roles gain a fifth: the Registrar, who signs closure. We propose the construction be specified as NOMOS-SPEC-014, and, following the discipline of its predecessors, that it remain Draft until a second, independent resolver agrees on published vectors.

2. Lineage

Resolution is not a new problem. It is an old problem that has never been mechanized, and each of its human-era solutions contributes one element of the construction while lacking another. We take them in turn, as Part II took its lineage: not as decoration, but as a record of which piece each tradition solved.

Conflict of laws solved the function and never wrote it down as one. Private international law is a thousand-year refinement of exactly R(a, c, t): given a transaction touching several sovereigns, which law governs? Story's Commentaries [Story 1834] and Savigny's seat-of-the-relationship doctrine [Savigny 1849] are algorithms in prose — connecting factors (place of the wrong, habitual residence, situs of property, chosen law) mapping a context to a governing régime. The EU eventually codified the algorithm outright: Rome I for contracts [Regulation 593/2008] and Rome II for obligations [Regulation 864/2007] are decision procedures, complete with priority orders and escape clauses. The tradition contributes the shape of the context c — the short list of properties that attach law to an act — and a millennium of case law on its edge cases, including renvoi, the infinite regress that arises when the resolved law resolves back. What it lacks is everything this series supplies: the resolved law is not a sealed object, the resolution is performed by courts after the fact, and completeness is argued by counsel, not proved.

Publication law solved bindingness. The principle that unfindable law does not bind is itself law. The Federal Register Act requires publication before a regulation can bind the public, and the APA voids secret law against a party without actual notice [FRA 1935 §7; 5 U.S.C. §552(a)(1)]. Hammurabi's stele, the gazette, the official journal: every legal order eventually learns that promulgation is constitutive, not decorative. The tradition contributes the normative anchor for C8 — a law that resolution cannot reach is, for the machine, not yet law — and the Registrar role: the official whose signature makes the list the list. What it lacks is machine form: a gazette proves a rule was published, never that the reader's set of rules is complete.

DNS solved delegation at planetary scale — and, later, honest absence. The analogy everyone reaches for is the right one, but the load-bearing part is not the lookup. It is two subtler properties. Delegation: no single operator knows the whole namespace; authority over zones is distributed along signed edges from pinned roots, which is precisely the §9.1 many-to-many structure, and DNSSEC made each edge verifiable offline [RFC 1034; RFC 4033–4035]. And authenticated denial of existence: an NSEC record is a signed proof that a name does not exist in a zone [RFC 4034 §4]. The resolver distinguishes “no such law” from “I could not find it” cryptographically. This is C8 avant la lettre, and to our knowledge no legal-tech system has ever had it: the ability to prove a negative about applicable law, relative to a zone. What DNS lacks is semantics — names map to addresses, not to scoped claims of authority over conduct — and its trust bottoms out in one root, a design this series rejects (C1.1: the relying party pins).

ICAO solved recognition and left applicability to treaty. Part II took the passport's verification architecture. The rest of the border is the part Part II did not take: the Timatic database that airlines query — destination, nationality, date → the applicable entry régime — is a privately operated, non-cryptographic resolution service for a narrow body of law, consulted billions of times a year precisely because carriers (airlines, there too) are liable for transporting passengers the law excludes. The lineage contributes the economic lesson: resolution infrastructure appears when the carrier is made liable for the law it failed to resolve. What it lacks is proof: Timatic answers are data, not signed claims chaining to the sovereigns whose law they summarize.

Certificate Transparency solved accountable completeness. CT does not prevent a rogue CA from issuing a bad certificate; it makes issuance undeniable by forcing it into append-only, publicly auditable logs, so misissuance is detected and attributed [RFC 6962]. This is the honest epistemology for resolution: no system can prove that all law everywhere is captured, but a system can make it impossible for a law to be in force within a pinned régime without appearing in a log the relying party can audit — and impossible for a resolver to have answered differently yesterday without the divergence being provable. The contribution is the entire §5 notion of accountable completeness. What CT lacks, resolution needs: CT logs certificates, which assert identity; a resolution log must record scoped claims of authority, supersession and closure, which assert law.

Citators solved currency. Shepard's Citations has, since 1873, answered “is this authority still good law?” — the C7 question — by indexing every subsequent treatment of a case. The tradition contributes the insight that currency is a graph property: an authority's standing is a function of edges later documents drew to it. Part II's supersession records and revocation lists are the sealed-world version. What citators lack is the forward direction: they tell you what happened to law you already hold; they never enumerate what governs an act you are about to perform.

Six traditions, six fragments: the context vocabulary from conflict of laws, bindingness-by-publication from the gazette, delegation and provable absence from DNS, carrier liability from the border, accountable completeness from CT, currency-as-graph from the citators. No tradition has all six, which is why no infrastructure exists today that a machine can ask, with proof: what governs this act, here, now — and is that all? The remainder of this paper assembles the fragments.

3. The resolution model

This section fixes the objects, the parties and the property we want, in the notation of Part II. Truth values remain Kleene's: 1, 0, ½.

3.1 The combined verdict, and the premise it hides

Part II's equation evaluates one authority. A consequential act in the open world answers to several at once: the ledger-owner's policy, the sanctions régime, the data-protection act, the sectoral rule. Write the set of authorities genuinely governing action a in context c at time t as 𝒜(a, c, t), and the combined verdict as:

V* = Comb { Eval_Ai(a, F, t) : Ai ∈ 𝒜(a, c, t) }

where Comb is the strict combination, in this severity order: DENIED if any member denies; otherwise INCOMPLETE if any member is INCOMPLETE — a member that cannot decide holds the whole answer open, because an escalation raised on a partial enumeration would invite a person to approve the wrong question, papering over the deny the missing member might have returned (omission safety, lifted to the combination itself); otherwise ESCALATED carrying the union of the escalations, each preserved by name (the lesson of Part II's gate clause (ii), lifted across authorities — safety must preserve who approves, not only whether); AUTHORIZED only if every member authorizes. Comb is associative and commutative, so V* does not depend on the order in which authorities are consulted — the cross-authority analogue of Part II's order-independence. (The reference implementation and NOMOS-SPEC-014 §4 state this ordering normatively.)

Every guarantee of Part II attaches to the Eval_Ai terms. None attaches to the set former. A relying party that computes the right-hand side over the wrong 𝒜 computes the wrong V* with every obligation C1–C4 intact. The premise hidden in §3.2 of Part II — ρ knows its list — is the premise this model discharges.

3.2 Parties

  • Publisher. An institution that authors and seals authorities — Part II's Issuer, unchanged.
  • Registrar. A party certified to make applicability claims and closure statements over a scope: the machine form of the official who keeps the gazette. A sovereign's registrar claims scope over a territory and subject matter; a private registrar (a trade network, a standards body, a platform) claims scope over its members' dealings. Registrars hold claim keys whose certificates name their scope, exactly as witness certificates name facts in Part II.
  • Resolver. Infrastructure that evaluates R from registrar claims. A resolver holds no authority of its own; like Part II's carrier, it is honest-or-adversarial plumbing, and §4 is designed so that a lying resolver is detectable rather than trusted.
  • Relying party ρ. As in Part II, extended: besides its root for key recognition, ρ pins a set of resolution roots — the registrars whose law it undertakes to honor — and keeps the head of each registrar's log in its own record.
  • Carrier. The agent. It appears in this section only to be excluded: resolution is a function the relying party evaluates. The carrier may also resolve, for its own planning, and §7 gives it reason to; but nothing the carrier resolves enters ρ's computation of 𝒜.

3.3 Claims, edges and closure

A registrar's log contains four kinds of signed, append-only entries.

  • Applicability claim. applies(A, s, w): authority A governs scope s during window w. A scope s is a predicate over (a, c): action types, territories, party properties, subject matters — the connecting factors of conflict of laws, as a machine-evaluable predicate in the same restricted condition language as Part II's rules (comparisons of a field with a value; the decidability trade of its §9.7 is accepted here for the same reasons).
  • Supersession edge. supersedes(A′, A, from t): the citator edge, sealed.
  • Recognition edge. recognizes(ρ_reg, r, s): this registrar defers scope s to the registrar rooted at r — DNS delegation, carrying law instead of names. Recognition edges compose 𝒜 across régimes: a trade-network registrar recognizes each member state's registrar over its own territory.
  • Closure statement. closed(s, L, t): as of t, the complete list of this registrar's in-force authorities over scope s is L. The NSEC record of law. Closure is what converts a directory into a resolution infrastructure: without it, every answer is “here is what I found,” and absence of evidence is evidence of nothing.

Each entry is hash-chained to its predecessor; the registrar signs the head. A relying party, or anyone, verifies the chain offline and detects rewriting by comparing heads — the CT discipline.

3.4 Resolution and its three values

Given (a, c, t), the relying party's resolver walks its pinned resolution roots, follows recognition edges within scope, collects applicability claims whose scope predicate is 1 on (a, c), discards superseded and revoked members, and demands closure:

  • RESOLVED(𝒜, π) — every pinned registrar reachable over (a, c) has a current closure statement covering the queried scope and agreeing with its chain; 𝒜 is the union of in-force claims; π contains, for each member, its claim and chain, and for the set, the closure statements and log heads that make it complete relative to the pinned roots.
  • CONFLICT(π) — two claims cover (a, c) with authorities whose combined verdict cannot be formed because the registrars assert incompatible precedence (each claims the other's scope, or closure statements disagree). Conflict is returned, never resolved by the machine: §6. This is Part II's escalation-preservation principle applied to sovereignty — the system must surface which human question exists, not pick a winner.
  • INCOMPLETE(π) — a scope predicate over (a, c) evaluates to ½ for want of a context fact; or a pinned registrar's log is unreachable or its closure stale beyond the freshness bound ρ configured; or a current closure disagrees with its registrar's chain; or the copy of a log ρ reads is older than ρ's bound. Exactly as in Part II, the third value names what is missing, and for a consequential act it is never read as permission.

Two remarks fix intuition. First, the direction of every arrow: the carrier supplies a and (through witnessed facts) parts of c, but the claims, the closure and the heads come from logs ρ pinned — the carrier cannot add to 𝒜, remove from it, or starve it undetectably. Second, the status of completeness: RESOLVED does not assert that no law exists anywhere on Earth touching (a, c). It asserts that within the régimes ρ undertook to honor, the enumeration is complete and provably current — and that any narrower answer the resolver might have given is detectable against the logs. §5 names this accountable completeness; §6 is honest about the remainder.

4. Four further conditions, each necessary

Part II's method: every obligation names the simplification it forbids, and the necessity argument is an attack built from genuine statements alone — no forged signature anywhere. We keep the method. Each attack below is executable the moment a reference resolver exists, and §9 commits to publishing them as vectors the way Part II's twelve ablations were published.

C5 — Resolution independence. The applicable set is computed by the relying party, over logs it pinned. Nothing the carrier submits adds to, subtracts from, or reorders 𝒜.

Forbids: trusting the Act's own account of which law governs — including the seemingly innocent design in which the Act lists “the authorities checked” and the relying party verifies each listed member.

Attack (applicability hiding). Context: a payment relying party honoring its own policy P and, nominally, sanctions régime S. The carrier assembles an Act under P alone: genuine authority, true witnessed facts, valid chain; Eval_P returns AUTHORIZED, honestly. S, which would have returned DENIED on the same facts, is simply never mentioned. Every Part II obligation holds — each was scoped to the authorities presented. A relying party whose 𝒜 comes from the Act commits a sanctioned payment on entirely genuine artifacts. The wrong was complete at set-formation. Under C5, ρ resolves S into 𝒜 from its own pinned registrar regardless of the Act's silence, and Comb returns DENIED.

C6 — Claim authority. An applicability claim binds only within the claimant's certified scope. A claim outside scope is not a weaker claim; it is no claim.

Forbids: first-to-publish semantics — any directory in which listing an authority over a scope is the act that makes it apply there.

Attack (jurisdiction squatting). A genuine registrar key, correctly certified for scope s₁ (say, a trade association's own membership rules), appends applies(A_strict, s₂, …) for a scope it was never certified over — a competitor's sector, a foreign territory. Every signature verifies. A resolver that checks signatures but not scope imports A_strict into strangers' transactions: a denial-of-service on commerce built from genuine keys. The inverted case, a permissive authority squatted over a strict scope to launder approvals, cannot occur: under the strict combination an added authority can only add refusals, so C6 protects strangers' commerce from wrongful refusal and foreign law, not the soundness of a commit. Under C6 the claim is void where it exceeds the certificate, exactly as a witness statement outside its certified facts is TESTIMONY_INVALID in Part II. The claim-key certificate is to law what the witness certificate is to facts: who may say what, one level up.

C7 — Currency of the set. Membership in 𝒜 is evaluated at t against supersession, revocation and in-force windows, from the registrar's log — not from any party's cache, and not from the carrier's presented version.

Forbids: resolving against a snapshot; treating a once-resolved set as a property of the relationship rather than of the moment.

Attack (the zombie authority). A₁ governed scope s until superseded by stricter A₂ on date d. The carrier — or a resolver serving week-old state — presents, and satisfies, A₁ after d. Every artifact is genuine; A₁'s seal verifies forever (Part II §9 already noted that deprecated-but-unrevoked versions stay cryptographically valid — necessarily, for verifying history). What makes the commit wrongful is not the authority's validity but the set's staleness: at t, 𝒜 contains A₂, not A₁. C7 is Part II's C1.2 (which version) lifted from the authority the carrier presents to the enumeration the relying party computes; the carrier's freedom to choose versions was closed there, the resolver's is closed here. Ignoring currency altogether is not this attack: it only adds law, the safe direction. The attack is membership judged at a stale instant.

C8 — Closure or silence. An authority's absence from 𝒜 is load-bearing only under a current closure statement covering the queried scope. Absent closure, resolution returns INCOMPLETE, and for a consequential act INCOMPLETE is never read as permission. A current closure must also agree with its registrar's own chain: it names no authority the chain no longer holds in force, and every in-force claim on the context is named by one. And a resolver reading a copy of a log, not the log itself, must bound the copy's age.

Forbids: the open-world allow — “we found no applicable law, therefore none applies.” This is the resolution-layer image of the two-valued evaluator Part II demolished: there, reading a missing fact as false let the carrier choose which exceptions exist; here, reading a missing claim as inapplicability lets whoever controls visibility — a lazy resolver, a partitioned network, a censored log — choose which laws exist.

Attack (the starved resolver). No one lies. The carrier submits a genuine Act; the relying party dutifully resolves; but the sanctions registrar's log is unreachable — an outage, or an adversary who can induce one, which is a strictly weaker capability than forging anything. A resolver without C8 returns the members it could reach, 𝒜 = {P}, and the commit proceeds as in the C5 attack — achieved this time without touching the carrier at all. Under C8 the reachable members do not suffice: the pinned registrar's closure is stale, resolution is INCOMPLETE naming the starved scope, and the act waits. Omission safety, Part II's deepest obligation, reappears as an availability obligation: silence of a log, like silence of a witness, must cost the proposer the verdict, never buy it.

Attack (withdrawal under a closure). No one forges anything. The sanctions registrar withdraws its claim, a genuine entry or a compromised key's, while its last closure still names the sanctions authority and is inside its bound. A resolver that reads a closure's age but never its list drops the authority silently: 𝒜 = {P}. Under C8's agreement clause the closure contradicts the chain, resolution is INCOMPLETE naming the authority, and law leaves the set only when the registrar signs a closure that omits it.

Attack (the stale view). The relying party reads a mirrored copy of the sanctions log, refreshed weeks ago. Its closure is still inside its own bound, so every check above passes on the copy, while the live log has superseded the authority it names. The relying party's bound on the copy's age is the only check that sees it: past the bound, INCOMPLETE.

Remark on independence. The four attacks are pairwise separating in the ablation sense: each succeeds against a resolver satisfying the other three. Hiding (C5) defeats set-formation with all logs current and honest; squatting (C6) defeats it with resolution independent and closed, and only ever as wrongful refusal; the zombie (C7) with scopes honored and a closure in bound, membership read at a stale instant; starvation (C8) with everything honest but one log dark. And all four leave every Part II obligation intact — which is the paper's claim that resolution is a genuinely new layer, not a corollary: C1–C4 discipline the inputs to Eval_A; C5–C8 discipline the subscript.

5. Sufficiency: choice-of-law indifference

5.1 The property

Part II's target was carrier indifference: whatever the carrier does, a commit implies that legitimate, current authority applied to the true facts permits the action, or that the required people approved exactly it. The extended property quantifies over one more adversarial freedom:

Choice-of-law indifference. Whatever the carrier presents, mentions or withholds, a commit at ρ implies V* = AUTHORIZED over the full resolved set 𝒜(a, c, t) — the set ρ's pinned registrars make complete and current — with every escalation any member raised answered by name.

The claim: C1–C4 plus C5–C8 are jointly sufficient. The argument has the shape of Part II's §5 and composes with it rather than repeating it. By C5, 𝒜 is a function of (a, c, t) and ρ's pins alone — the carrier's presentation is not an argument of R, so no choice of what to mention perturbs the set. By C6, every member of 𝒜 entered through a claim within certified scope, so the set contains no squatted law; by C7, no superseded law; by C8, the set former either certifies completeness under closure or refuses the verdict, so the set lacks no in-force law within the pinned régimes. Carrier indifference (Part II, applied per member) then guarantees each Eval_Ai term; associativity and escalation-preservation of Comb guarantee the combination is order-free and loses no approval requirement. Two corollaries carry over with their force multiplied:

  • Disclosure remains dominant, and now extends to law. An honest carrier gains nothing by omitting an authority — ρ resolves it regardless — and loses nothing by naming every authority it believes applies: at worst its list is corrected by π. The arms race Part II ended for facts (“agents will hide what they are”) does not reopen for law: there is nothing to be gained by not mentioning the sanctions régime, because the régime's applicability never depended on being mentioned.
  • Reproducibility extends to the set. Part II's Theorem 10 let a third party recompute the verdict from the record. Under C5–C8 the record additionally carries π — claims, closure statements, log heads — so an auditor recomputes not only was this permitted under A but was A the whole of the applicable law as ρ's pins then stood. The question “did they even check sanctions?” becomes a hash comparison.

5.2 Accountable completeness

We must be exact about what “complete” means, because an absolute reading is indefensible and a lax one is useless. RESOLVED does not assert that no rule anywhere on Earth touches (a, c). It asserts: relative to the registrars ρ pinned, the enumeration is complete (closure), current (C7), within authority (C6), and independent of the proposer (C5) — and every one of those four properties is checkable by a stranger from the record. The epistemic position is precisely Part II's: a verdict there was never “true” absolutely, it was sound relative to a pinned root; soundness became valuable because divergence from it was detectable by anyone. Completeness here is valuable on the same terms. Call a failure of completeness within the pins — an in-force authority a registrar closed over but a resolution omitted — a resolution fault. Then: every resolution fault is attributable from π against the logs, to the resolver (served stale state: heads prove it), the registrar (closure contradicted by its own chain: the statement proves it), or ρ (pins not honored: its record proves it). What remains genuinely outside the machinery is law outside every pinned régime — and that residue is not a silent failure but a visible, enumerated choice: ρ's pin list is inspectable, and electing not to pin a régime is the Sovereign's knowing act, the exact analogue of Part II's one irreducible Sovereign choice (record versus in-force statement). The machine cannot make ignorance of the law impossible. It makes ignorance of the law legible — a named, signed, auditable configuration rather than a shrug.

5.3 What one lying claimant can do

Part II bounded each key's compromise; the same containment discipline applies to the new parties, and it reveals a load-bearing asymmetry.

  • A compromised claim key can add law, not subtract it. A false applies within certified scope injects a spurious authority into 𝒜; Comb is strict, so the worst outcome is wrongful DENIED or spurious ESCALATED — commerce impeded, never unauthorized change committed. This is the safe direction, and it is the direction forgery points by construction.
  • Hiding law requires corrupting closure. To make 𝒜 silently smaller, an adversary must produce a closure statement that omits an in-force authority — which, read against the registrar's own append-only chain, shows exactly what was dropped and when, is signed with the registrar's key, and sits in an append-only log that ρ and any auditor hold heads for. The lie is possible and permanently self-incriminating: CT's bargain. Detection, not prevention — but detection attached to a signature attached to an institution. Law a registrar never logged is not covered: there is nothing in the chain to read it against, and that residue belongs to §6.
  • A lying resolver is a cache, not an oracle. Under C8 a resolver cannot starve quietly (staleness surfaces as INCOMPLETE), and under §5.2 it cannot answer narrowly without the divergence being provable against the heads. ρ that wants no resolver in its trust base can walk the logs itself; the resolver is an optimization, exactly as Part II's verification needed no call to the issuer.
  • The Registrar is the new Sovereign-grade trust. A registrar's key compromise is the worst case: within its scope, until revocation, both additions and (via closure) omissions are possible. The containment is scope itself (C6 — never beyond the certificate), revocation on the key (Part II's machinery, reused), and the log (every abuse is in the chain forever). Who deserves this trust is not a cryptographic question; it is §9.1.

6. What resolution must not decide

A resolution layer acquires authority of a dangerous kind: the power to say what law exists. The construction is deliberately shaped so that three questions pass through it undecided, and we state them as design obligations rather than regrets — each is a place where deciding would be worse than surfacing.

Overlapping sovereignty. Two registrars, each within certified scope, each closed and current, claim (a, c) under authorities whose combined verdict the machine could only form by ranking sovereigns. Conflict of laws spent centuries here precisely because there is no neutral algorithm: lex loci, closest connection, ordre public are arguments, adopted treaty by treaty. The resolver returns CONFLICT with both chains in π, and the act escalates to people with the conflict named — which registrars, which claims, which precedence assertions disagree. The temptation resisted is a tie-breaker: any machine ordering of sovereigns (first-pinned, alphabetical, largest) would be a silent treaty nobody signed. Part II's gate taught that safety must preserve which escalation applies; lifted to this layer, safety must preserve which sovereignty question exists. What registrars can do is dissolve conflicts in advance, by recognition edges and scope carve-outs — treaties, in machine form — and the log records exactly which conflicts have been so dissolved and which remain live. A CONFLICT rate over a scope is thus a measurable property of the world's legal interoperability — for the first time, an instrumented one.

Interpretation. Resolution answers which authorities govern, never what their rules mean. The scope predicate language is restricted (comparisons over declared context fields) for Part II's §9.7 reasons: decidable, cheap, reproducible. The cost is honesty about borderline characterization — is this instrument a security? is this processing profiling? — which no predicate settles. The construction's answer is the same third value one level down: a context fact the predicate needs but no witness can state is ½, the scope evaluates to ½, and resolution is INCOMPLETE naming the characterization question. The machine does not guess what kind of thing the act is; it names the fact a person or a certified witness must settle. Characterization — which human decides such facts, under which registrar's vocabulary — is an open problem (§9).

Legitimacy. A registrar's certificate makes its claims checkable; nothing makes them just. A sovereign can close a scope over oppressive law, and resolution will enumerate it faithfully. We regard this as the correct division: the infrastructure's contribution to legitimacy is not judgment but exposure — every claim attributable, every change logged, every relying party's pin list an inspectable statement of whose law it honors. Publication law's lesson (§2) ran forward: law must be findable to bind. It also runs backward: infrastructure that makes law perfectly findable makes the choice to honor it perfectly visible. The machine holds the mirror; it must not hold the gavel.

7. The construction, and how much of it already ships

The model of §3 was not designed on blank paper. Most of its objects exist in production in the NOMOS reference platform, built for narrower purposes and acquiring, under this paper's reading, their general role. We map each member, because the distance from here to a reference resolver is the paper's practical claim.

Model object (§3)Shipping todayThe SPEC-014 delta
Registrar logThe hash-chained, Ed25519-signed exchange log at /.well-known/nomos-exchange-log, offline-verifiable from a 64-zero genesis to a signed headEntry kinds for applies, recognizes, closed; today's entries record listing and withdrawal only
Closure statementThe signed catalogue at /.well-known/nomos-authorities — already a dated, signed, complete enumeration of one publisher's listed authoritiesScope-qualified closure, signed per scope rather than per catalogue; a freshness bound; agreement with the registrar's own chain
Applicability claimListing metadata: jurisdiction and topic facets on Exchange listingsPromotion from facet to signed, scoped claim — a certificate-bound assertion, not a tag; the scope-predicate language
Recognition edgeSPEC-007 chain-of-trust: scoped, expiring, revocable key certificates, order-independent resolution, revocation on the kidReuse as-is between registrar keys; semantics “defers scope s” added to the certificate's scope field
SupersessionListing versions: a new version records what it replaces; catalogue and search already serve only the newest ACTIVEA sealed supersedes log entry, so currency is provable from the chain rather than queried from the database
Currency of membersSPEC-006 revocation lists at /.well-known/nomos-revocations; max_age on query resultsUnchanged in kind; closure staleness bounds added, and a bound on the age of a log copy
CombThe strict cross-rule combination inside one authority (deny wins, escalations preserved by name — the platform's verdict gate)The same discipline across authorities; vectors for escalation-union
π in the recordQuery transcripts already seal the authority, version and audit hash of each decisionThe resolved-set head hashes added, so a transcript proves which enumeration the verdict was computed over
Resolverauthority-search + the catalogue: today a discovery aid for humans and agentsThe resolution query (a, c, t) with three-valued answers and π; the reference implementation and its vectors

Three observations about this table, which is the paper's quiet argument.

The hard cryptographic objects all exist. Append-only logs with signed heads, scoped certificate chains with revocation, sealed supersession, offline verification of all of it by strangers — built and in production for Part II's purposes. What SPEC-014 adds is almost entirely semantics: new entry kinds in an existing log discipline, a predicate language already restricted the way Part II's rule language is, and a query. This is the same relationship Part II bore to Part I: no new primitive, a new layer of meaning over proven ones.

The Act binds to the enumeration. One field completes the loop: an Act (or a transcript) carries the head hash of each registrar log the resolution consulted. Then the record of a commit proves not only the verdict under each authority (Part II, Theorem 10) but the enumeration itself as of t — an auditor replays R against the logs at those heads and gets, deterministically, the same 𝒜. Forum shopping does not merely fail; it becomes archaeologically visible, because the heads a relying party resolved against are in the sealed record forever.

The carrier's resolver and the relying party's resolver are the same artifact. C5 forbids ρ to trust the carrier's resolution; nothing forbids the carrier to run one. An honest agent resolves before acting — to assemble witnesses for the right authorities, to request the right approvals — and, because resolution is deterministic over the same heads, an honest carrier's prediction of 𝒜 equals ρ's computation of it. The economics of Timatic (§2) then arrive on their own: the carrier that resolves correctly sails through; the one that does not pays in INCOMPLETE round-trips. Disclosure was the dominant strategy for facts; diligence becomes the dominant strategy for law — not because anyone polices agents, but because the verdict never depended on their negligence.

8. What changes

Part II closed with five consequences of theorems it called deliberately narrow. The same discipline, one layer up.

Ignorance of the law stops being a human excuse and becomes a system state. Ignorantia juris non excusat has always been a legal fiction maintained because the alternative — litigating what each actor knew — is unworkable. Under C8 the fiction retires: for a machine actor, “did not know the law” is exactly INCOMPLETE, a named, logged, recoverable state that blocks the act instead of excusing it. The doctrine survives for people. For agents it is replaced by something better: ignorance that cannot act.

Promulgation becomes deployment. Today a regulator publishes text and waits years while the governed build compliance by hand, each firm independently discovering what applies to it. A registrar appending applies and closed entries changes what every pinned relying party resolves at the next query. The gap between law-in-books and law-in-force — the oldest gap in legal sociology — becomes a propagation delay, measured in cache freshness bounds. And because supersession is resolved at t, the transition date stops being a compliance project and becomes a log entry.

Forum shopping becomes a property of the record, not of the opportunity. The carrier never could corrupt a verdict (Part II); now it cannot curate the law, and — §7's binding of heads into the record — a commit permanently proves which enumeration it answered to. The regulatory arbitrage that remains is the legitimate kind, chosen by relying parties in their inspectable pin lists: jurisdiction competition moves from obscurity engineering to published terms, which is where markets can price it.

The applicable set becomes an asked question, so its answer becomes a market. No firm today can say, with proof, how many bodies of law its operations answer to; the question is unaskable, so the answer is unsellable. R makes it a query with a verifiable result. Everything downstream of that — the compliance audit, the market-entry analysis, the “what changes for us if this bill passes” memo — restructures around a primitive that did not previously exist: the diff of a resolved set, over time, over geography, over a proposed amendment replayed against yesterday's transactions.

Hart's architecture completes, and the thesis extends. Part II mechanized adjudication-grade verification and change-grade currency for presented law; this paper mechanizes recognition in its enumerative half. The three secondary rules now each have a machine form — which is not a claim that law is now software, but the converse: that software acting consequentially has finally acquired the minimum institutional structure law discovered it needed twenty-five centuries ago. The historical claim of §1.1 extends accordingly, and remains falsifiable: institutions will scale consequential agent decisions across jurisdictional boundaries only once applicable law is resolvable by machine, with accountable completeness, from infrastructure the proposer cannot influence. If cross-border agent commerce scales stably on hand-maintained lists of law, the thesis fails. If every attempt founders on exactly the four attacks of §4 — hiding, squatting, staleness, starvation — it stands.

9. Limitations and open problems

As in Part II, each assumption marks a problem the construction does not solve. We state them as the open problems of the discipline, in rough order of consequence.

9.1 Who may be a Registrar. Part II's §9.1 asked who should operate roots and deferred to R-09. This paper inherits the question squared: a resolution root does not merely certify keys, it certifies what law exists over a scope. For public law the natural registrar is the sovereign's own gazette office — publication is already its constitutional function, and closure is already its implicit claim — but sovereigns move last. The likely bootstrap is private: networks whose members pin a shared registrar over their dealings (the trade network, the exchange, the platform), for whom §2's carrier-liability economics already bind. Whether private closure can legitimately hard-launch what public law must eventually ratify is an institutional-design question we leave open, flagging one asymmetry that helps: a registrar's claims bind only parties that pin it. Pinning is adoption, not conquest.

9.2 Characterization. Scope predicates read context facts; someone must state them. Which witness vocabularies describe an act's legal character, who certifies those witnesses, and what happens when registrars' vocabularies disagree about the same transaction, is open — it is conflict of laws' characterization problem, now needing a schema rather than a treatise.

9.3 Private law. Contracts are authorities two parties sealed for themselves. Resolution over public régimes is log-walking; resolution over the private layer — which of the ten thousand contracts this organization signed touches this act? — is the same model with registrar = the parties, but the closure statement (“these are all our agreements touching s”) is an assertion most organizations today could not truthfully sign. The gap between the model and corporate reality is itself informative: it prices the records debt.

9.4 Query privacy. A resolution query reveals intention — (a, c, t) is a plan, told to whoever serves the logs. Part II's §9.3 trade-offs recur with sharper teeth, since the querent here is often deciding whether to act at all. Mirrored logs and private information retrieval are the obvious directions; the right point on reproducibility-versus-confidentiality is open.

9.5 Freshness economics. C7 and C8 convert law's currency into cache discipline. Bounds tight enough for sanctions are expensive for parish bylaws; whether freshness classes should be a property of the scope, the registrar or the relying party's risk appetite is a protocol-economics question with no principled answer yet.

9.6 Independence of evidence. Every artifact named in §7 and every attack in §4 comes from this series' own ecosystem. The §4 constructions must become published vectors; a reference resolver must ship with them; and the promotion condition is unchanged from Part II's: a second resolver, independently written against SPEC-014 cold, agreeing on the vectors. Until then the specification is Draft and the claims of §5 are claims about a design. One step is taken: the reference resolver is mechanized in Lean 4 (papers/resolution/lean/Resolution.lean in the specification repository, core library only, standard axioms), step by step for one query. Writing it found two gaps in the first draft of SPEC-014, both closed in 0.2.0: a closure's age was read but never its list, and nothing told a stale copy of a log from the live one. It proves the combination order-free, sufficiency over the registrars reached, and that added law is never less safe; the walk over recognition edges, log heads and the view-age bound are tested, not proved.

10. Conclusion

Part II ended where its equation ends: a verdict, computed where the change lands, indifferent to its carrier. We began by locating the variable that equation never bound. A is chosen; the theorems hold whichever A is chosen; and in deployment the chooser is the adversary. The oldest compliance strategy — do not ask — survived the strongest verification architecture yet built, because verification answers only the law it is shown.

The remedy is of the same species as Part II's: move the choice out of the carrier's hands, into infrastructure that is pinned, scoped, current, closed and append-only. Four conditions — independence, claim authority, currency, closure — each necessary by an attack built from genuine artifacts, jointly sufficient for choice-of-law indifference: a commit implies the whole of the resolved law permitted it, whatever the carrier mentioned. Completeness is accountable, not absolute, and the residue — law outside every pinned régime, sovereignty conflicts, interpretation, justice itself — is surfaced to people by name rather than decided by machine.

Hart's community outgrew its primary rules through three secondary ones. The rule of adjudication acquired machine form when verdicts became reproducible by strangers; the rule of change when supersession and replay made amendment a diff; the rule of recognition, until now, had only its pedigree half mechanized. This paper supplies the other half: not whether a presented rule is law, but what the law is, here, now, provably all of it that the parties undertook to honor. The agent was removed from the verdict in Part II. It is removed from the statute book here. What remains in its hands is what was always meant to remain: the proposal.

The attack constructions of §4, the resolution query semantics, and the SPEC-014 draft objects are intended for publication in the nomos-spec repository under CC BY 4.0, alongside a reference resolver and its vectors. We invite the same three things Part II invited: independent implementations, attempts to break the obligations, and corrections.

Cite this

This is a field in formation; this page will be revised. Cite the version date below, not the day you happen to be reading this.

Suggested citation

SafeHaven (2026). Resolve the Law, Not the Catalogue. Computable Authority Research Library, version of 2026-11-12. https://www.computableauthority.com/research/resolve-the-law-not-the-catalogue

BibTeX

@misc{computableauthority-resolve-the-law-not-the-catalogue,
  author       = {SafeHaven},
  title        = {Resolve the Law, Not the Catalogue},
  howpublished = {Computable Authority Research Library},
  year         = {2026},
  note         = {Version of 2026-11-12},
  url          = {https://www.computableauthority.com/research/resolve-the-law-not-the-catalogue},
}

Full citation guidance →