Programmable Institutions

Abstract

An institutional action can outlast the authority, evidence, or resources on which it began. A filing may wait for judgment while a delegation expires. An authorized payment may leave too little money to complete the promised service. We ask how a program can act under these changing conditions while the institution retains control of its record. We construct a state-change rule that checks current authority, the facts used in evaluation, required human answers, and the actual effect together. Under explicit assumptions, every observable change has an authorized origin and a retained evidence record, even after reversal. For finite workflows, we also characterize all actions that preserve safety and guaranteed completion within a given number of decisions. The construction accounts for shared resource limits, affected rights, and facts the program cannot yet observe. Its guarantees depend on complete environmental contracts, competent authority sources, and faithful rules. They do not establish those institutional premises.

Author note. The author has a commercial interest in systems of the kind this paper describes.

1. Institutional action over time

A company register records officers and shares. A licensing body records permissions. A trustee records beneficial interests. A payment administrator records obligations and discharges. People act on these records because an accepted institution stands behind them.

Changing such a record often requires several acts by different people. A program gathers evidence, submits a request, waits for an answer, and then seeks the change. During that interval, the record can change. An authority can expire. An answer can concern an earlier request. The program must establish which facts and permissions still support the proposed action when the institution accepts it.

We call that acceptance event a commit. It changes the institution’s authoritative record. The institution controls this event, even when a delegate’s program prepares and submits the request. The first question is whether each commit can preserve this control and leave enough evidence to reconstruct the act.

A sequence of individually permitted acts presents a further problem. Several delegates can exhaust one shared allowance. A valid first purchase can leave insufficient resources to complete an outstanding obligation. Delayed observations can conceal whether a service occurred or an authority ended. We therefore also ask which next actions preserve a lawful, funded route to the stated outcome, given the available evidence.

The construction begins with one filing and the exact moment its authority matters. It then treats a workflow as a sequence of such acts. The local result attributes every observable change to current authority, an evaluated rule, and retained evidence. The finite continuation results characterize the choices that can still guarantee the specified outcome. Their premises include the institution’s authority designations and a complete account of the possible external responses.

These questions connect established methods. Complete mediation requires an authority check for each protected act (Saltzer and Schroeder 1975). Optimistic concurrency control compares the state used in a decision with the state being changed (Kung and Robinson 1981). Workflow analysis studies completion and deadlock (van der Aalst 1998). Here the decision must also retain the exact human judgments, shared resources, and current source conditions on which institutional authority depends. Section 9 gives the detailed comparison with these traditions.

2. A filing that waits

Consider a fictional company register. The example states no rule of any actual jurisdiction.

The register contains one company record:

  • company: Cedar Works Ltd

  • registered office: 8 Reed Street

  • company secretary: Mira

  • governing rule: a registered-office change requires a board resolution and a filing by an authorized secretary

The board gives Mira a signed delegation with a stated scope. We call this record a capability. It permits one action, change of registered office, on one object, Cedar Works Ltd, until 17:00 on 30 September. The delegation does not permit a share issue, an officer appointment, or a change to another company.

Mira asks a program to change the address to 12 Kestrel Road. The program reads the company record, verifies the board resolution, checks the delegation, evaluates the filing rule, and proposes a mutation. The important moment is not the proposal. It is commit, when the authoritative record changes. The record belongs to the registrar, which is its sole writer under the applicable law and runs the commit boundary. Mira’s program submits the filing. It does not commit the registrar’s record.

Three runs show why these checks belong to the same accepted act. We call authority live when it remains valid at the time of use.

Run A: permitted commit. The board resolution is present. Mira’s delegation is authentic, in scope, and live at commit. The filing rule returns permit. The mutation changes only the registered-office field. The system commits the new address and appends an immutable evidence record, called a receipt. The receipt identifies the prior state, the new state, Mira, the delegation chain, the rule version, the resolution, and the commit time.

Run B: expired authority. The program performs the same checks at 16:59. A queue delay moves commit to 17:01. If authority is checked only when work begins, the program changes the record after Mira’s authority has ended. A live-at-commit check refuses the mutation. The program may prepare the filing before expiry, but preparation is not authoritative change.

Run C: human judgment. Suppose the rule also requires “satisfactory evidence that the new address is suitable for official service.” The submitted document does not settle that question under the encoded rule. The evaluator records an unanswered question, called a discretion hole. Its type specifies the missing evidence, allowed answers, and registrar role. The request waits. A timeout cannot create permission. An authorized registrar authenticates an answer to the exact pending request revision. The boundary checks the registrar’s live authority for that act. The evaluator checks whether that answer may still be used. A later permit records the exact answer on which it relies. A changed filing, rule, or question context requires a fresh request revision. Closing an obsolete question supplies no answer.

This example distinguishes four objects that ordinary workflow descriptions often merge.

First, the board resolution is evidence about an institutional decision. Second, Mira’s capability identifies who may submit the action. Third, the filing rule decides whether the submitted action satisfies encoded conditions. Fourth, the registrar’s judgment resolves a question the rule deliberately leaves open. None substitutes for another. A board resolution does not prove that Mira’s delegation is live. A valid delegation does not make the filing lawful. A rule cannot invent the registrar’s judgment. A registrar cannot silently expand the delegation to a share issue.

The example is small because the invariant is local. Larger workflows are sequences of the same boundary. Formation, licensing, ownership changes, tax filings, and payments add more rules and external effects. They do not remove the need to show who had authority at each commit.

The commit changes the institution’s local record. Governing law and the institution’s designation determine the legal effect of that record. A replayable receipt proves what the local system recorded under its stated rules. It does not prove settlement finality, beneficiary credit, or discharge in an external system.

3. Requests, authority, and admissible changes

The filing separates three kinds of record. The company record states the registered address. Authority records state who may act. A request history records the question, its revisions, and the answer. Changing the address requires these records to agree at commit.

We first specify their contents, then the events that can change them. An execution trace lists accepted events in order. A trace prefix contains the events accepted so far.

Let P be a set of principals. A principal is an identity that the model treats as able to hold authority. It may denote a natural person, a legal person, an office, or a delegated service identity. Let O be a set of institutional objects. For each o\in O, let \mathsf{judgments}(o)\in O be the stable authority object for discretion holes concerning o. Let A be a set of action names. Let \mathsf{Field} be the set of authoritative field names. Let S be the set of authoritative institutional states. Let T be a totally ordered record-time domain. Event record times in a valid trace are nondecreasing.

Mira’s filing can be revised without becoming a different workflow. The answer to one revision must nevertheless identify the exact address, evidence, and rule that the registrar considered. A stable workflow identifier and a separate revision identifier express this distinction. An action request is an immutable revision of a workflow:

q=(\ell,\xi,p,a,o,x,e,r,\nu,c_q,d_q).

The boundary assigns the stable workflow identifier \ell. The fresh nonce \xi identifies one revision. The actor is p\in P, the action is a\in A, and the target is o\in O. The payload is x, and the submitted evidence is e. The boundary selects governing rule r, immutable version \nu, question context c_q, and request expiry d_q.

The context c_q contains the frozen subject facts and proof inputs that give the question its meaning. It excludes later judgment receipts and auxiliary ledger appends. Mutable conditions governing an answer’s current use are checked separately. These include revocation, supersession, and the current request revision. Thus an accepted answer does not invalidate its own signed context.

Let H assign a content identifier to a canonical record. Write \omega=H(q) for the revision’s content identifier. The formal model compares the complete canonical records named by these identifiers. Section 6 states the cryptographic realization assumptions. Changing a bound field requires a fresh revision and nonce. An authenticated continuation retains \ell and names its previous revision. The boundary checks that lineage against its registry. The registry records the current revision and successful consumption. Changing a revision preserves every unresolved obligation in that workflow. An authorized transfer of an unanswered obligation is called carriage. It moves the obligation to a successor pending record. Carriage supplies no answer.

3.1 Scoped capabilities

Mira can delegate only the authority she received. The record must therefore identify both the permitted act and its permitted effects. Judgment authority needs an answer scope as well: permission to answer one question need not include every possible determination. A capability is a tuple

c=(i,h,O_c,A_c,F_c,Y_c,[t_0,t_1],n,\pi,\sigma).

The issuer i delegates to the holder h. The set O_c is the object scope. The set A_c is the action scope. The set F_c\subseteq O_c\times\mathsf{Field} is the field scope. The set Y_c is the allowed judgment-answer scope. The interval [t_0,t_1] is the validity window. The natural number n is the remaining delegation depth. The value \pi identifies the parent capability, or a trusted root when no parent exists. The value \sigma is the issuer’s authentication evidence over the other fields.

A trusted root is a capability whose authority the model accepts as an axiom. A capability chain for principal p is a finite sequence from a trusted root to a capability held by p. The chain is well formed at time t when:

  1. Every authentication check succeeds.

  2. Every parent points to the preceding capability.

  3. Each child issuer is the holder of its parent capability.

  4. Each child object scope is a subset of its parent’s object scope.

  5. Each child action scope is a subset of its parent’s action scope.

  6. Each child field scope is a subset of its parent’s field scope.

  7. Each child answer scope is a subset of its parent’s answer scope.

  8. Each child validity interval is contained in its parent’s interval.

  9. Time t lies in every link’s validity interval.

  10. Delegation depth strictly decreases at each link.

  11. No revocation or competent authority notice terminating any link, effective at or before t, appears in the trace prefix.

The chain’s effective scope is the intersection of all object, action, field, answer, and time scopes in the chain. Intersections are used because a delegate cannot grant more than it received.

Let \Gamma_\tau be the authority context recorded in trace prefix \tau. It contains trusted roots, issued capabilities, revocations, recorded authority terminations, and authentication material. We write

\Gamma_\tau \vdash_\chi p \triangleright (a,o)

when the named chain \chi is well formed and live at the evaluation time, ends at p, and its effective scope contains action a and object o. Naming \chi prevents different chains from supplying different parts of one authorization.

3.2 Rule outcomes and discretion holes

The filing rule needs the request history as well as the company record. Otherwise it could overlook an unanswered question or reuse an answer whose permitted use has ended. Let \Gamma^J_\tau be the auxiliary ledger derived from accepted events in trace prefix \tau. It records request revisions, consumption, discretion holes, original resolutions, derived uses, carriage, supersessions, and eligibility changes. It supplies evidence to the evaluator and leaves institutional state S unchanged. For each action a, the evaluator returns one of three results. It either permits the act, refuses it with a reason, or requests judgment:

R_a(s,q,\Gamma^J_\tau,t)\in \{\operatorname{Permit}(b),\operatorname{Refuse}(r), \operatorname{Awaiting}(j)\}.

A permit carries a rule receipt b=(r_b,\nu_b,e_b,\omega_b,J_b,\mathcal{G}_b).

A rule receipt records what supported the permission. The final commit receipt will also bind the actor, authority, actual change, and commit time. A judgment dependency is an answer used by that evaluation. An observation guard records a fact or query result that must still hold at use. The receipt identifies the rule, immutable version, evaluated evidence, request revision, exact judgment dependencies J_b, and observation guards \mathcal{G}_b. Every judgment dependency names a judgment-use record for \omega_b. It contains a direct resolution or an authorized derived-use certificate, as defined below. All guards of each derived-use record also belong to \mathcal{G}_b. The guards record relevant values, range results, and absence predicates. They include the current revision, consumption status, unresolved holes, superseding acts, conflicts, quorum membership, and policy-selected authoritative sources whenever the evaluation uses those facts.

The question an authorized person must answer

For Cedar’s filing, suitability of the new address is a question about specified facts under a specified rule. Its record must preserve that meaning while the set of people entitled to answer can change. A refusal carries reason r. An awaiting result carries the discretion hole

j=(k,m,\ell,\omega,o,Q,E_j,U_j,Y_j,\delta,d_j).

The evaluator supplies a stable rule occurrence key m. This key identifies one question produced by the rule. It includes any refresh generation authorized by the governing rule. The pending identifier is determined before admission: k=H(\omega,r,\nu,m,Q,E_j,U_j,Y_j,\delta,d_j). A repeated evaluation of the same occurrence has the same identifier. A later question or refresh requires a distinct justified occurrence key. The registry binds each (\omega,m) to its complete question record. Changed fields under an existing occurrence key are rejected. The key \omega binds the complete request revision. The text Q states the question, and E_j names required evidence. The set U_j\subseteq P gives the initial eligible answerers. The set Y_j defines the answer domain. The condition \delta governs escalation. The record d_j states answer-time and permitted-use validity conditions. The answer deadline lies within the request’s expiry. The governing authority separately selects and authenticates permitted-use conditions. They can permit reuse after the original request’s execution deadline. That request itself remains subject to its original deadline.

The immutable pending-record key is \pi_j=H(\omega,j,\mathsf{judgments}(o)). It binds the question, evidence requirements, authority interface, answer scope, initial eligibility policy, and validity conditions. Each pending record also has a current eligibility epoch \epsilon_j. An epoch identifies the current eligible-answerer set. Authenticated escalation can change that epoch and its eligible set. It preserves the immutable record named by \pi_j.

Let \operatorname{Open}_\tau(\ell) contain every discretion hole for \ell that remains an active unanswered leaf across all revisions. A pending record has at most one terminal disposition: resolved, derived, superseded, or carried to one successor record. Carriage edges advance revisions and have no cycles or forks. The carriage map is injective, so distinct duties remain distinct. Carriage preserves the active successor obligation. It supplies no answer. Expiry alone leaves an unanswered obligation open. Resolving a hole requires a principal eligible in the current epoch, an answer y\in Y_j, and one live chain whose action scope contains \operatorname{resolve}, object scope contains \mathsf{judgments}(o), and answer scope contains y. Supersession requires the corresponding \operatorname{supersede} authority. It closes an obsolete hole but never satisfies a member of J_b. A later permit must come from a fresh evaluation that no longer depends on that hole. The first valid resolution or supersession for k is final within the trace; later attempts are rejected. Every resolution authenticates its original request revision and pending record. Its additional evidence remains in the resolution receipt. It does not silently replace the request’s submitted evidence. Current-use guards are evaluated after resolution. They are distinct from the immutable signed subject and question context.

Using an answer in a later request

A later filing can concern facts already considered by the registrar. Reuse requires authority for that use and compatibility with the new question. The following record makes both conditions checkable.

For example, an address-suitability judgment may expressly permit use for another filing about the same premises. The receiving rule must accept that use under the original conditions. Changing the address changes the subject of the question and requires a new compatibility check. A rule requiring fresh personal judgment requires a fresh answer.

A judgment-use record binds an answer to the current request’s pending record. A direct resolution supplies such a record for its own revision. An earlier resolution can support another revision through a certificate \upsilon=(\zeta,\pi_{\rm target},\omega,r_u,\nu_u, \mathcal{D}_u,\mathcal{G}_u). The immutable original resolution \zeta retains its exact request, question, answer, evidence, signer, chain, issuance, and validity. The certificate names the target pending record and current request, governing reuse rule and version, compatibility derivation, and use guards. The checked derivation \mathcal{D}_u establishes authorized reuse. The original act permits that use, and the receiving rule accepts it. The answer supplies the target question under its subject facts, evidence requirements, and answer domain. Every original and target use condition holds. A rule requiring fresh personal judgment prevents mechanical reuse. Reuse preserves original issuance and signed permitted-use expiry. It cannot amplify scope. The boundary authenticates the certificate and checks its use guards.

A fail-closed two-valued evaluator can send a refusal to an external human process. The third result adds something different: it makes the question, answer domain, answering authority, and resulting human act a named dependency of the state change.

When an earlier evaluation still applies

An answer can be authentic while the permission based on it has become stale. Another judgment might conflict with it. A new request might replace the one evaluated. A source-selection policy might change. The evaluator must record every observation that determines its result. The commit then checks those observations together.

A query can depend on an absence: no conflicting judgment was found. It can also depend on several facts changing together. The condition below requires equal observations to imply equal evaluation results across complete contexts. This is the meaning of dependency completeness. The write footprint records which fields the proposed action may change; Section 3.3 specifies that part of the result.

Completeness is extensional across whole admitted contexts. An admitted context contains institutional state, both ledgers, and the governing policy and source records. For context C, write \mathsf{Eval}(C;q,t)=(v,J,\mathcal{G},W), where v is the rule outcome and W is the declared write footprint defined in Section 3.3. For the state s in C, this footprint equals W_a(s,q). Let \mathsf{obs}_{\mathcal{G}}(C) contain the exact named values and predicate results. For every admitted context C', completeness requires \mathsf{obs}_{\mathcal{G}}(C')=\mathsf{obs}_{\mathcal{G}}(C) \quad\Longrightarrow\quad \mathsf{Eval}(C';q,t)=(v,J,\mathcal{G},W). The statement quantifies over simultaneous changes outside the guards. One-at-a-time insensitivity is insufficient. The final boundary checks the named reads and predicates atomically with the commit. An altered guard requires a fresh evaluation.

A checkable dependency fragment. Consider finite expressions built from constants, named reads, registered queries, total pure operations, and conditional expressions. A query declares its result domain, selecting policy, and predicate scope. Its source head identifies the version of the source record. Its range head identifies the version of the complete range inspected by the query. An insertion into that range therefore changes the observation even when all previously returned records remain unchanged. The dependency function D includes every named read. It includes the source head, range head, and selecting policy of each query. For an operation, D takes the union over its operands. For a conditional, it takes the union over the guard and both branches. The same analysis applies to judgment selections, write values, and external command descriptors. An opaque primitive supplies a checked semantic contract or declares its entire readable domain.

Lemma 2 (setwise dependency preservation). If two admitted contexts agree on D(e), expression e produces the same value, judgment references, and proposed effects in both contexts.

Proof. Induct over the expression syntax. Constants require no observation. Named reads agree by hypothesis. Query results agree because their complete domain, predicate scope, and selecting policy agree. Total operations preserve equal operands. A conditional has equal guard values and therefore selects the same branch. The union includes that branch’s dependencies. The argument applies to tuples of outputs. It therefore establishes whole-context completeness for this fragment.

For example, let e=x\mathbin{\wedge}y at (x,y)=(0,0). Either isolated change leaves the outcome false, whereas changing both makes it true. The analysis includes both coordinates. A judgment query also includes an absence predicate, so insertion of a new conflicting judgment invalidates its earlier observation.

The commit witness contains the complete vector of source heads. A local transaction protects those heads, point reads, and predicate reads through the same durable decision that appends the receipt. A remote current-use dependency requires the source’s authorized use transition or an institutionally sufficient reservation at the named use stage. A fresh cached head alone supplies no such reservation. Changing any protected source requires reevaluation before commit.

3.3 Mutation footprints

The address example requires more than the action name. The operation must change only the fields its authority covers. We call the operation that proposes this concrete state change a primitive. For each action, a primitive transition function proposes a next state:

F_a(s,q)=s'.

The function also declares a write footprint W_a(s,q)\subseteq O\times\mathsf{Field}. The footprint lists every authoritative field the primitive may change. Primitive soundness requires the actual difference between s and s' to be contained in the declared footprint.

The footprint is part of authority, not only an engineering optimization. Permission to change a company’s address does not imply permission to change its shareholders. A capability that names an object but not its relevant action is incomplete. The pair of action scope and write footprint supplies the finer boundary.

Which changes require their own authority

A final record can hide an earlier effect. Writing a shareholder field and then restoring it produces no final difference, but another party might have observed the temporary value. The trace must retain each visible write.

Observable effects. A primitive can perform several internal computation steps before Commit. Those steps use private workspace. Isolation prevents external readers, callbacks, triggers, and adapters from observing its provisional writes. The workspace has no dispatch capability. Its observable result is the single admitted Commit and its declared effects.

A step visible outside that workspace is a separate admitted transition. Write \mathsf{Writes}(\tau) for the sequence of all pairs (i,o,f) changed by Commit i, with their old and new values. It retains multiplicity and order. A write followed by restoration therefore contributes two entries even when the final difference is empty. The footprint check applies to each observable step, before visibility. An implementation may refine an isolated step into hidden operations only when its projection has the same observable trace.

Commands whose effects occur elsewhere

A local record can instruct a provider to act. The provider’s subsequent performance occurs outside the local transaction. An unresolved attempt must remain attributable while the institution waits for evidence. A durable outbox stores the admitted command before dispatch.

External command attempts. An action can commit a command record to a durable outbox. Its command identifier binds the immutable request before dispatch. The record names the provider, operation, resource reservations, permitted outcomes, and the authority-use stage required by the provider contract. A dispatcher atomically marks an attempt ready before it sends anything. It checks current authority and source coverage at actual dispatch. Provider acceptance or performance has its own current-use check when the applicable authority contract requires that later stage.

The observable trace also records \operatorname{Send}(c,i,t) and authenticated provider observations \operatorname{Observe}(c,o,z,t_e,t_r). Here c identifies the command, i the attempt, o a physical occurrence, and z the reported outcome. Occurrence time t_e and recording time t_r remain distinct. Send requires the admitted ready attempt and the same immutable command. A retry preserves c. Provider idempotency is a separate adapter contract. An unknown attempt preserves its reservations and outstanding obligation. A successor dispatcher recovers the ready record and reconciles evidence before deciding whether another attempt is permitted.

Observations retain partial completion, uncertainty, reversals, and disputes. They enter an append-only evidence journal, including adverse observations. A separate authorized Commit reconciles the institutional state with them. Restoring a local field cannot delete Send or Observe. An offline replay folds records and has no Send transition. A provider may promise stronger reservation or settlement behavior through an explicit protocol contract. The local receipt never substitutes for it.

3.4 Trace events

The ordinary filing submits a request, waits if judgment is needed, records an authorized answer, and attempts a commit. Authority notices or conflicting changes can intervene. The event rules below specify what each step must establish and which record it may change.

An execution trace is a finite sequence of the following events. Each event time is at least the prior event’s record time.

Registering a request and preserving its unanswered duties

  • \operatorname{Submit}(q,\omega_{\rm prev},M,\chi,\alpha,t) registers an immutable request revision. The boundary authenticates p through one live chain covering a and o, and checks the recorded workflow lineage. A first submission receives a fresh \ell. A continuation names the current revision as \omega_{\rm prev}. Its actor must control that lineage under the recorded submission authority. The nonce \xi is fresh and t\leq d_q. The rule and frozen question inputs match the boundary’s evaluation. The authenticated event also binds the carriage map M. Every displaced predecessor obligation has one entry in M. Each entry names an open original record and a successor pending record determined by the new revision’s evaluator. Each successor satisfies Await’s admission conditions in the same atomic registered context. These include nonempty eligibility, declared judgment scope, canonical occurrence binding, and a fresh initial eligibility epoch. The recorded governing policy authorizes that question and expiry transition. It preserves every still-required question, evidence duty, and answer restriction. The map is injective, and each edge advances the revision. An unanswered obligation disappears only through authorized supersession. Registration atomically makes H(q) current, authenticates the successor records, and marks each mapped predecessor as carried. Unmapped records remain open under their original conditions. When those conditions preclude an answer, revision requires authorized carriage or prior authorized supersession. Without that path, registration fails and preserves the prior state. Carriage creates a new authorized opportunity to answer. It renews no prior determination, evidence validity, or use expiry.

Recording authority and its termination

  • \operatorname{Issue}(c,t) adds a delegated capability after checking a live parent chain at t, issuer-parent continuity, scope, validity containment, depth, and authentication.

  • \operatorname{AuthorityNotice}(c,s,k,t_e,t_r) records an authenticated external authority event from source s under its coverage contract k. The event binds the affected capability, legal effective time t_e, recording time t_r, and supporting bytes. Its source must have the contract’s competence for that event class. A court or registry source can differ from the capability’s issuer. Recording the notice appends evidence and updates current-use status. A late notice preserves earlier records and opens an attributed coverage breach with affected acts and required remedial actions.

  • \operatorname{Revoke}(c,u,t) records a prospective revocation effective at t only when u issued c or holds a live ancestor of c, and u authenticates the act.

Recording the rule outcome

  • \operatorname{Refuse}(q,r,t) requires R_a(s,q,\Gamma^J_\tau,t)=\operatorname{Refuse}(r). It does not change state.

  • \operatorname{Await}(q,j,\alpha_A,t) returns the existing record and current status when the occurrence key was already admitted. A new occurrence requires R_a(s,q,\Gamma^J_\tau,t)=\operatorname{Awaiting}(j), a current unconsumed request revision, t\leq d_q, U_j\ne\varnothing, and a declared \mathsf{judgments}(o) scope. The boundary checks the complete request and frozen question binding. It validates the occurrence key and derived k. A new occurrence records \pi_j as open and sets its initial eligibility epoch. Authentication \alpha_A binds the complete pending record to this accepted boundary event. A retry creates no second pending obligation.

Answering or disposing of a pending question

  • \operatorname{Resolve}(\pi_j,\epsilon_j,u,y,\chi_J,\zeta,t) looks up one earlier authenticated open pending record admitted by Await or atomic submission carriage. Its complete pending record must match \pi_j. Its request belongs to the recorded authenticated lineage. Its eligibility epoch must be current. The answer satisfies y\in Y_j, and its evidence satisfies E_j. The answer-time conditions in d_j hold at t\leq d_q. One live chain \chi_J ends at authenticated resolver u. It covers \operatorname{resolve}, \mathsf{judgments}(o), and y, and u belongs to the current eligible set. Resolver authentication covers \pi_j, \epsilon_j, answer, supplied evidence, chain, permitted use, and time. Acceptance atomically records \zeta and closes that pending record. Its open-state, lineage, and epoch checks occur in the same transition. An earlier revision can therefore receive its own still-valid answer. That answer supports a newer revision only through authorized reuse.

  • \operatorname{Reuse}(\pi_{\rm target},\zeta,\upsilon,t) requires an authenticated open target record for the current revision. The source is one accepted original authenticated resolution. The boundary validates the complete certificate \upsilon, its compatibility derivation, and every original and target use condition. It atomically checks the target, current revision, and use guards, authenticates the certificate, and marks the target as derived. An authorized reusable judgment requires no new human signature.

  • \operatorname{Supersede}(\pi_j,u,r',\chi_J,\zeta,t) looks up one earlier authenticated open pending record. It closes that exact record only when u is currently eligible, the live chain \chi_J ends at authenticated u and has action scope \operatorname{supersede} and object scope \mathsf{judgments}(o). The authenticated act binds \pi_j, reason r', any successor reference, chain, and time. Its eligibility and open-state checks are atomic with closure. Supersession supplies no answer and satisfies no judgment dependency.

  • \operatorname{Escalate}(\pi_j,\epsilon_j,u,U'_j,\chi_J,\zeta,t) requires that exact pending record to remain open. The named eligibility epoch must be current and \delta must hold. Authenticated u has one live chain covering \operatorname{escalate} over \mathsf{judgments}(o). The immutable escalation policy must permit U'_j. The signed act binds \pi_j, prior epoch, new eligible set, triggering evidence, chain, and time. Acceptance atomically checks those premises and records a fresh epoch. It preserves the question, answer domain, and open status.

Recording external attempts and observations

  • \operatorname{Send}(c,i,t) performs the admitted ready attempt under its actual-use authority and provider contract. \operatorname{Observe}(c,o,z,t_e,t_r) appends authenticated external evidence, preserving physical occurrence identity and both times. These events follow the command and observation rules in Section 3.3. They do not directly change the institutional state S.

Admitting the state change

  • \operatorname{Conflict}(q,\eta,t) records that the expected state-and-history head \eta was stale. It changes no institutional state and consumes no request revision.

  • \operatorname{Commit}(q,\eta,s,s',b,\chi,\alpha,\rho,t) atomically changes the current authoritative state from s to s', consumes the current request revision, and appends receipt \rho. The value \alpha authenticates the holder of \chi as the actor named by q.

Let \operatorname{head}(\tau) be a cryptographic commitment to the current institutional state and the preceding event history. A source head similarly identifies the source record used in evaluation. A source-use contract states what its competent owner must establish when authority is used. It is ready when its required conditions hold. Retention admission checks that the required evidence bytes have been stored and retrieved under the custody contract. Sections 6.1 and 6.2 give these two contracts in full.

The commit rule has six premises:

  1. Holder authentication \alpha verifies that p controls the terminal principal of one named chain \chi, and \Gamma_\tau\vdash_\chi p\triangleright(a,o) holds at t.

  2. The same chain \chi covers a, o, and every field in W_a(s,q).

  3. The expected head \eta equals \operatorname{head}(\tau), and the current state is s. The request revision H(q) is current and unconsumed, t\leq d_q, and the governing rule still applies. The request’s frozen subject and question context match this evaluation. Every required source-use contract is ready at this durable use time. Every required evidence preimage has a valid retention admission. The receipt binds those contracts, source heads, and evidence manifest.

  4. R_a(s,q,\Gamma^J_\tau,t)=\operatorname{Permit}(b), J_b is complete, \operatorname{Open}_\tau(\ell)=\varnothing, and every member of J_b is a valid judgment-use record. Each record satisfies the judgment-ledger invariant below. Its target pending revision equals \omega_b=H(q). A direct resolution supplies its own answer. A derived record retains its exact authenticated original resolution and checked authorized compatibility derivation. The rule identifiers and versions in q and b agree. Every original and target permitted-use condition holds at Commit. Continuing resolver authority is checked when the governing rule requires it. Historical authority is checked at resolution time. All read and predicate guards in \mathcal{G}_b hold atomically with Commit. Whole-context completeness covers simultaneous changes outside them. Supersession cannot satisfy a judgment dependency.

  5. F_a(s,q)=s' and the actual difference from the current s to s' lies within W_a(s,q).

  6. The receipt \rho binds q, its submitted evidence, \chi, \alpha, the rule identifier and version, J_b and its exact pending and resolution records, \mathcal{G}_b, derived-use certificates and their compatibility derivations, \eta, the output-state digest, revision consumption, and t. Consumption and receipt append occur in the same state-changing event.

No other event changes S. Issuance changes authority without expanding it. Revocation prevents later use of the affected authority. Submission, awaiting, resolution, reuse, supersession, and escalation change only \Gamma^J_\tau. A later legal decision with retroactive effect requires a new authorized remedial event. It does not alter an earlier trace prefix.

4. Authority-preservation theorem

The event rules describe one accepted act. The theorem must also account for everything that happens between acts, including revocation and revision. Its proof follows the trace and shows that these events preserve the attribution of earlier changes.

The assumptions specify what a realization must enforce. F1–F9 concern the initial roots and the local execution boundary. F10 supplies the authority information required at each use; Section 6 explains its external institutional conditions.

  • F1. Root integrity. Every trusted root in the initial authority context is authentic within the model.

  • F2. Exclusive mutation boundary. Only the commit event changes authoritative institutional state.

  • F3. Atomic current-head check. Commit succeeds only when its expected head and input state equal the current head and state.

  • F4. Primitive footprint soundness. Each observable primitive changes only fields in its declared footprint, measured from its current state. Hidden steps have no external observer or dispatch capability. The effect journal preserves every visible step.

  • F5. Complete judgment discipline. Commit requires permit, a complete dependency set, and no open hole across workflow revisions. Each dependency satisfies the judgment-ledger invariant and binds the current target revision to a valid authenticated original resolution. Derived reuse requires its authorized compatibility derivation. Every use condition remains valid for the committed act. Completeness compares whole contexts using exact reads and protected predicate results. Commit atomically validates those observations. A successful commit consumes that revision once.

  • F6. Time causality. Record times are nondecreasing. A revocation changes the authority context only for events at or after its recorded time.

  • F7. Atomic receipt append. A commit and its receipt are one trace event.

  • F8. Trusted record time. The boundary assigns event time from a trusted monotone clock. The actor cannot choose it.

  • F9. Holder authentication. Each commit authenticates its actor as the holder of the chain it names. Submission authenticates its requester and complete event record. Resolution, supersession, and escalation authenticate their acting principals and complete event records. Admission, carriage, and reuse records authenticate their boundary origin.

  • F10. Authority-context completeness. Each authority-use event has the source-specific coverage contracts defined in Section 6.1. Every termination effective at or before that use is either recorded before the use or handled by an institutionally sufficient use decision. This includes issuance, submission, judgment, commit, and required external use stages. Authenticity alone establishes no coverage. The competent institutional owners discharge each contract’s legal scope and effective-time conditions.

We first check the origin of human answers. Without this invariant, an otherwise valid commit could cite an answer to the wrong question.

Lemma 0 (judgment-ledger integrity). Every accepted resolution names one earlier authenticated pending record admitted by Await or submission carriage. Its immutable request, question, authority interface, evidence requirements, and answer domain match that record. The resolver authenticated the particular answer under one live, in-scope chain and the current eligibility epoch. Each pending record has at most one terminal disposition. Every derived answer retains an authenticated original resolution and a checked authorized use derivation for its target. Carriage preserves each unanswered obligation as a distinct successor.

Proof. Induct over accepted events. Await introduces a justified occurrence and its complete binding. A retry returns the existing record and preserves its status. Resolve requires that record to be open and checks every named binding, authentication, authority, epoch, and validity condition. Its atomic transition changes the record to resolved. Supersede requires the same open state and changes it to superseded. Reuse validates the original resolution, compatibility derivation, and current use guards before atomically marking its target derived. Any terminal state prevents another terminal transition. Escalate preserves the immutable record and authenticates its next epoch. Submit retains unmapped obligations. Each carriage entry atomically replaces an open leaf with its distinct authenticated successor under the recorded governing policy. Revision advancement prevents cycles, and injectivity prevents merged duties. Thus carriage preserves an obligation and supplies no answer. The other events introduce no resolution or derived answer.

Proposition 1 (local commit boundary). Under F1–F10, every accepted \operatorname{Commit} event has the following properties:

  1. One authenticated chain is live at boundary-assigned commit time and covers the action, object, declared footprint, and actual difference.

  2. The rule result is permit, every named human dependency has one authenticated original resolution with a valid direct or derived use binding for the exact current request revision. No active discretion obligation in the workflow remains open. Every original and target permitted-use condition holds at Commit.

  3. The expected head is the current head, so the rule result applies to the state that changes.

  4. One receipt binds the request, actor authentication, chain, rule, evidence, exact pending records, resolutions, observation guards, input head, output digest, time, and one successful revision consumption.

Proof. The six commit premises give the four statements directly. F8 fixes the time used by the liveness test, F9 binds the actor to the chain, and F10 gives recorded termination its intended scope. Lemma 0 establishes the origin and binding of each resolution. Current-revision, context, and permitted-use checks establish its applicability. Whole-context completeness and the atomic guard check preserve the evaluated result and its declared effects.

The next observation connects the commit’s immediate delegation to its trusted root. Here attenuation means that delegation narrows authority.

Lemma 1 (chain attenuation). Every child capability has object, action, field, answer, time, and depth scopes contained in those of its trusted root.

Proof. Each issuance checks containment in its parent. Finite chains and transitivity give containment in the root. Revocation can remove a chain from later use but cannot enlarge it.

For states s,s', write D(s,s')=\{(o,f):s(o,f)\ne s'(o,f)\} for their field-level difference.

Theorem 1 (trace-wide effect attribution). Let a valid trace take initial state s_0 to final state s_m under F1–F10. For every (o,f)\in D(s_0,s_m), some commit in the trace changed (o,f). That commit names one chain \chi which was live at its boundary-assigned time, whose field scope contains (o,f), and whose receipt binds \chi, the rule result, both heads, and that time. Moreover, s_m is the ordered composition of the committed transitions and of no other events. Every commit also carries the exact authenticated judgments required for its request revision. No revision commits twice.

Proof. Induct on the trace length. The empty trace has s_m=s_0. Suppose the result holds for a prefix ending in s_n. If the next event is not a commit, F2 leaves the state unchanged. If the next event commits s_n to s_{n+1}, then D(s_0,s_{n+1})\subseteq D(s_0,s_n)\cup D(s_n,s_{n+1}). The induction hypothesis supplies the witness for the first set. Premises 1, 2, 5, and 6 of the last commit supply the live chain, scope coverage, and receipt for the second. F2 also proves that the final state is exactly the ordered composition of commit transitions. For each new commit, Proposition 1 supplies exact judgment dependencies and their permitted-use checks. Atomic consumption prevents another commit of the same revision. Noncommit events preserve these claims about earlier commits.

Corollary 1 (observable trace attribution). Every entry of \mathsf{Writes}(\tau) names its responsible live chain, footprint, and receipt. Every Send names an admitted command and a valid authority-use witness. Later restoration or compensation preserves those entries. Replay reconstructs them without executing another Send.

Proof. Apply Proposition 1 to each observable Commit before taking any final state difference. Send admission checks its own command and authority premises. The append-only trace preserves both event forms. Private computation contributes no observation by the isolation contract. Replay reads Send records through the reconstruction fold. That fold has no operation that executes dispatch. These cases establish the result by induction over observations.

The theorem concerns recorded authority and execution of an encoded rule. Legal validation must establish that the relevant institution designated the trusted root and that the encoded rule matches its legal source for the stated jurisdiction and time.

5. Why the assumptions are necessary

The first four failures remove one control and violate an attribution conclusion. They identify distinct obligations in an implementation. The final example separates formal attribution from fidelity to the legal rule: the theorem can hold while the encoded rule is wrong.

Theorem 2 (four necessary controls). Commit-time liveness, primitive footprint soundness, complete judgment dependencies, and faithful scope comparison are independently necessary for the local boundary and trace-wide attribution results. For each control, a trace can satisfy the other three and violate a conclusion when that control is removed.

5.1 Check-time is not commit-time

Remove the live-at-commit premise. Let a capability be valid through time 5. Let the program check it at time 4 and commit at time 6. The trace changes state without a live chain at commit. Proposition 1(1) is false. Caching an earlier authorization result does not make the trace valid because recorded authority is temporal.

The same counterexample applies to revocation and to authority that ends by operation of law. Suppose a winding-up order ends a director’s power at 16:30 while a capability interval runs until 17:00. A 16:40 commit passes unless F10 brings the order into the authority context before the commit. The required legal-event source is therefore part of the hypothesis.

5.2 A hidden write defeats scoped authority

Remove primitive footprint soundness. Give Mira authority only to change the registered-office field. Let the address primitive also change the controlling-shareholder field. The visible action is authorized, but the actual mutation exceeds its scope. A type declaration is useless when the code can write around it.

This counterexample requires an exclusive mutation boundary in the surrounding system. If an administrator, database trigger, or external service can change the authoritative record outside the event rules, the theorem governs only the trace and not the institution.

5.3 Timeout is not judgment

Replace awaiting with “permit after 24 hours if nobody answers,” or let a later permit omit the earlier discretion hole from J_b. No authorized person answers, yet the workflow commits. The unresolved question has become permission through silence or dependency omission. F5 rejects both traces.

Identifier continuity alone does not bind a human answer. The complete pending record binds the payload, evidence, rule, question context, authority interface, validity conditions, and request nonce. A changed request requires a new revision. Earlier obligations remain open until answered, lawfully superseded, or carried to an authenticated successor obligation. A resolution for an earlier revision supports a new revision only through an authorized compatibility derivation and current-use checks.

Dependency completeness also includes predicate observations. Two contexts agreeing on recorded reads but differing in an unrecorded absence condition need not produce the same result. The whole-context condition requires that absence to be guarded whenever the evaluator depends on it.

A supersession creates the same defect if it is treated as an answer. Let Y_j contain \mathsf{suitable} and \mathsf{unsuitable}. A principal with supersession authority but no answer scope closes j. If that receipt could satisfy J_b, the request would commit without either allowed answer. The commit rule excludes that trace.

Fail-closed behavior can still impose harm through delay. The model prevents unauthorized commit. It does not prove that a reviewer answers promptly, that queues are fair, or that awaiting cannot be used strategically.

5.4 Generic delegation amplifies through interpretation

Suppose a parent capability permits “manage company matters,” and the system treats that phrase as containing every later action name. A child capability can then appear formally narrower while acquiring authority that the parent never specifically granted. Scope inclusion is only meaningful over a stable action vocabulary or a signed interpretation rule.

The formal model assumes that scope comparison is decidable and faithful. Schema evolution therefore needs an explicit rule. New action names must not fall inside old wildcard scopes by default.

The four counter-traces establish Theorem 2.

5.5 A receipt can faithfully record a wrong rule

Let the encoded filing rule omit a statutory condition. The workflow may satisfy every formal premise and issue a perfect receipt for a legally invalid change. The theorem still holds because it proves execution relative to the encoded rule. It does not prove semantic equivalence between that rule and law.

This is the central boundary of computational law. Evidence of faithful execution is not evidence that the specification was right.

7. From authorized steps to completed obligations

The trace theorem applies to every accepted step of a longer workflow. It does not establish that the workflow can finish. We first examine how sequential, concurrent, and external steps retain their authority. We then add what completion needs: shared resource accounting, authority over affected rights, and a feasible continuation under possible responses.

The distinction is concrete. From a balance of 100, a permitted purchase of 60 can leave a required 60-unit delivery unfunded. A program also needs to account for what it cannot yet observe. A pending response can hide either completed performance or a continuing obligation. These are the problems treated by the finite constructions below.

7.1 Sequential composition

If two actions commit in sequence, the second evaluates against the state produced by the first. Its authority and rule checks are fresh. A permit receipt from the first action does not authorize the second. This prevents a workflow-level approval from becoming a blanket capability. The second action has a fresh request nonce. Its commit requires fresh authority and an unconsumed current revision. An earlier human judgment can support the new action through its authorized derived-use record and current-use checks.

A composite workflow is authority preserving when every state-changing step passes the same commit rule. The conclusion follows directly from Theorem 1 because the trace proof is event-local.

7.2 Concurrent proposals

Two programs can read the same state and propose inconsistent changes. Premise 3 atomically compares the expected head with the current head. If they differ, the boundary records a conflict and requires a fresh evaluation. The rule result therefore applies to the state that changes, and an in-scope field cannot be silently overwritten with a stale value. Current revision, consumption, eligibility, and observation guards are checked in the same accepted transition. A conflict leaves request consumption and pending-record status unchanged.

This rule closes the local lost-update case in the sequential model. It does not prove serializability for distributed effects. That theorem still needs a conflict relation, scheduler semantics, and an equivalence proof.

7.3 Compensation

Institutional workflows often include external steps that cannot be rolled back exactly. A bank transfer, public filing, or delivered notice may remain historically true after a later failure. A compensation is a new authorized action that restores a business invariant. It is not deletion of the prior act.

The safe pattern stages external effects after all reversible checks, records an intent before dispatch, and requires a separate capability for compensation. Theorem 1 then covers each forward and compensating commit. It does not prove that the compensation restores an external world state. That claim requires a contract for the external primitive and an extensional proof or empirical test.

A commit receipt may confirm that an instruction was dispatched. Legal finality and beneficiary credit follow the receiving rail’s rulebook and account relationship. Swift carries messages rather than funds (Cipriani, Goldberg, and La Spada 2023). Its speed measure therefore does not establish end-to-end beneficiary credit (Swift 2025). Fedwire finality follows Regulation J and Operating Circular 6, not the sender’s local receipt (Federal Reserve Banks 2026).

Current evidence and a recognized determination may shorten a later evaluation. The commit boundary does not make onboarding, authority, or recognition relationships portable. Each relationship must be formed under the receiving institution’s rules (Du, Huang, and Scharfstein 2026).

7.4 Delegation and revocation

Each step still needs a complete delegation. Combining workflows creates no new source of authority. Scope intersects along one parent chain. A principal may hold several independent chains, and each chain authorizes its own acts. One act must be covered by one complete chain; different chains cannot supply its action, object, and field scopes separately. Quantitative limits add a common economic account to this chain. Section 7.5 gives its containment and consumption rules.

Revocation is checked before each act that uses authority. Already accepted events remain historical facts. A later revocation can stop future commits or trigger a remedy. Notice to a third party is a separate legal act that a receipt can evidence. Irrevocable powers lie outside this capability model. Systems that require retroactive legal effect need a separate remedial transition and a rule for downstream reliance.

7.5 Shared economic authority

Consider a principal who authorizes expenditure of 100 units and appoints ten agents. Giving each agent a limit of 100 permits aggregate expenditure of 1,000. Intersecting each child’s scope with the parent’s scope leaves this error intact. A quantitative limit constrains a history of actions. It therefore needs one account shared by every action in that history.

Fix a competent authority root b and a finite set D of resource coordinates. Each coordinate names a unit, purpose, and accounting window. For example, separate coordinates can constrain total expenditure, expenditure during a day, and expenditure on a named project. Finite overlapping windows also express rate limits on a discrete time domain. Every applicable coordinate receives a charge. Unspecified units and accounting windows require an explicit extension of the mandate.

The root binds its owner, accounting rule, validity interval, and canonical account identity. Every child retains that identity. An alias, a new workflow, or another service identity creates no additional root account. For each capability c, let B_c\in\mathbb{Q}_{\geq0}^{D} be its limit. A child satisfies B_{c'}\leq B_c coordinatewise, narrows the purpose scope, and has a contained validity interval. The ordinary chain rules continue to apply. Creating a child changes no resource balance.

For command k, let u_k\in\mathbb{Q}_{\geq0}^{D} bound its charge. The command binds its request revision, complete economic dependencies, effect description, and one capability chain. The accounting rule must justify u_k against every permitted external outcome. A local estimate alone supplies no bound on a provider’s actual performance. Let r_k be the unresolved reservation and s_c the cumulative charge already attributed to capability c and its descendants. Define U_c=s_c+\sum_{k:\,c\in\operatorname{chain}(k)}r_k. \tag{E1} The sum ranges over all descendants, including sibling agents and suspended workflows. Each command appears once in an ancestor’s sum. The root’s counter therefore represents aggregate delegated use.

Admission compares the entire chain and reserves u_k in the same transition that admits the immutable command. It requires U_c+u_k\leq B_c at every ancestor c. A batch reserves the sum of its new commands. Distinct commands can then execute concurrently from their separate reservations. Local serial admission leaves their external work parallel. The construction does not require a distributed serializability claim.

When authenticated performance incurs charge d\leq r_k, reconciliation replaces r_k by r_k-d and adds d to each ancestor’s s_c. An exact command retry returns the recorded admission without reserving again. Each fresh dispatch still checks current authority and the complete current dependency set. A suspended or uncertain attempt retains r_k. Unused capacity returns only through an admitted release proving that further charged performance is excluded. A timeout supplies no such proof. Historical performance can be recorded after authority has ended without granting a new dispatch right.

A lifetime expenditure coordinate retains its consumed charge after a refund. A replenishable balance requires its own accounting rule and authenticated receipt. An exposure coordinate can permit release when its specified risk ends. Neither transition proves performance of an unrelated delivery obligation. Cash availability, expenditure authority, and outstanding duties have distinct projections of the same state.

Theorem 3 (aggregate economic attenuation). Suppose one boundary owns every counter for a canonical root. Assume complete command coverage, nonnegative charges, faithful charge bounds, atomic admission, and the transitions above. Starting with 0\leq U_c\leq B_c, every reachable state satisfies that inequality for every capability c. The result includes all sibling delegates, exact retries, suspended commands, and concurrent external execution.

Proof. Creating a child adds zero usage. Admission adds the new reservation to each affected ancestor and checks its limit atomically. Reconciliation moves d from reservation to consumed charge, so U_c is unchanged. A justified release decreases U_c. An exact retry changes no counter. Revocation changes authority and leaves historical charges and unresolved reservations intact. These cases exhaust the transitions. Induction on the admitted history proves the result. Concurrent external actions retain their separate reservations throughout their execution. \square

Two agents with limits 40 and 60 can reserve and execute both commands against a root limit of 100. If both hold limits of 100, one reservation of 100 excludes another. A shared intermediate capability with limit 50 also constrains the sum of its children, even when the root has unused capacity. Parent attenuation and aggregate accounting perform different parts of the argument.

This construction makes the common reservation account of Section 6.1 precise. Its economic dependencies use Lemma 2 and the same guarded membership and range observations as the commit boundary. It adds no alternative test for dependency completeness. A physical resource shared between separate institutional roots requires an explicit common allocation authority or a sound partition. Different root names alone establish neither construction.

7.6 Authority over affected rights

The shared account limits aggregate use. It does not identify whose rights an admitted use changes. A one-field change can alter many rights. Replacing a fee schedule may change the amount owed by every client whose contract refers to that schedule. The field footprint correctly identifies the written field. An additional projection identifies the resulting economic and legal changes.

Fix a guarded universe I of affected institutional relationships. For i\in I, define \rho_i(s) as its rights projection in state s. This projection includes the holder, obligor, applicable terms, amount or performance, priority, maturity, and discharge conditions relevant to the action. A created or removed relationship has a distinguished absent value on the other side. Define its actual impact by \mathcal I(s,s')=\{i\in I:\rho_i(s)\ne\rho_i(s')\}. \tag{E2} The action declares a set J containing \mathcal I(s,s') and supplies the current amendment authority for each changed projection. This authority names the exact old and new terms and their effective time. It includes consent when the governing rule requires consent. A competent public power or constitutional mandate can supply a different lawful basis. The construction does not convert every institutional duty into a commercial agreement.

The registered universe and its membership generation are guarded inputs. The dependency analysis includes the rules that interpret each relationship, their relevant data, and any range query that selects affected parties. A new affected contract invalidates a proposal’s old membership guard. The boundary recomputes the impact before committing it. Source completeness and competent authority remain the explicit institutional premises of Section 6.1.

Proposition 2 (economic impact attribution). Assume the registered universe covers every relationship in scope, the projections are faithful, and the impact guards hold at commit. If \mathcal I(s,s')\subseteq J and each changed projection has the required current amendment authority, every changed right in scope has that authority. Every relationship outside J has the same projection before and after the commit.

Proof. A changed projection belongs to \mathcal I(s,s'), hence to J, where its exact amendment authority is checked. If i\notin J, then i\notin\mathcal I(s,s'). Equation (E2) gives \rho_i(s)=\rho_i(s'). \square

For example, existing contracts can bind a fixed schedule while new contracts adopt a separately authorized schedule. A change for future contracts then preserves the existing clients’ projections. Charging those clients a higher fee instead requires their applicable amendment basis. Permission to write the schedule field supplies only the field part of that authority.

Complete impact analysis is a semantic obligation. The proposition does not infer an unrecorded right from a database field. Finite explicit contract families permit direct evaluation of every projection. More general rule languages need a sound abstraction or their own completeness argument. This is the same distinction between a declared write footprint and its faithful implementation, applied to the meaning of the record.

7.7 Viable continuations

A workflow can respect both its resource limits and its amendment authority, yet fail its obligation to deliver. An authorized action can leave no funded route to the required result. Spending 60 from a balance of 100 is within a limit of 100. It still strands a delivery that requires a further 60. A useful program therefore needs a continuation condition in addition to next-action permission.

For the balance of 100, a delivery route costing 90 can be viable, as can a route costing 80. The policy retains both when their declared outcomes meet the goal. The 60-unit preliminary purchase is excluded when every subsequent delivery costs another 60 and further funding is unavailable. Its local authority remains valid. It fails the stated continuation goal. A lawful refund route can remain available as a remedy while lying outside a delivery-only goal.

A continuation must work after every response allowed by the contract. We compute such continuations backward from the permitted outcomes. The first construction assumes the program sees the complete state. Here S denotes the safe subset of workflow states, distinct from the institutional state space used in Section 3.

We give an exact finite construction. Let X be a finite, fully observed state space. A state records current authority, source coverage, budget counters, outstanding rights, external outcomes, and the remaining time. Let S\subseteq X be the states allowed by the governing safety and risk contract. Let G\subseteq S be a nonempty set of authorized terminal outcomes. Delivery, discharge, and a permitted remedy have explicit predicates. A refund belongs to G only when that goal permits it. Public-service performance can define G through its governing mandate.

A policy chooses the next action from the state it observes. The environmental contract states how providers and other authorities can respond before the policy chooses again. At x, the finite set A(x) contains the actions or batches that satisfy the current commit, economic, and affected-rights rules. The finite environmental contract gives a finite family \mathcal P_E(x,a) of complete observable response paths for each action. Each path starts at x and contains at least one transition. Write \operatorname{Post}_E(x,a)\subseteq X for their final states. Terminal states occur only at response endpoints and admit no further act. The contract states the covered provider outcomes, evidence delays, authority changes, and losses. An executable action has at least one successor. An empty successor set cannot certify completion by a vacuous universal statement. The contract also binds the identities and versions that give these states and transitions their meaning.

For example, a safe first purchase must leave a permitted continuation after every allowed price, performance, and authority outcome. The sets V_h below collect states from which completion remains guaranteed within h decisions. The sets \Pi_h(x) collect all next actions preserving that guarantee.

Write \mathsf{SafePath}(x,a) when every state on every response path lies in S. For a horizon of h decision rounds, define \begin{align*} V_0&=G,\qquad \Pi_0(x)=\varnothing,\\ \Pi_{h+1}(x)&=\{a\in A(x):\mathsf{SafePath}(x,a),\; \varnothing\ne\operatorname{Post}_E(x,a)\subseteq V_h\},\\ V_{h+1}&=G\cup\{x\in S:\Pi_{h+1}(x)\ne\varnothing\}. \tag{E3} \end{align*} At a terminal state the policy stops. Elsewhere it retains every member of \Pi_h(x). Outside S, define \Pi_h(x)=\varnothing. The remaining horizon decreases after every response path.

Theorem 4 (finite viable continuation). For the stated fully observed contract, x\in V_h exactly when a policy can keep every reached state in S and terminate in G within h rounds, against every response path in \mathcal P_E. Here the horizon counts decision rounds. Every action in \Pi_h(x) at x\in S\setminus G preserves this guarantee. Any action outside that set at x\notin G fails to supply such a guarantee for the remaining horizon.

Proof. For h=0, completion means x\in G. Suppose the equivalence holds for h. From a nonterminal state, a policy must select an executable action whose response paths stay in S and whose every final state admits a remaining policy of horizon h. The induction hypothesis makes this exactly the condition defining \Pi_{h+1}(x). The state itself must belong to S. Conversely, choose any action in that set. After observing its outcome, use the corresponding policy furnished by the induction hypothesis. Its horizon decreases and it reaches G. Empty successor sets were excluded, so this implication cannot use an impossible transition. The same argument proves the claim for every retained action and excludes each other first action. \square

An intermediate violation followed by restoration fails \mathsf{SafePath}. Safe endpoints alone establish no such guarantee. Each response path also retains the per-event guards of Theorem 1. An initial batch decision supplies no authority for an unchecked later act. Each response contract has a finite duration bound, represented by the clock in X. A deadline belongs to S and G when the mandate requires it. Waiting beyond that deadline is then an explicit losing outcome.

The recursion is ordinary finite backward reachability. Its institutional content lies in the state, action, and environmental contracts being composed. Theorem 3 contributes aggregate resource bounds. Proposition 2 contributes authority over changed rights. The original commit theorem supplies current authority, complete dependencies, and effect attribution. No one of these properties implies the others.

A safety contract can permit a measured loss. The theorem does not require every transaction to be riskless. Its universal quantifier ranges over the declared environmental outcomes. A provider failure or authority change outside that set is a contract breach, requiring a fresh analysis from the observed state. A rejected transition preserves existing rights and obligations. It cannot replace delivery with a newly convenient goal.

The finite reference construction evaluates every action and successor in Equation (E3). It includes parallel sibling reservations, ancestor limits, revocation before dispatch, uncertain performance, and fee changes affecting existing and future contracts. Its witnesses distinguish an authorized dead end, a viable alternative, an impossible transition, and a refund outside the delivery goal. These establish the stated finite semantics. The next construction treats partial observation. Unbounded service and production adapter refinement require additional results.

7.8 Acting from incomplete observations

A delayed answer can arrive after the acting delegate loses authority. The answer resolves the judgment. A current authority check still governs the next effect. Meanwhile, independently authorized preparation can continue. The program needs to distinguish these three conditions while retaining every useful continuation supported by its evidence.

Example 1 (useful work through suspension). One party reserves 80 units of money. The other reserves one service slot. A pending judgment can approve or refuse performance. Its answer arrives within two admitted service opportunities. Here a service opportunity is an admitted chance to obtain that answer. The acting delegate can lose authority during either opportunity or during independent preparation. The evidence returned to the program reports the judgment. The authority change remains hidden until a guarded attempt returns its result.

After approval, the program can still be uncertain about its delegate’s authority. The same observation is compatible with a live delegate and a revoked delegate. A command must therefore be safe in both cases, and its observed response determines what can happen next. This requires a set of possible states rather than one assumed state.

Let X and \overline A be finite sets of states and command choices. Let S\subseteq X be the safe states and G\subseteq S the fulfilled or expressly permitted terminal outcomes. A state includes all memory that constrains later responses, including hidden authority and pending response obligations. The initial contract supplies a nonempty set B_0\subseteq X containing every initially possible state. A belief B is the nonempty set of states consistent with the complete action and observation history.

The controller is the program that implements the policy. For each x and a, the contract supplies finite response paths \mathcal P_E(x,a). Each path starts at x and ends at the next controller decision. Intermediate steps obey the same authority, rights, and resource guards as a separately issued act. The controller makes no intervening choice. Its transcript \operatorname{obs}(p) contains exactly the evidence and timing it observes. Hidden state labels never enter that transcript automatically.

A program cannot choose different actions in states its observations do not distinguish. Its next choice must have a defined response in each possible state. An action is uniformly executable at B when \mathcal P_E(x,a)\ne\varnothing for every x\in B. One guarded attempt can therefore succeed under live authority and return a local refusal under revoked authority. Both are responses to the same choice. Refusal preserves the outstanding duties and their reservations. An empty response family in one possible world prevents uniform execution.

The update keeps precisely the endpoints compatible with the response actually observed. Thus approval can settle the judgment while leaving authority uncertain; a later guarded attempt can resolve that uncertainty.

For a possible transcript z, define the updated belief U(B,a,z)=\{\operatorname{last}(p):x\in B,\; p\in\mathcal P_E(x,a),\;\operatorname{obs}(p)=z\}. \tag{E4} Write Z(B,a) for the transcripts that these paths produce. Every update for z\in Z(B,a) is nonempty. An observation outside Z(B,a) is a contract breach. It supplies no completion certificate.

The actual endpoint belongs to every successive belief. Initially this holds by the state contract. Each actual response starts in the prior belief and produces the received transcript. Equation (E4) therefore retains its endpoint. Complete state memory makes the update exact. A conservative transition contract instead gives a conservative belief, which can exclude actions that the actual environment would permit.

Actual fulfillment and knowledge of fulfillment differ. Completion can be declared precisely when B\subseteq G. A belief containing a fulfilled world and a pending world still requires evidence. Unlike the terminal convention in Section 7.7, fulfilled states here can admit evidence-only responses. The controller’s declaration ends the policy.

We now apply the same backward argument to sets of possible states. \mathcal W_h contains the beliefs from which safety and known completion can be guaranteed within h decisions. The set \widehat\Pi_h(B) retains every first choice with that property. Each possible observation must lead to a belief with a shorter guaranteed continuation.

Let \mathsf{SafePath}(B,a) require every state on every response path from B to lie in S. Define \begin{align*} \mathcal W_0&=\{B:\varnothing\ne B\subseteq G\}, &\widehat\Pi_0(B)&=\varnothing,\\ \widehat\Pi_{h+1}(B)&=\{a\in\overline A: a\text{ is uniformly executable at }B,\\[-2pt] &\qquad\mathsf{SafePath}(B,a),\quad U(B,a,z)\in\mathcal W_h\text{ for every }z\in Z(B,a)\},\\ \mathcal W_{h+1}&=\mathcal W_0\cup \{B:\varnothing\ne B\subseteq S,\; \widehat\Pi_{h+1}(B)\ne\varnothing\}. \tag{E5} \end{align*} Set \widehat\Pi_h(B)=\varnothing when B is unsafe or B\subseteq G. At other winning beliefs choose any retained action. After receiving its complete response, apply Equation (E4) and decrease h by one.

Theorem 5 (viable continuation from observations). Under the complete finite contract, B\in\mathcal W_h exactly when an observation-based policy guarantees safety and known completion within h decision rounds. The guarantee covers every permitted response path. At a nonterminal safe belief, \widehat\Pi_h(B) contains exactly the first actions of such policies. Every retained action preserves the guarantee for the remaining horizon.

Proof. At horizon zero, every possible world must satisfy the declared goal. This is exactly \mathcal W_0, and G\subseteq S supplies safety. At a nonterminal belief, a policy chooses before observing the next response. Its choice applies uniformly across all possible worlds. Each response must exist and remain safe at every intermediate step. After transcript z, Equation (E4) gives precisely the remaining worlds. Induction identifies their winning continuation policies with U(B,a,z)\in\mathcal W_h. These are exactly the conditions in Equation (E5). Conversely, each retained action and the corresponding posterior policies satisfy those conditions. The decreasing horizon forces completion. This also proves the assertion about all first actions. \square

The theorem uses universal path guarantees. Its objective differs from almost-sure reachability under a probability model. Subset constructions for imperfect-information games are established methods. Reif (1984) studies games of incomplete information. Chatterjee and Doyen (2011) explain why belief alone can fail for other stochastic objectives. Here the belief and remaining horizon suffice because they determine all future choices and responses under the stated contract.

Return to the 80-unit service in Example 1. With six rounds remaining, both preparation and a service request are winning first actions under a delivery-or-permitted-cancellation goal. Consider preparation, one pending response, then approval. The next guarded attempt either performs or records local refusal. Refusal keeps the money, service slot, and both parties’ duties intact. A separately authorized owner action can then transfer the unused reservation to a fresh command. The owner performs under its own current authority. The original command retains its identity and refusal history.

The refusal branch uses six rounds:

  1. Preparation completes.

  2. A service opportunity returns a pending response.

  3. The next service opportunity returns approval.

  4. The guarded attempt records local refusal.

  5. The authorized owner transfers the unused reservation.

  6. The owner performs under its current authority.

This path pays 80 once and performs the service once. An adverse judgment instead requires the admitted joint cancellation and its simultaneous releases and discharge. The delivery-only goal is losing when that adverse answer is possible. Returning money alone does not discharge the other party’s performance claim. The example’s mandates and response competence are explicit premises. The finite transition table implements their modeled consequences.

Example 2 (progress without forced approval). A response monitor records the original obligation and its remaining service opportunities. At each required opportunity, it supplies an allowed answer or decreases the counter. At zero, the next opportunity must yield an allowed answer, refusal, expiry, or authenticated failure. The contract determines which of these outcomes can meet the goal.

The counter belongs to the hidden state whenever its value is unobserved. Retries retain the original counter. Resetting it permits indefinite delay and invalidates the finite guarantee. Weak fairness alone also permits arbitrary finite delay. A calendar bound additionally requires a schedule and a duration bound for the complete decision round. If each round, including the controller’s choice, takes at most d time units, h rounds take at most hd. An absent competent response at expiry breaches that contract.

Retaining every action into an eventual winning set would permit an idle loop. Equation (E5) retains idle only while enough rounds remain for completion. In the two-party example, idle is available at horizon seven and excluded at horizon six. The policy preserves freedom within the specified deadline.

The finite reference evaluates Equation (E5) on demand. It also checks complete observation-policy trees for small games and traces all retained choices in the two-party example. These tests distinguish hidden deadlock, intermediate unauthorized effects, lost observation history, false completion, and response-counter resets. The construction requires complete institutional and provider contracts. Large state spaces call for abstractions whose soundness and useful action retention are proved against the same semantics.

The accompanying Programmable Institutions: supplementary construction contains the finite observation controller, the two-party example, and their reproduction tests.

8. What programmability changes

Software can prepare filings, contracts, approvals, and payments before submission. The institution still decides which acts change its authoritative record. The commit boundary connects those two facts. Software can prepare and test an act continuously, while the institution retains sole control of the change that has legal or administrative effect.

The construction gives a governed institution four properties.

  1. Independent reconstruction. An authorized reviewer can reconstruct each accepted change from its retained evidence export. Retrieval, decryption, and digest checks produce explicit results. The replay interpreter has no external dispatch capability.

  2. Institutional autonomy. Each institution keeps its own trusted roots, rules, judgment authorities, and authoritative record.

  3. Append-only correction. A later remedy is a new authorized act. It does not rewrite the earlier event.

  4. Typed human judgment. When a rule cannot decide, it names the question, required evidence, allowed answers, and principals who may answer. The authenticated answer binds one exact pending revision. Its permitted use becomes a dependency of the resulting commit.

These are the properties supplied by the construction. Whether they suffice for a specific institution depends on its law, external effects, and operating process. The boundary applies to private and public institutions. A local commit may consult a compliance state composed across several jurisdictions, but recognition between institutions is a separate construction.

9. Prior art and exact position

The construction uses established authorization, transaction, and workflow methods. Their roles differ: some constrain who may act, some constrain what changes, and some determine whether a process can finish. The comparison below identifies the joint institutional condition studied here.

Reference monitors and capabilities. Dennis and Van Horn (1966) introduced capability-based protection in multiprogrammed systems. Lampson (1971) gave the access-control matrix model. Saltzer and Schroeder (1975) set out complete mediation, least privilege, and economy of mechanism. SPKI/SDSI certificate reduction, proxy certificates, and Macaroons already provide scoped, time-bounded, and attenuating delegation. The present model uses those established ideas at the sole-writer boundary of an institutional record.

Authorization logic. Abadi, Burrows, Lampson, and Plotkin (1993) gave a calculus for distributed access control. PolicyMaker and KeyNote separated policy from application code and evaluated signed assertions. XACML 3.0 returns Permit, Deny, Indeterminate, or NotApplicable and may attach obligations. This paper’s narrower discretion hole names the unanswered question, admissible answers, and answering principals, then binds the authorized answer as a dependency of the state change.

Effects and authority safety. Lucassen and Gifford’s effect systems (1988) track computational effects. Necula’s proof-carrying code (1997) binds code to evidence of a safety property. Miller (2006) and Maffeis, Mitchell, and Taly (2010) establish non-amplification results for object-capability systems. This paper constrains a field-level write footprint by the same delegation chain that authorizes the action and binds both to the receipt.

Concurrency. The current-head comparison is optimistic concurrency control in the sense of Kung and Robinson (1981). Here it also fixes the institutional meaning of the rule result: the permit was computed on the state that the commit changes.

Transactions and workflows. Garcia-Molina and Salem’s sagas (1987) treat long transactions through compensating actions. Workflow-net research, including van der Aalst (1998), studies sound completion and deadlock. The present model adopts staged and compensating action, while separately requiring actor authority and typed judgment before state mutation.

Computational law. Sergot and co-authors (1986) represented provisions of the British Nationality Act as a logic program and left open predicates external. Catala makes statutory defaults and exceptions explicit in a programming language. LegalRuleML standardizes rule interchange. L4 and defeasible-logic research model legal rules, priorities, and arguments. This paper specifies the execution boundary that any such rule representation must cross before authoritative state changes.

Open texture and adjudication. Hart (1961) described the open texture of rules. Dworkin (1977) argued that legal reasoning also involves principles and institutional interpretation. The discretion-hole type records where a chosen formalization stops and who must act next. The institution supplies the legal interpretation.

Tamper-evident evidence. Haber and Stornetta (1991) showed how to time-stamp documents in a hash-linked history. Certificate Transparency later used append-only logs to make certificate issuance publicly auditable. A receipt chain makes mutation history detectable and replayable under stated assumptions. Evidence validity is a separate input.

The local contribution is their composition at one mutation boundary. One commit binds a live delegation chain, an encoded rule result, every required judgment use, an observable write footprint, protected source heads, and retained evidence. The trace theorem attributes each visible write to that boundary. Source contracts connect recorded authority to its institutionally competent origins and actual use stages.

The finite continuation constructions add a completion question to this boundary. They retain all safe completion choices under the same current authority, resource, and affected-rights conditions. Backward reachability and the construction of beliefs are established methods. Their guarantees here are relative to the specified institutional and environmental contracts.

Five companion papers define the surrounding objects. One Entity in Many Jurisdictions defines an entity recognized under several legal contexts and the composed state this boundary may consult (Lorgat 2026a). How Compliance Composes defines state composition (Lorgat 2026b). Lex: A Logic for Jurisdictional Rules defines the applicable rule and typed discretion hole (Lorgat 2026c). Op: A Typed Bytecode for Compliance-Carrying Operations defines execution and its evidence bundle (Lorgat 2026d). The Sovereign Jurisdiction Network defines a network in which each institution controls its own record (Lorgat 2026e). This paper defines the commit boundary, the live authority trace at that boundary, and the replayable receipt.

10. Scope and open problems

The theorems govern changes to one sole-writer institutional record under an encoded rule and recorded authority context. Legal validation supplies the trusted-root designation and fidelity of the rule to its source. Empirical evaluation supplies reliability, latency, and error rates. Distributed histories, external effects, privacy, and human judgment require further results:

  1. Mechanized metatheory. Formalize the syntax, trace semantics, scope algebra, and theorem in at least one proof assistant. Prove decidability of capability validation and rule-outcome checking for a defined fragment.

  2. Distributed concurrent authority preservation. Add conflict-aware scheduling and prove that every accepted distributed history is equivalent to an authorized sequential history, or returns a typed conflict.

  3. External-effect refinement. Give contracts for external primitives and prove that staged execution and compensation preserve named business invariants.

  4. Rule-translation validation. Define a process that binds legal sources, interpretations, tests, and authorized certifiers to each executable rule. Evaluate it on a representative legal corpus.

  5. Judgment governance. Specify quorum, conflict, appeal, revocation, bias monitoring, and reason-giving for human resolutions. Extend the exact request and question binding to these additional governance transitions.

  6. Information-flow security. Prove that receipts disclose no information beyond a declared observer policy while retaining enough evidence for review.

  7. Adversarial systems evidence. Test complete mediation, storage integrity, clock integrity, key compromise, disaster recovery, and log availability in a concrete system.

  8. Comparative expressiveness. Characterize which traces this calculus admits beyond SPKI/SDSI, XACML, and object-capability models.

The trace theorem uses F1–F10. The economic and continuation results add complete resource accounting, faithful rights projections, and an explicit finite environment. These open problems connect the results to distributed, legal, and operational effects.

11. Conclusion

An institution can delegate preparation and execution while retaining authority over each change to its record. The required evidence must remain attached to the act it supports. A current delegation governs the effect, a human answer governs its exact question, and protected observations connect the evaluated rule to the state that changes. The trace theorem establishes this attribution under F1–F10, including observable changes later reversed.

Useful delegation also depends on what remains possible after the act. A common account preserves an allowance across sibling delegates. Rights projections identify the amendment authority required by a change. The finite continuation constructions then retain every next action that can guarantee the stated outcome within the remaining decisions. Under partial observation, the guarantee must hold for every state still consistent with the evidence. Completion requires evidence that every such state satisfies the goal.

These conclusions depend on faithful rules, complete dependencies, competent authority sources, and the stated environmental contract. Retained evidence allows a reviewer with the required access to reconstruct the recorded decisions. Legal validation establishes their authority and effect. External providers remain responsible under their own performance contracts. The program’s authority to proceed is therefore a condition established again at each act, with its outstanding duties and feasible continuations preserved in the same state.

References

Abadi, M., Burrows, M., Lampson, B., and Plotkin, G. (1993). “A Calculus for Access Control in Distributed Systems.” ACM Transactions on Programming Languages and Systems, 15(4), 706–734.

Birgisson, A., Politz, J. G., Erlingsson, U., Taly, A., Vrable, M., and Lentczner, M. (2014). “Macaroons: Cookies with Contextual Caveats for Decentralized Authorization in the Cloud.” Network and Distributed System Security Symposium.

Blaze, M., Feigenbaum, J., and Ioannidis, J. (1999). The KeyNote Trust-Management System Version 2. RFC 2704.

Blaze, M., Feigenbaum, J., and Lacy, J. (1996). “Decentralized Trust Management.” Proceedings of the 1996 IEEE Symposium on Security and Privacy, 164–173.

Centre for Computational Law, Singapore Management University. (2020). L4: A Domain-Specific Language for Law.

Chatterjee, K., and Doyen, L. (2011). “Partial-Observation Stochastic Games: How to Win when Belief Fails.” IST Austria Technical Report IST-2011-0007. https://arxiv.org/abs/1107.2141

Cipriani, M., Goldberg, L. S., and La Spada, G. (2023). “Financial Sanctions, SWIFT, and the Architecture of the International Payments System.” Journal of Economic Perspectives, 37(1), 31–52.

CLS and FNA. (2025). Reimagining Same-Day FX: Exploring the Case for Additional Settlement Cycles. ShapingFX report, 6 March 2025. CLS ShapingFX report.

Committee on Payment and Settlement Systems and Technical Committee of the International Organization of Securities Commissions. (2012). Principles for Financial Market Infrastructures. Bank for International Settlements and IOSCO. https://www.bis.org/publications/principles-financial-market-infrastructures.pdf

Dennis, J. B. and Van Horn, E. C. (1966). “Programming Semantics for Multiprogrammed Computations.” Communications of the ACM, 9(3), 143–155.

Dworkin, R. (1977). Taking Rights Seriously. Harvard University Press.

Du, W., Huang, C., and Scharfstein, D. (2026). “Competing Rails for Cross-Border Payments: Banks, Fintechs, and Stablecoins.” Harvard Business School working paper, 15 February 2026. HBS working paper.

Ellison, C., Frantz, B., Lampson, B., Rivest, R., Thomas, B., and Ylonen, T. (1999). SPKI Certificate Theory. RFC 2693.

European Parliament and Council. (2014). Regulation (EU) No 910/2014 on Electronic Identification and Trust Services.

European Parliament and Council. (2016). Regulation (EU) 2016/679, General Data Protection Regulation.

European Parliament and Council. (2024). Regulation (EU) 2024/1689, Artificial Intelligence Act.

Federal Rules of Evidence. Rule 902(13)–(14), Certified Records Generated by an Electronic Process or System and Certified Data Copied from an Electronic Device, Storage Medium, or File.

Federal Reserve Banks. (2026). Operating Circular 6: Funds Transfers Through the Fedwire Funds Service. Effective 5 January 2026. https://www.frbservices.org/binaries/content/assets/crsocms/resources/rules-regulations/010526-operating-circular-6.pdf

Garcia-Molina, H. and Salem, K. (1987). “Sagas.” Proceedings of the 1987 ACM SIGMOD International Conference on Management of Data, 249–259.

Haber, S. and Stornetta, W. S. (1991). “How to Time-Stamp a Digital Document.” Journal of Cryptology, 3(2), 99–111.

Hart, H. L. A. (1961). The Concept of Law. Oxford University Press.

Lampson, B. W. (1971). “Protection.” Proceedings of the Fifth Princeton Symposium on Information Sciences and Systems, 437–443.

Laurie, B., Langley, A., and Kasper, E. (2013). Certificate Transparency. RFC 6962.

Lorgat, R. (2026a). One Entity in Many Jurisdictions. Companion paper.

Lorgat, R. (2026b). How Compliance Composes. Companion paper.

Lorgat, R. (2026c). Lex: A Logic for Jurisdictional Rules. Companion paper.

Lorgat, R. (2026d). Op: A Typed Bytecode for Compliance-Carrying Operations. Companion paper.

Lorgat, R. (2026e). The Sovereign Jurisdiction Network. Companion paper.

Lucassen, J. M. and Gifford, D. K. (1988). “Polymorphic Effect Systems.” Proceedings of the 15th ACM Symposium on Principles of Programming Languages, 47–57.

Kung, H. T. and Robinson, J. T. (1981). “On Optimistic Methods for Concurrency Control.” ACM Transactions on Database Systems, 6(2), 213–226.

Maffeis, S., Mitchell, J. C., and Taly, A. (2010). “Object Capabilities and Isolation of Untrusted Web Applications.” Proceedings of the 2010 IEEE Symposium on Security and Privacy, 125–140.

Merigoux, D., Chataing, N., and Protzenko, J. (2021). “Catala: A Programming Language for the Law.” Proceedings of the ACM on Programming Languages, 5(ICFP), Article 77.

Miller, M. S. (2006). Robust Composition: Towards a Unified Approach to Access Control and Concurrency Control. PhD thesis, Johns Hopkins University.

Necula, G. C. (1997). “Proof-Carrying Code.” Proceedings of the 24th ACM Symposium on Principles of Programming Languages, 106–119.

OASIS. (2021). LegalRuleML Core Specification Version 1.0. OASIS Standard.

OASIS. (2013). eXtensible Access Control Markup Language (XACML) Version 3.0. OASIS Standard.

Prakken, H. and Sartor, G. (2015). “Law and Logic: A Review from an Argumentation Perspective.” Artificial Intelligence, 227, 214–245.

Reif, J. H. (1984). “The Complexity of Two-Player Games of Incomplete Information.” Journal of Computer and System Sciences, 29(2), 274–301. https://doi.org/10.1016/0022-0000(84)90034-5

Saltzer, J. H. and Schroeder, M. D. (1975). “The Protection of Information in Computer Systems.” Proceedings of the IEEE, 63(9), 1278–1308.

Swift. (2025). Spotlight on Speed. September 2025. https://www.swift.com/sites/default/files/files/swift-spotlight-on-speed_september-2025.pdf

Sergot, M. J., Sadri, F., Kowalski, R. A., Kriwaczek, F., Hammond, P., and Cory, H. T. (1986). “The British Nationality Act as a Logic Program.” Communications of the ACM, 29(5), 370–386.

Tuecke, S., Welch, V., Engert, D., Pearlman, L., and Thompson, M. (2004). Internet X.509 Public Key Infrastructure Proxy Certificate Profile. RFC 3820.

Uniform Law Commission. (1999). Uniform Electronic Transactions Act.

United Nations. (2005). Convention on the Use of Electronic Communications in International Contracts.

United Nations Commission on International Trade Law. (1996). Model Law on Electronic Commerce with Guide to Enactment.

United States. (2000). Electronic Signatures in Global and National Commerce Act, 15 U.S.C. § 7001 et seq.

van der Aalst, W. M. P. (1998). “The Application of Petri Nets to Workflow Management.” Journal of Circuits, Systems and Computers, 8(1), 21–66.