Submitted:
14 October 2026
Posted:
14 October 2026
Read the latest preprint version here
Abstract
As AI-enabled software becomes agentic and evolutive, we formulate a structural sufficiency condition and two execution-level requirements for accountable evolution: fixed-regime execution must remain within a standard Borel representation closed under finite/countable products required by local execution and path construction (S0); governing changes must be executable within the same apparatus they govern (R1); and every admitted act must remain deterministically verifiable from the context and governing specification under which it was admitted (R2). We develop a calculus for interacting executable binary relations. Execution uses an asymmetric epistemic–ontological–eschatological (OEE) structure: an append-only context records admitted events; a partial single-valued realization yields at most one candidate per invocation; a Boolean criterion decides admission; and fixed Axiom 0 records admissible realizations. Standard Borel product closure provides the measurable carrier for local execution, while repeated Axiom 0 defines Eschatological Induction; Zermelo–Fraenkel coding separately enforces rank discipline. Under stated assumptions, we discharge S0, establish common admission semantics for governance and operation under OEE closure, and obtain deterministic verification replay. The fixed-regime path space has a countable/perfect dichotomy. Axiom 0 invokes no global choice selector; that problem appears only after projection to the coordinate-free relational reduct. Fixed-point and recursive-descent results require separate monotonicity and well-foundedness assumptions.
Keywords:
execution calculus
; executable binary relations
; evolutive AI
; self-adaptive systems
; standard Borel spaces
; append-only context
; admission criterion
; deterministic verification replay
; axiom of choice
; forgetful projection
1. Introduction
1.1. Problem and Engineering Motivation
AI-driven software engineering is moving from systems that merely call AI components toward agentic and self-adaptive systems that can reconfigure behavior, policies, tools, and decision logic at runtime. The central execution problem is therefore not only how to generate the next action, but also how to govern changes to the mechanism that decides which actions are admissible while preserving a history from which those decisions can later be verified. Existing engineering patterns can compensate for many local failures, but governance and operational execution are commonly represented by different mechanisms. We therefore ask a narrower formal question: can governing change and ordinary execution be represented by one execution calculus while every admitted act remains attributable to the context and specification under which it occurred?
From extensional to executable abstraction. Classical set-theoretic abstraction deliberately suppresses construction in order to expose extensional structure: a set is characterized by its members and a binary relation by its ordered pairs. This is sufficient for stating what belongs or what may be related, but construction history, provenance, and the condition by which one possible pair becomes an admitted execution fact are not constitutive parts of the relation. This work starts from this representational boundary and asks how to lift a binary relation into an executable abstraction while retaining the classical relation as its extensional reduct.
Research question. Let R ⊆ X × X be a general binary relation and Rx = {y ∈ X : (x, y) ∈ R} a nonempty fiber. When R is non-functional, it may represent several possible successors without containing the constitutive execution information by which one possibility becomes an attributable execution fact. The problem addressed here is therefore not initially one of selecting an element from Rx, but of execution: what additional structure is required so that repeated execution remains representable within a stable measurable class, realization is locally constituted relative to accumulated execution, admission is explicitly governed, and the resulting event remains causally attributable and reproducible from the record? Once that constitutive structure is later forgotten and only the coordinate-free family of nonempty fibers remains, the familiar simultaneous-selection problem addressed by the Axiom of Choice reappears [1] (§4.2).
Two executions can admit the same extensional value under different conditions. In the coordinate-free representation, they correspond to the same element; as executions, they are distinct events, distinguished by the coordinates discarded by U. Formally, e ≠ e′ may hold while U(e) = U(e′). The extensional view thus identifies events that an accountable execution model must distinguish.
Example. Two payments of $50—one admitted after a successful fraud check and the other after an authorized manual override following a failed check—have the same extensional value but are distinct execution events. Their different grounds for admission must remain distinguishable in an audit. The calculus formalizes this difference for arbitrary binary relations, not only for payments.
Construction principle. The construction is guided by one structural and two accountability obligations. First, repeated execution must remain within a representation class closed under the products used to form local admission tuples and execution paths; S0 formalizes this requirement. Second, for a fixed invocation, realization must be single-valued before commitment and admission must be evaluated against the accumulated execution context, providing local determinacy and causal attribution. Third, correctness-relevant governing change and the specification lineage needed to verify admitted acts must remain inside the same execution history, corresponding to R1 and R2. For an internal abstraction, C therefore does more than preserve provenance: it supplies the endogenous resolution basis on which the specified realization procedure ωτ determines which realization, if any, is consistent with the execution accumulated so far; τ then determines whether that realization is admitted. At system level the same C couples abstractions because every admission changes the resolution and admission context seen by later invocations. These obligations lead to the executable abstraction Aτ = (R, ωτ, τ), the append-only context C, and Axiom 0 as the local rule by which relational possibility becomes an attributable execution fact.
Section 2 shows that transition structures can represent what may happen while the mechanism that resolves possibility into one accountable execution step is often implicit, external, or represented elsewhere. The present calculus makes that resolution constitutive by retaining the accumulated context, realization procedure, and admission criterion inside the executable object.
This gap sits at the intersection of several high-priority open directions in contemporary software-engineering roadmaps toward 2030. The broad SE2030 roadmap identifies AI and software engineering, verification and validation, software evolution, and trustworthy automatic programming among the field’s core open research areas [2]. A 2026 research agenda for self-adaptive robotics specifically calls out safe runtime reconfiguration, verification under uncertainty, and testing challenges involving nondeterminism and safety risk [3]. A separate 2026 roadmap for AI-driven software engineering emphasizes versioned policy/context bindings, provenance, reviewability, accountability, and replay [4]. The present paper does not claim to solve those broader agendas. It isolates one execution-level issue common to them: when a correctness-relevant alternative or governing change is resolved, the mechanism that resolves it must not remain an unrecorded second system if the resulting execution is to be attributable and replayable.
Structural sufficiency requirement (S0 — Borel execution closure). Before choosing a particular execution construction, we require the abstract system to be strong enough to support the products and iteration used by execution. For every fixed specification-and-invocation regime r, the reachable execution objects must admit a standard Borel coding stable under the finite and countable products required to form local admission tuples and execution paths, and the complete finite/infinite outcome space must be Borel in the corresponding coding. Standard Borel spaces are used because their finite and countable products remain within the same measurable class, providing the closure required by local execution products and by the path spaces generated through repeated admission. We call a system satisfying this requirement Borel-sufficient for the analysis in this paper. S0 is a representational sufficiency condition: it does not assert that every source-domain object is intrinsically Borel, and it introduces no probability measure.
Target requirements. We formulate R1 and R2 as execution-level requirements for the accountability notion studied here, rather than as universal conditions on all adaptive systems. R1 — Endogenous governance and evolution: the mechanism that governs execution, including any correctness-relevant change to the system’s own ontology or admission criterion, must itself be executable inside the same formal apparatus and recorded in the same history; within this calculus, a governing change that bypasses that apparatus would remain outside the replayable execution history. R2 — Deterministic executional reproducibility: every admitted act must remain verifiable from the recorded prefix, the recorded realization, and the immutable specification versions in force at admission; without those preserved inputs, the execution record alone cannot deterministically establish the basis of the admission. For evolutive AI, these requirements provide a formal execution basis for safety mechanisms concerned with accountable self-revision: governing changes, admission decisions, and their consequences remain inside the same replayable execution record. The calculus does not prescribe the substantive content of a safety policy; it provides the execution structure in which such a policy can be applied, revised, and audited. R2 also makes admitted history usable as deterministically verifiable evidence for later learning or analysis; it is not a learning algorithm in itself.
Separation of obligations. S0 concerns closure and measurability of the execution representation; R1 and R2 concern accountability of governance and admitted history. The construction below is designed to satisfy all three. Section 3.1 and Section 3.2 expose the local OEE factorization, §4.4 discharges S0 for the fixed-regime finite-branching execution space, §§4.3.3 and 4.5.6 establish R1 under OEE closure, and §4.3.5 establishes R2 under the stated replay assumptions.
Representational diagnosis. The obstacle studied here is not the expressive power of Zermelo–Fraenkel set theory (ZF), which is used throughout the formal development, but the executional information suppressed by the coordinate-free reduct. A set element records value and membership without executional provenance; a relation R ⊆ X × X records possible pairs without, by itself, identifying the accumulated context, realization procedure, or criterion that made one pair an admitted execution fact. The classical relation remains a valid reduct; the calculus asks what must be added so that the relation can participate directly in causally attributable execution.
How to read Table 1. The correspondence is an executional lifting, not an identification of sets with sequences and not a replacement of ZF. The payload of an event is its extensional content and the epistemic–ontological–eschatological (OEE) address distinguishes execution instances. Thus e ≠ e′ may hold even when U(e) = U(e′). An extensional set records what belongs; C records how addressed execution facts were admitted and ordered. Entry into the executable context is produced by admission; its forgetful image recovers the corresponding extensional value. Section 3.1 and Section 3.2 formalize this lifting and its projection back to the relational reduct.
Resolution: one executable abstraction. For one relation, the primitive execution object is the executable abstraction Aτ = (R, ωτ, τ), evaluated against an execution context C. Operationally, the ontological component supplies a partial, deterministic realization procedure for a fixed invocation, while the eschatological component supplies the Boolean admission criterion evaluated against the complete accumulated context. C records what has been admitted; ωτ determines what can be realized for the invocation; τ determines whether that realization may be admitted. These are constitutive roles, not axes of physical time, runtime state, or software architecture. Their asymmetry is expressed through the typed execution products of §3.1.7 and represented in ZF through the rank discipline of §3.1.
Resolution: dynamics and recursion. Axiom 0 is the local dynamics of one executable binary relation. For a fixed invocation, ontological realization yields at most one candidate; if that realization exists and the eschatological criterion holds, Execute records it through the deterministic event constructor Rec and extends C by one event. Otherwise that invocation contributes no extension. Repeated application of this partial local rule is Eschatological Induction, generating executable history from C0 = ∅. When τ has a finite specialization hierarchy, recursion is induced by that specification itself: evaluation descends through specialized levels, lower-level admissions build the context required by enclosing levels, and the enclosing relation is re-evaluated over the enriched context on return. Recursion depth is therefore the executional image of eschatological specification depth, not an independent execution primitive.
From one abstraction to a system. A software or AI system is represented as a family {Aτi} of executable binary relations sharing one execution context C. Axiom 0 governs one invocation at a time. An admission by Aτi extends C and thereby changes the context against which other active abstractions are subsequently evaluated; interaction is therefore mediated by the shared context rather than by a second admission semantics. Read in Mesarović–Takahara input–output terms, an admitted output of one executable relation becomes part of the effective input context of the others through C: Aτi → C → Aτj. The result of one admission can therefore enable, preempt, or otherwise change the admissibility of another abstraction. This separates vertical dynamics—recursive specialization within one eschatological hierarchy—from horizontal interaction among abstractions through C. §§4.3.3 and 4.3.5 show, under the stated closure and replay assumptions, that governing and operational acts share one admission semantics and that admitted execution supports deterministic verification replay. Together these properties support accountable specification change and permit the evolutive regime defined in §4.5.6.
Higher-arity representation. Binary relations are the elementary execution representation used by the calculus, not a claim that real problems are intrinsically binary. Higher-arity structure can be represented in this calculus by binary incidence relations over an explicit relation-instance carrier; the representation is lossless when that carrier retains the full relation instance, as in the hidden-variable construction, whereas naive pairwise projection is not generally lossless [5,6,7]. Section 2.1 and Section 3.1.5 provide the representation details. The calculus therefore uses binary executable abstractions as composable execution primitives without restricting the arity of the problem being represented.
Relationship to prior publications. Zero Tier Execution Substrate (ZTES) [8] is a concrete architectural realization from the same research program, while the companion AI paper [9] applies a summarized OEE decomposition to guardrail incompleteness and evolutive consensus. The present manuscript treats the calculus itself as the object of study and derives its record/specification discipline, admission semantics, projection/Choice boundary, governance and replay results, and fixed-regime execution-space consequences.
1.2. Contribution
The paper makes five contributions, following the construction introduced in §1.1.
(i) Structural sufficiency, executable lifting, and OEE separation. The paper states S0 as a Borel execution-closure requirement and then lifts bare extensional values and relations into an execution representation based on addressed events accumulated in a shared context. It formalizes C, ωτ, and τ as constitutively distinct roles—record, ontological realization, and admission criterion—represented by strict ZF rank separation together with explicit versioned specification, while recovering the ordinary set element and binary relation as forgetful reducts.
(ii) Three-stage execution, Axiom 0, and Eschatological Induction. For a fixed invocation, ontological realization yields at most one candidate, the eschatological criterion returns a Boolean admission judgment, and the fixed Axiom 0 kernel records the event only when that judgment is true. These operational stages express the three asymmetric OEE roles. Repeated application of the same local kernel is Eschatological Induction; when τ is hierarchically specialized, recursive depth is induced by the depth of that eschatological specification.
(iii) Choice-free local admission and the classical projected problem. Execute never selects a member from an arbitrary family of nonempty sets: for a fixed invocation the realization is single-valued when defined and τ is Boolean. The classical choice problem reappears only after the execution coordinates and criterion are forgotten and the abstraction is read as a family of relation fibers (§4.2).
(iv) Systems of interacting abstractions and endogenous governance. A system is a family of executable abstractions sharing one C. Each application of Axiom 0 is local to one abstraction, while admissions interact horizontally by changing the context against which the others are evaluated. Under OEE closure, governing and operational acts share one admission semantics (§4.3.3); a governing abstraction may then admit a new ontology or criterion version through that same mechanism (§4.5.6).
(v) Borel execution closure, deterministic replay, and global execution-space consequences. Under the fixed-regime finite-branching assumptions, §4.4 proves the local standard Borel product closure and Borel outcome-space condition required by S0 and derives the countable/perfect dichotomy. Independently, every admitted event is deterministically verifiable from its recorded prefix, realization, and immutable specification versions (§4.3.5), establishing R2 under the stated assumptions. Section 4.4 and Section 4.5 separately characterize monotone fixed points, finite recursive descent, and regime terminality.
1.3. Reading Conventions
Seven facts hold throughout and are useful to fix before the formal development:
• Cn is the finite append-only sequence of everything admitted so far; n counts admissions, not clock ticks.
• S0 is a fixed-regime representational requirement: the coded execution carrier must remain in a standard Borel class under the products used by local execution and path construction; §4.4 proves this under the finite-branching assumptions stated there.
• ωτ is partial and single-valued for a fixed invocation; once a realization exists, τ is Boolean. Failure at either stage preempts the invocation and writes nothing.
• Admission is evaluated against the complete recorded prefix Cn. Sequence position records serialization; direct causal dependence is determined from the admission condition, not from adjacency alone.
• The classical set element and binary relation are forgetful projections of the executable structure, not objects from which its omitted execution structure is reconstructed (§4.2).
• Recursion is vertical, induced by one criterion hierarchy; interaction is horizontal, produced when admissions by one abstraction change the shared C seen by others.
• Axiom 0 is local to one executable abstraction at one invocation: it determines at most one admitted event for that relation and context. A system may contain many such abstractions sharing the same C.
The notation used throughout the formal development is summarized in Table 2.
1.4. Scope and Paper Structure
Scope. Axiom 0 answers a local execution question: for a fixed invocation and finite prefix Cn, does a realization exist and, if so, is it admissible now? Each reached τ-evaluation is assumed effective and terminating (§3.2.3). The local admission step does not decide whether a currently preempted abstraction will ever be admitted or whether the system as a whole will terminate.
Global continuation is a separate question. Re-evaluation after context growth is a new invocation over a new prefix, and terminality is defined only relative to a fixed specification-and-invocation regime (§4.5.5). Fixed-point existence, persistent continuation, finite recursive descent, and regime terminality are therefore analyzed separately in §§4.4–4.5 rather than being built into the local admission test.
Borel scope. S0 is evaluated regime by regime. The local product-closure statement concerns the coded reachable execution representation, not a claim that every source-domain carrier is itself a standard Borel space. The global Borel result additionally uses the fixed-regime finite-contribution/finite-branching assumptions of §4.4. An admitted specification change ends one regime and induces a new regime whose execution space is analyzed separately.
Replay scope. Because preemption produces no event, deterministic verification replay covers admitted execution only. It verifies every recorded admission from the preserved prefix, recorded realization, and immutable specification versions in force; it does not claim to reconstruct every unavailable or negatively evaluated candidate unless a separate abstraction has admitted such an evaluation record into C.
Specification scope. The substantive content of the ontology and eschatological criterion belongs to software specification and design; the calculus governs their correct execution, not their substantive design. Design need not remain external, however: when delegated to a governing abstraction, a new ontology or criterion version is itself produced and activated through ordinary admission (§4.5.6). Historical precedents and engineering correspondences are positioned in §§2 and 6 rather than used as premises of the formal results.
Section 2 establishes the related-work boundary and precise research gap. Section 3 states the formal method, constructs the OEE execution structure and Axiom 0, and makes the asymmetric three-stage execution carrier explicit. Section 4 presents the derived results: context and interaction, the projection/Choice boundary, governance and deterministic replay, discharge of S0 through fixed-regime Borel execution closure, and the separate conditions for order, fixed points, termination, and evolutive change. Section 5 gives the realization contract, implementation interface, and running example; Section 6 documents operational correspondence and historical precedent; Section 7 discusses interpretation, boundaries, and open problems; and Section 8 concludes. Appendix A and Appendix B provide the detailed rank and projection arguments.
2. Related Work, Structural Positioning, and Research Gap
This section establishes the paper’s structural position before the formal development. The comparison is analytical rather than a systematic literature review: it selects canonical formalisms representing relations, purposive systems, process and concurrency, discrete-event execution, and event-sourced history in order to identify the execution boundary addressed here. The comparison is not a ranking of prior formalisms; each solved a different problem. The narrower question is which of three execution roles—accumulated record, realization procedure, and admission criterion—are constitutive in each formalism and which are supplied elsewhere.
2.1. Historical and Formal Precedents
Leibniz and Tarski supply two early conceptual boundaries relevant here. Leibniz’s principle of sufficient reason gives a philosophical precursor of an explicit condition on actuality [10,11], while Tarski separates truth evaluation from the language being evaluated and later supplies the monotone fixed-point theorem used under the restricted conditions of §4.5.4 [12,13]. Neither contribution is treated as an execution calculus; their relevance is structural.
Turing [14,15,16]. Turing’s 1937 machine model formalized mechanical computation as a rule-governed sequence of local transitions. His 1939 ordinal-logics paper made an external decision boundary explicit through the o-machine: the decision delegated to the oracle is outside the ordinary machine table, and Turing states only that the oracle “cannot be a machine” [15]. His 1952 morphogenesis paper studies a structurally different mode of determination: locally defined reaction–diffusion processes interacting through a shared medium can generate global form endogenously [16]. We make no historical claim that Turing intended morphogenesis as a revision of the oracle construction or as a theory of execution. The correspondence is structural: the former makes an external decision boundary explicit; the latter demonstrates mathematically how global organization can arise from interaction within a shared structured domain. In the terminology of the present calculus, this is a functional precursor to endogenous, context-mediated resolution, but it does not provide an append-only causal record or an explicit admission criterion.
Saratov nonlinear-dynamics reconstruction and synchronization. A closely related domain-specific precedent is the Saratov tradition of reconstructing and synchronizing nonlinear dynamical systems from observed or coupled trajectories. Bezruchko and Smirnov constructed nonautonomous differential equations from experimental time series and explicitly connected reconstruction with prediction, qualitative dynamical description, attractor dimensions, and Lyapunov exponents [17]. Subsequent work reconstructed time-delay systems from chaotic realizations [18], recovered delayed-feedback equations through low-dimensional representations of otherwise high-dimensional dynamics [19], reconstructed externally driven time-delay systems together with their delay, inertial, nonlinear, and forcing parameters [20], and extended the approach to recovery of coupling architecture and element parameters in networks of time-delay oscillators [21]. A particularly close structural analogue is provided by Koronovskii, Moskalenko, and Hramov [22], who analyze generalized synchronization in coupled chaotic systems through the conditional Lyapunov spectrum: negativity of the largest conditional Lyapunov exponent is a criterion for the emergence of the synchronized regime, which is then exploited in a noise-resistant secure-communication scheme. Retrospectively, this separates a dynamical space of possible response regimes from an explicit criterion that determines when one regime is realized as synchronized behavior. The correspondence to the present calculus is structural rather than historical. These works provide domain-specific mechanisms for reconstructing or resolving dynamical organization and for testing the realization of a synchronization regime, but they do not provide an append-only accountable execution context, separately versioned ontological and eschatological specifications, a common admission rule for operational and governing acts, or deterministic verification replay. The present calculus abstracts this broader pattern into an explicit computational execution semantics in which accumulated context, realization, and admission remain distinct but interacting constitutive roles.
Relational, process, concurrency, and event-record formalisms contribute complementary pieces. Codd isolates the relation as a data model [23]; Milner and Hoare make interaction and alternative continuation first-class [24,25]; Petri, Dijkstra, and Lamport formalize enabling, nondeterminism, and causal ordering [26,27,28]; event sourcing and Command Query Responsibility Segregation (CQRS) make durable history central [29,30]. Table 3 states the narrower distinction relevant here: none of these components alone makes the particular combination of accumulated record, explicit realization, and history-conditioned admission criterion constitutive of one executable object.
Mesarović–Takahara. Their General Systems Theory defines a general system as a relation on abstract component sets; when those component sets are partitioned into input and output objects, the same system is represented as an elementary input–output relation S ⊆ X × Y [31]. Elementary systems may be composed into nonelementary, hierarchical and multilevel systems [32], and Takahara later formalized a complex system as a relation on component systems while retaining an ordinary input–output relation at the global level [33]. This relational program has remained an important formal thread of general systems theory and a basis for later developments [34]. The present comparison builds on that relational and hierarchical systems ontology and adds the specific execution semantics studied here, which is not explicit in the original framework: each elementary relation is lifted to an executable abstraction, and an admitted output is written into the shared context C, where it becomes part of the context against which other abstractions realize and admit their own outputs. Thus relation-to-relation interaction is operationally mediated by C, so the admission of one abstraction can change the admissibility of another.
Binary representation of higher arity. Constraint-satisfaction and database research provides a direct precedent for treating higher-arity structure through interacting binary relations. Bacchus and van Beek describe the standard hidden-variable construction and note that any finite-domain non-binary CSP can be translated into an equivalent binary CSP; an n-ary constraint is replaced by one relation-instance variable and one binary compatibility relation to each participating variable [5]. Dubois later formalized this transformation in Coq and proved solution equivalence in both directions [6]. Dechter’s decomposition results also show why the auxiliary relation-instance structure matters: decomposition of a bare n-ary relation into a tree of binary relations over its given structure is exact only when the relevant decomposability conditions hold; otherwise the binary tree is an approximation [7]. These results support the binary-relational representation adopted here without implying that arbitrary higher-dimensional problems are losslessly reducible by pairwise projection alone.
Discrete Event System Specification (DEVS) and Tocher are the closest execution precedents in this part of the comparison. DEVS supplies explicit discrete-event transition semantics [35], while Tocher’s three-phase kernel repeatedly re-tests conditions as the execution situation changes [36]. Both exhibit admission-like behavior; the distinction studied here is the explicit separation of a versioned realization specification and a history-conditioned criterion over an append-only execution context.
Borel-measurable probabilistic program semantics. Batz et al. develop deductive verification foundations for continuous probabilistic programs over the standard Borel σ-algebra on the program-state space, define Borel-measurable expectations, and explicitly use n-fold product Borel structures for multidimensional integration and preservation of measurability [40]. This provides a contemporary software-verification precedent in which measurable product structure is constitutive to rigorous program semantics. Its role is nevertheless different from S0: their measurable structure supports expectation-transformer semantics, Lebesgue integration, and loop verification, whereas the present calculus requires product closure of the execution carrier and a Borel fixed-regime outcome space so that asymmetric realization, Boolean admission, Axiom 0 execution, and Eschatological Induction remain within one accountable execution class. Their semantics does not introduce the append-only OEE record, endogenous governing change, or deterministic verification replay studied here.
ZTES. Semantic closure is demonstrated there for one concrete architecture (§6.1): append-only record, criterion inside the component, and governed admission. Admissibility is axiomatic in that realization; the present paper develops a substrate-agnostic calculus and an explicit formal account of the admission structure used by that architecture.
Taken together, the comparison summarized in Table 3 identifies a common boundary rather than a catalogue of deficiencies: prior traditions provide the relevant ingredients, but not the same executable combination of an append-only accumulated context, an explicit realization procedure, and a history-conditioned admission criterion that may itself be revised through admission into that record.
Within this comparison, the present calculus retains set elements, relations, state views, processes, and architectures as reducts or derived views; its additional structure is the local execution rule that turns relational possibility into an attributable admitted fact.
2.2. Shared Representational Boundary
As Table 4 shows, the calculus begins from the executable abstraction and treats the other representations as reducts or derived views obtained by forgetting or projecting parts of the execution structure. In particular, forgetting explicit admission and execution structure recovers the binary-relational reduct, while forgetting an admitted event’s execution coordinates recovers its extensional payload (§4.2).
2.3. Synthesis, Research Gap, and Precise Novelty
Across the surveyed traditions, the relevant pieces appear separately. Relational and algebraic formalisms provide structure; purposive systems theories provide goal and hierarchy; process and discrete-event formalisms provide transition and interaction; event-sourced architectures provide durable history; measurable program semantics provide analytically controlled state/function spaces; Turing’s oracle construction exposes an external decision boundary while morphogenesis demonstrates endogenous organization through interaction. None of these comparisons is used as a premise of the calculus. The research gap is therefore not the absence of these individual ingredients, but the absence, within the comparison class established in §2, of their constitutive integration in one executable object.
Within this comparison class, no surveyed formalism combines all three obligations studied here. S0 requires an execution representation that remains in a standard Borel class under the products needed by local execution and fixed-regime path construction. R1 requires correctness-relevant governing specification changes to use the same admission semantics as ordinary execution. R2 requires each admitted act to preserve enough execution and specification lineage for deterministic verification replay. Concretely, no surveyed formalism makes all of the following constitutive parts of one executable object in the sense defined here: measurable execution closure, an append-only accumulated context, an explicitly identified ontological realization, a history-conditioned admission criterion, governing specification changes represented through the same admission mechanism, and replayable immutable lineage. This is a claim about the comparison class established in §2, not about every formal system.
These obligations address distinct boundaries. Borel-measurable program semantics can preserve measurable structure through products, integration, and loop reasoning [40], but that does not by itself make realization, admission, provenance, and governing change constitutive parts of one accountable execution object. Conversely, recursion or succession notation alone does not establish that a product-constituted successor remains inside the same analytically controlled execution class. Separately, when admission is external to the record, the reason a possibility became an admitted execution fact is not constitutively retained; and when governing change is handled by a second mechanism, its rationale can leave ordinary execution history. The construction below addresses these three boundaries through S0, R1, and R2 respectively.
What is new, stated precisely. The contribution integrates three obligations in one executable construction: (i) under the stated fixed-regime finite-branching assumptions, a standard-Borel execution representation closed under the products required by local execution and fixed-regime paths (S0); (ii) an append-only OEE admission structure in which governing specification change uses the same Axiom 0 semantics as ordinary operation (R1); and (iii) immutable event/specification lineage supporting deterministic verification replay (R2). The executable abstraction retains a single-valued realization procedure ωτ for each fixed invocation and an explicit criterion τ evaluated over the accumulated context. Local admission introduces no independent choice operation: Execute evaluates the specified realization and criterion directly. Only after the criterion and execution coordinates are forgotten does the classical relation-fiber selection problem reappear (§4.2.5). The same structure represents recursive specialization and governed self-revision within execution rather than through a separate admission semantics. Within the accountability model studied here, correctness-relevant resolution, governing change, and later verification therefore remain attributable to the execution record.
Specification and execution. The content of the ontology and eschatological criterion belongs to system design; the calculus governs their correct execution, not their substantive design. When specification itself is delegated to a governing abstraction, however, the resulting ontology or criterion change is an ordinary attributable admission and becomes effective through the same execution mechanism.
3. Materials and Methods
This study is a constructive and deductive formal analysis rather than an empirical performance benchmark. Starting from S0, R1, and R2, it defines an executable abstraction and a compatible ZF representation, derives local and system-level properties by proof, analyzes the fixed-regime space of admissible executions, and then examines realizability through software mappings and comparison with established systems formalisms. The engineering examples in Section 5 and Section 6 illustrate correspondence with established software mechanisms and possible implementation mappings; they do not provide empirical validation of the theorems.
The formal results are conditional on explicitly stated assumptions. Local admission concerns a fixed invocation over a finite recorded prefix and assumes effective, terminating operational interpretations of ωτ and τ on their respective domains. Deterministic verification replay additionally requires append-only C, immutable versioned specification references, deterministic interpretations, and preservation of the realization originally tested. The governance result requires OEE closure. The S0 result and fixed-regime path-space analysis require a fixed specification-and-invocation regime, finite candidate contribution at each finite node, and the standard coded execution representation developed in §4.4; product closure is a property of that representation rather than of every source-domain carrier. Theorem 3 further requires monotone set-factored admission, whereas Theorem 4 requires a supplied well-founded measure that strictly decreases on recursive admission. None of these conditions is treated as a universal property of executable systems.
Generative AI tools assisted with manuscript language refinement, structural and consistency checks, technical formatting, and exploratory literature discovery. The authors reviewed and independently verified the formal arguments and cited sources. Tool and version details are reported in Acknowledgments.
3.1. OEE Execution Structure and Rank Representation
This subsection gives a ZF representation of the three constitutive OEE roles as strictly separated construction levels. The representation supplies the type discipline used by the later projection, admission, governance, and replay derivations; it is a construction within ZF, not a new foundation or an independent source of those results.
3.1.1. Foundational Position
Axiom 0 operates on three constitutive roles whose order of construction is represented here in the cumulative hierarchy of ZF. The rank argument does not create those roles; it makes their separation precise. Together with explicit versioned specification, that separation prevents the execution record from being confused with the specifications that govern it and supports the non-substitutability claims used later. Section 4.2 and Section 4.3 then use this structure to derive the projection, governance, and replay results. Appendix A gives the full coding details.
The asymmetry precedes the rank calculation. C, ωτ, and τ do not name three comparable observables; they name three constitutive roles ordered by dependence. C is the realized epistemic record; ωτ specifies the ontological realization presented for admission and may, for an internal abstraction, derive that realization from the accumulated record; τ is specified over the realization and the accumulated context and decides whether a new event is admitted. The rank assignment below is the ZF representation of this order of construction, not the conceptual source of it.
Only strict level separation is conceptually relevant. Exact numerical offsets are encoding-dependent, and operational interpretations are distinguished from the specification objects whose ranks are compared. Appendix A.1 gives the coding and Appendix B.2 locates the bundled abstraction above its highest-ranked specification component.
3.1.2. Epistemic, Ontological, and Eschatological Objects
Before assigning ranks, the calculus distinguishes three constitutive roles that must be kept distinct: the record of admitted facts, the specification that determines what can be realized, and the criterion that determines what may be admitted. Their operational interaction is introduced in §3.2; this section first fixes their meanings and then shows that the separation can be represented consistently by a strict ZF rank ordering.
• The epistemic level is carried by admitted event records in C. Their positions preserve serialization, while causal dependence is determined from admission conditions as developed in §4.1.4–§4.1.5. The aggregate sequence C is a container of these records, not the object compared by Theorem 1.
• ⌜ωτ⌝ is the constitutive ontological specification of Aτ. Its operational interpretation ωτ(C) yields at most one realization for a fixed invocation when defined. The specification is not a projection of C; a later specification version may be introduced only by an explicit admitted specification act (§4.5.6).
• ⌜τ⌝ is the constitutive eschatological specification. Its operational interpretation τ(C, ω) is total and Boolean once an ontological realization ω exists. A later criterion version likewise requires an explicit admitted specification act rather than being inferred implicitly from C.
Notational convention. Operational formulas from §3.2 onward use ωτ and τ as shorthand for the interpretations of the active immutable specification versions ⌜ωτ⌝ and ⌜τ⌝. Rank statements always refer to the specification objects. τ’s operational domain is written E^{<ω} × Ω because order and position in the finite context may be read by the criterion; Appendix A uses the corresponding raw coding over (X × X)^{<ω} × Ω.
3.1.3. Rank Structure
Let X be the non-empty rank-homogeneous coding domain constructed as in Appendix A.1, and let R ⊆ X × X be a binary-relational reduct. The rank comparison concerns specification codes, not the operational functions obtained by interpreting those specifications. For a fixed active specification version, write ⌜ωτ⌝ and ⌜τ⌝ for the ontological and eschatological specification objects; their operational interpretations are denoted ⟦ωτ⟧ and ⟦τ⟧. Later operational formulas suppress the brackets when no rank claim is being made.
• Epistemic record level. Let RecX = X × X be the event-record carrier. The execution context satisfies C ∈ RecX^{<ω}. Each admitted event e ∈ C has rank ρ(e) = ρ(X) + 1 under the rank-homogeneous coding convention. The rank theorem orders this event-record type relative to the specification types; it does not assert that the aggregate sequence object C itself has lower set-theoretic rank than its specifications.
• Ontological axis ⌜ωτ⌝. The ontological specification is encoded one construction level above event records, with ρ(⌜ωτ⌝) = ρ(X) + 2 under the convention of Appendix A. Its operational interpretation ⟦ωτ⟧ : C ⇀ Ω is a partial, single-valued realization procedure for a fixed invocation; that function is not the object whose rank is compared in Theorem 1.
• Eschatological axis ⌜τ⌝. The criterion specification is encoded one level above the ontological specification, with ρ(⌜τ⌝) = ρ(X) + 3 under the tagged coding of Appendix A. Its operational interpretation ⟦τ⟧ evaluates a realized candidate against the accumulated context and returns a Boolean value. The positive extension Γτ+ is a further derived set and is not identified with the specification code itself.
Theorem 1 (ZF representation of OEE level separation). Under the coding of Appendix A.1–A.2, every admitted event record e ∈ C satisfies ρ(e) < ρ(⌜ωτ⌝) < ρ(⌜τ⌝).
Proof. Appendix A.1 first replaces any source carrier, if necessary, by a definably rank-homogeneous tagged copy and then uses the Kuratowski pair coding for event records. The ontology and criterion specifications are represented by tagged codes placed at successive construction levels above the event-record type. Hence the stated strict inequalities hold. Their exact numerical offsets are encoding-dependent and are not used beyond this strict order. ∎
Rank separation is a representation result, not an independence theorem: tagged coding can preserve a constitutive ordering only after the roles to be represented have been specified. The substantive non-substitutability used by the calculus therefore rests on explicit, versioned specification, while Theorem 1 shows that this role separation has a consistent strict-rank representation in ZF.
Appendix A gives the full set-theoretic coding, the homogeneous-square construction used for iterative self-composition in this calculus, and the compositional reason the ontology and criterion occupy successive specification levels. No additional interaction primitive is introduced beyond Axiom 0: §4.1.3 gives its repeated application as Eschatological Induction, and §4.2.3 names the resulting contextual execution relation explicitly.
3.1.4. Dependency and Order of Construction
Four consequences follow from rank separation together with explicit versioned specification, not from rank alone and independently of any operational reading of Axiom 0:
C1. The active criterion is not implicitly derived from C. The specification ⌜τ⌝ occupies a different construction level from admitted events and is supplied as an explicit versioned parameter of the abstraction. C may contain an address to that version, and a governing abstraction may later admit a new criterion version, but the current criterion is not inferred merely from whatever facts C happens to contain.
C2. The active ontology is not implicitly derived from C for the same reason. The constitutive specification ⌜ωτ⌝ is explicit and versioned, while its operational interpretation may use C to produce a realization. External semantic interpretations of admitted execution are a different matter and are treated as derived views in §4.3.4.
C3. Ontological and eschatological specifications are independently specifiable. The criterion may evaluate a realization produced under the ontology, but changing either specification requires its own explicit specification version; neither role substitutes for the other.
C4. Axiom 0 is the local interaction law of the full executable structure, not a property available from the coordinate-free reduct R alone. Execute(Aτ, Cn) = en+1 states the point at which the shared record C, the operational interpretation of the active ontology, and the operational interpretation of the active criterion jointly determine admission. Every executable abstraction therefore has a binary-relational reduct, but no converse claim is required that an arbitrary bare relation uniquely determines such an executable lifting.
Remark (orthogonality). Orthogonality here is a distinction of constitutive role and construction level, not pairwise set-disjointness. The record, ontological specification, and criterion specification interact at every admission while remaining non-substitutable roles. Evolution changes a role only by admitting a new specification version, not by collapsing that role into the record.
3.1.5. Composite Coordinates and Event Forms
Formal event representation. The conceptual map of §1.1 is now made exact. Every admitted event is an ordered pair e = ⟨coord(e), payload(e)⟩ with coord(e) = (idesh,1, …, idesh,k, idont, idinst). The payload preserves extensional content; the coordinate preserves specification lineage and the admitted instance. idesh and idont are immutable specification addresses fixed before admission, while idinst is assigned only when the event is appended. Database normalization is an implementation mapping rather than a premise of the calculus; §3.2.6 states the schema assumptions used when a 6NF realization is desired.
The key distinguishes three levels of specification, existentially dependent on one another. A criterion is represented in C by an eschatological specification event carrying an idesh address; an ontology is represented by an ontological specification event carrying (idesh, idont); an execution of that ontology carries the full address. Each specification address resolves to an immutable specification version. Later evolution creates and activates a new version/address rather than mutating the object previously referenced. Each admitted execution event also contains, or losslessly references, the realized candidate needed to re-evaluate its original admission. These events therefore preserve the information required for verification replay without embedding higher-rank specification objects themselves at the event-record level.
The three coordinates are not of one kind. idont and idesh are pre-admission addresses referring to already registered specification versions; idinst is assigned only when admission occurs and records the position of the resulting event. For every operation that requires a canonical least address, fix once and for all an injective coding code : ℕ^{<ω} → ℕ and compare addresses by the natural order of their codes. This supplies a definable well-order without relying on ordinary lexicographic order over variable-length tuples.
A system is a family of executable abstractions sharing one record C; each abstraction comprises one binary-relational reduct together with active ontological and eschatological specification versions. Every abstraction has the same absolute execution origin C0 = ∅, but once abstractions participate in a system they do not maintain isolated execution histories: their admitted events extend the shared C. This shared context is the operational coupling among the relations. If Aτi admits e, then e enters C and every other active abstraction Aτj subsequently evaluates its realization and criterion against that enriched context. In this precise sense the output of one executable relation becomes part of the effective input of the others, Aτi → C → Aτj, and one admission may enable, preempt, or otherwise alter a later admission. Higher arity does not require a different execution primitive: as summarized in §1.1 and grounded in §2.1, an n-ary relation can be represented by binary incidence relations coupled through an explicit relation-instance carrier. Those binary relations may then be lifted to executable abstractions and composed through the same shared C. Arity belongs to relational representation; interaction belongs to execution; the shared record composes the system.
3.1.6. Eschatological Specialization
For criteria compared within a common abstraction/ontology regime (or after an explicit embedding into a common context domain), define the successful-admission domain AdmDom(τ) = {C : Collapse(Aτ, C)}. The strict eschatological specialization relation is then defined by proper inclusion of these domains:
τ'⊏τ ⇔ AdmDom(τ') ⊊ AdmDom(τ).
Because ⊏ is proper set inclusion on successful-admission domains, it is irreflexive, asymmetric, and transitive. The purpose decomposition used by an executable abstraction is required to be finite; hence every descending specialization chain τleaf ⊏ … ⊏ τ terminates at a leaf. This does not assert that the leaf is satisfiable in the current context; satisfiability remains an execution-time question settled by Axiom 0. The specialization chain forms the eschatological hierarchy used by the recursive execution of §4.1.3.
Executional consequence. The eschatological hierarchy is also the recursion hierarchy of the abstraction. A composite criterion is evaluated by descending through its strict specializations; each lower level is an executable relation governed by Axiom 0 and may extend the same context C. Those admissions supply the context in which the enclosing level becomes evaluable on return. The recursion depth of the computation is therefore determined by the depth of the eschatological specification itself. Iteration is the depth-one case in which no further specialization is introduced.
3.1.7. Asymmetric Execution Product and the S0 Obligation
Role-typed execution carrier. The OEE asymmetry can be represented locally by an ordered product of role-distinguished execution coordinates. Let E denote the epistemic carrier of finite recorded contexts, Ω the ontological realization carrier, and 𝔹={false,true} the eschatological judgment carrier. One admission progressively forms the typed inputs C, (C,ω), and (C,ω,b); the order is constitutive because later coordinates are evaluated only after the earlier ones are available.
E → E × Ω → E × Ω × 𝔹 → E′
Borel requirement. S0 requires the coded reachable execution representation to remain in a standard Borel class under the finite and countable products needed by this construction and by execution histories. The Borel structure supplies closure and measurability; it does not create the OEE asymmetry, which comes from typed coordinate roles and their dependency order. Section 4.4 proves S0 for the fixed-regime finite-branching execution space.
Relation to ZF rank separation. The product view and the rank view answer different questions. Product structure supplies the measurable carrier used by execution; Theorem 1 supplies a ZF coding that keeps event records, ontological specifications, and criterion specifications at distinct construction levels. Neither result substitutes for the other.
3.2. Executable Abstraction and Axiom 0
This section defines the executable abstraction and the single local rule from which the rest of the dynamics follows. For a fixed invocation, ontological realization first determines at most one candidate; the eschatological criterion then returns the deterministic Boolean admission judgment; and the fixed Axiom 0 kernel constructs and records the resulting event only when that judgment is true. These are three operational stages of one constitutive execution rule, not three independent semantics. §4.1 then studies what repeated applications of this rule build.
3.2.1. Abstraction
An abstraction Aτ is the full execution object whose relational reduct is a binary relation. Formally, its definition bundles R with versioned ontological and eschatological specification objects ⌜ωτ⌝ and ⌜τ⌝. Their operational interpretations supply, respectively, a partial single-valued realization procedure and a Boolean admission criterion over the shared context. For readability, operational formulas suppress interpretation brackets and write ωτ(C) and τ(C, ω). Aτ is not a separate layer added to R; R is what remains once specification and execution coordinates are forgotten (§4.2.3).
The absolute abstraction is the same executable object at C0 = ⟨⟩. No admitted instance or execution position exists yet. Axiom 0 is the first operation that can extend this empty context. Under the forgetful map, the empty sequence has the empty set as its extensional image; the reverse direction is not assumed but constructed by successive admissions. No separate bootstrap execution rule is introduced.
Remark (Constitutive asymmetry at bootstrap). The ZF ordered pair preserves positional order but does not, by itself, assign constitutive execution roles or dependencies to its coordinates. In the present calculus, ordered relational coordinates are constitutively asymmetric: the epistemic context provides the execution record, ontological realization supplies a candidate, and eschatological evaluation determines its admissibility. These roles are non-interchangeable, and their operational evaluations are ordered by dependence. This asymmetry is already specified at the empty initial context, before any event has been admitted. Axiom 0 governs the first admission and every subsequent extension without requiring an additional bootstrap axiom.
Remark (Terminology). The term “abstraction” is used here in two related senses. In software engineering, an abstraction retains the properties relevant to a purpose while suppressing implementation detail. In axiomatic set theory, the corresponding mathematical move is extensional: a set is determined by its members and a binary relation by its ordered pairs, while construction history, provenance, and admission conditions are not constitutive parts of the object. The present calculus preserves that extensional relation as the reduct Red(Aτ) = R but lifts it to an executable abstraction Aτ = (R, ωτ, τ), evaluated over C. For a fixed invocation, Aτ combines relational possibility, a single-valued ontological realization procedure, an eschatological admission criterion, and deterministic event construction. In this sense, Aτ is not merely an abstraction of a computation; it is an abstraction that participates in computation by determining whether and how the next attributable execution fact is produced. Classical abstraction suppresses construction to expose structure; executable abstraction restores only the construction information required for accountable computation.
Accordingly, Aτ is referred to here as an executable binary relation: OEE gives the relation its constitutive execution structure, while Execute gives that structure its generative action. The coordinate-free R is the forgetful reduct of this executable object, not the object from which the omitted execution structure is reconstructed.
Event-record constructor. For a fixed invocation and fixed active specification versions, let Rec(Aτ, Cn, ω) denote the deterministic construction of the OEE-addressed event record associated with an already determined realization ω. Rec assigns the immutable specification addresses, sets idinst = n+1 at admission, and places ω itself or a lossless immutable reference to ω in the event payload. Rec has no selection semantics: it only records a realization whose admissibility has already been determined. Consequently Execute(Aτ, ·) is a partial function from contexts to event records.
Admission status. At a fixed context Cn, a fixed invocation is Admitted exactly when Collapse(Aτ, Cn) holds, in which case Execute is defined; otherwise it is Preempted. Retrospectively, a preempted invocation is Deferred if a later context admits that same bound invocation, or Never within the considered regime if no such extension does. The preemption–resume cycle is therefore a change in Collapse status under context growth, not a third local outcome of Axiom 0.
3.2.2. Ontological Realization
Canonical form. Here and below, ωτ(C) abbreviates the operational interpretation of the active immutable ontological specification ⌜ωτ⌝. It is a partial, deterministic realization function: for a fixed invocation it yields at most one realization. For an internal abstraction, that realization may depend on the accumulated context C and remain undefined while required facts are unavailable. Environmental abstractions retain the same ontological role but may bind a candidate from an external occurrence before the admission test. In either case, once a candidate exists, admission is determined separately by τ over the full current context.
Invocation convention. Operational claims in what follows concern a concrete invocation of an abstraction. For an environmental abstraction, the triggering external occurrence is bound to that invocation before ontological realization is evaluated; distinct external occurrences therefore correspond to distinct invocations of the same abstraction specification. Conditional on a fixed invocation, ωτ remains single-valued exactly as in the internal case.
Remark (ωτ is not an ad hoc external parameter). An ontological specification event in C records an immutable address for the active ⌜ωτ⌝ version (§3.2.6), so replay resolves the same specification that governed the original admission. In the environmental case, what may originate outside the record is the occurrence that triggers an invocation, not the ontological specification governing how that occurrence is realized. A later change of ontology is represented by a new specification event and address rather than mutation of the version already referenced.
Remark (prefix-monotone domain growth for context-dependent realization). For an internal abstraction whose ontological realization depends on the accumulated context, dom(ωτ) is the set of contexts for which the required realization is defined. This domain need not be prefix-closed in general. When the ontological specification satisfies prefix-monotone availability for the same bound invocation—ωτ(C)↓ and C'≽C imply ωτ(C')↓—append-only context growth preserves ontological availability. Under that additional condition, once the contextual requirements for realization are present, later extensions cannot make the invocation undefined, although the realized value itself need not remain unchanged unless the specification also guarantees value stability. Without prefix-monotone availability, context growth may change ontological availability. This question is distinct from §4.5.1, which concerns preservation and later verification of an already-recorded admission under its original prefix and criterion version. Environmental candidate generation may instead be triggered by an external occurrence; once a candidate exists, however, its admission is governed identically by τ over the full current context.
Remark (scope of ontological realization). The calculus fixes the type of ωτ, its single-valuedness for a fixed invocation, and its role in admission; it does not prescribe the internal algorithm or domain methodology by which a particular realization is produced. Likewise, the calculus fixes how ωτ and τ compose through Axiom 0 without prescribing the language in which either is written or the infrastructure that executes them. Those representation and realization choices are treated explicitly in §4.3.4 and §5. For each fixed invocation, the specified interface is deterministic even if its returned content represents a multivalued domain relation. Domain construction and interpretation are design choices; a context-dependent realization remains undefined while required information is unavailable and may be re-evaluated as C grows.
The ontological specification event eont records or references the active ⌜ωτ⌝ version and the eschatological lineage under which that version is defined (§3.2.6). A realization produced by an invocation is a different object: it is a candidate for admission and does not enter C merely because ωτ has produced it. Only when the eschatological criterion holds over the full current context does Execute append the resulting execution event. The criterion specification is referenced by the eschatological record eesh rather than embedded into eont; keeping these specification addresses distinct preserves their roles while allowing both to be recovered for replay.
Remark (context-mediated resolution of ontological multiplicity). Single-valuedness of ωτ for a fixed invocation does not eliminate multiplicity from the ontology or nondeterminism from the system. An ontological specification may admit many realizable possibilities in the abstract. For an internal abstraction, the accumulated context C supplies the endogenous basis against which that multiplicity is resolved for the current invocation; operationally, this is represented by the partial single-valued value ωτ(C). Multiplicity therefore belongs to the specification, while a fixed invocation exposes at most one realized candidate. No independent selecting operation is introduced. The realization is constituted relative to accumulated execution and is then separately evaluated for admission by τ. For an environmental abstraction, the bound external occurrence supplies the candidate, but C still determines through τ whether that candidate becomes an admitted execution fact. Across several active invocations, C determines their individual admission status but does not by itself determine a serialization order; any correctness-relevant ordering rule must itself be specified or represented in C.
Remark (environmental abstraction). An environmental abstraction is a derived, domain-relative designation for an executable relation whose candidate may be bound from another domain without consulting the accumulated context. Its own eschatological criterion nevertheless evaluates that candidate against the current C, and only Axiom 0 admits an event. The designation introduces neither a separate execution class nor an external controller.
3.2.3. Deterministic Boolean Admission Function
Canonical notation. Here τ(C, ω) abbreviates the operational interpretation of the active immutable criterion specification ⌜τ⌝. Its actual domain is the set of pairs (C, ω) for which the active ontology has produced a realization; on that domain τ is total and Boolean. The notation (C, ω) ∈ τ is shorthand for membership in the positive extension Γτ+ = {(C, ω) : τ(C, ω) = true}; the function, its specification code, and its positive extension are related but not set-theoretically identical objects.
Effectiveness assumption. For an executable abstraction, ωτ and τ are assumed to be given by effective procedures that terminate on every input in their respective domains. This assumption is local to one invocation. It ensures that each reached admission test is a finite operation, but it says nothing about whether repeated admissions, persistent preemption, or the system as a whole terminate.
The calculus permits hierarchical composition of any effective deterministic predicate over (C, ω). One useful conjunctive form is τ = Aggregate(P1, …, Pk), with τ(C, ω) = true iff every required component Pj(C, ω) is true. When functional, non-functional, safety, compliance, or ethical constraints are specified as components of such a criterion, they have the same formal status at the admission boundary. A normative or safety constraint intended to block admission must therefore participate in τ before Execute records the event; post-hoc analysis or compensation is a separate abstraction. Section 5.3 gives one conjunctive system-level construction. The calculus does not prescribe the substantive content of any such criterion.
3.2.4. Admission and Preemption
Definition 1 (Collapse). For a fixed invocation, Collapse(Aτ, C) holds exactly when both stages of admission succeed: Collapse(Aτ,C) ⇔ ωτ(C)↓∧τ(C,ωτ(C)) = true. Collapse is the local admission boundary. It determines whether the already specified realization is recordable; the unique event record itself is then supplied by the deterministic constructor Rec.
Preemption is the absence of admission and may originate at either stage. Ontological preemption occurs when no realization is available for the current invocation, so the eschatological criterion is not reached. For a context-dependent internal abstraction this may occur because the required facts are not yet present in C. An environmental invocation may instead obtain its candidate from the external occurrence bound to that invocation. Eschatological preemption occurs after a realization exists, when the total Boolean evaluation τ(C, ω) returns false.
Both forms produce no execution event and no extension of C. They need not have the same cause: the first is an undefined ontological realization, whereas the second is a computed negative admission decision over the full current context. The compact form of Axiom 0 hides this operational distinction but does not remove it.
For a fixed invocation, once the inputs to each stage have been bound—including any external occurrence—the complete Collapse condition can be viewed externally as a Boolean function of C. This is the compact form used by Axiom 0 (§3.2.5). The two-stage account makes the ontological and eschatological sources of preemption explicit without introducing a second admission rule.
Axiom 0 is not a conventional state-transition rule over a state snapshot. It is the local admission step over the complete accumulated context. Only successful admission produces an event and a new sequence position.
3.2.5. Axiom 0
Axiom 0 (local admission). For a fixed invocation and context Cn, Execute(Aτ,Cn) = Rec(Aτ,Cn,ωτ(Cn)) if ωτ(Cn)↓ and τ(Cn,ωτ(Cn)) = true; otherwise Execute(Aτ, Cn) is undefined. The initial context is C0 = ⌀, and whenever Execute is defined the record extends by Cn+1 = Cn⌢⟨Execute(Aτ,Cn)⟩.
This is Axiom 0 in operational form. The specification objects ⌜ωτ⌝ and ⌜τ⌝ belong to Aτ; their active operational interpretations are the two tests on the right-hand side, while Rec is a deterministic encoding step and introduces no further choice. The results of §§4.4–4.5 add finiteness, branching, and well-foundedness assumptions that are not part of this local rule.
3.2.6. Event and Its Three Forms
Definition 2 (Event). An admitted event is the unique record returned by Execute for a collapsed invocation. It has the general form e = ⟨coord(e), payload(e)⟩, where coord(e) contains the OEE specification lineage and the assigned instance position, and payload(e) contains or losslessly references the realization admitted at that invocation. Three specialized record forms are used in C:
• eesh = ⟨idesh, payloadesh⟩ — eschatology
• eont = ⟨(idesh, idont), payloadont⟩ — ontology
• eexec = ⟨(idesh,1, …, idesh,k, idont, idinst), payload⟩ — execution
The general execution-event form is eexec = ⟨(idesh,1, …, idesh,k, idont, idinst), payload⟩. The composite address identifies immutable specification versions and the recorded instance, while the payload preserves the realized candidate needed for deterministic verification replay. Under the stated database-schema assumptions—atomic payload, complete composite key as the sole candidate key, and no non-trivial join dependency—the event relation is in sixth normal form [41]. This 6NF claim is a schema condition used by the implementation mapping, not a consequence of determinism alone.
Existential dependency follows from key structure: an execution event presupposes an ontological event, which presupposes an eschatological event: ∃ eexec ⇒ ∃ eont ∈ C ∧ ∃ eesh ∈ C, and ∃ eont ⇒ ∃ eesh ∈ C. No admitted execution fact exists outside the context.
Remark (time and parallelism). Time is derived from epistemic position rather than being a constitutive execution axis: a mapping t: ℕ → T may assign temporal labels to positions in C. Apparent parallelism likewise reflects how multiple abstractions are represented or scheduled around the shared record; formally, each admission is written sequentially into C. No additional simultaneous-execution status is required by the calculus, and interaction among abstractions is mediated by the context they share (§4.1.5, §4.3.2).
3.2.7. Execution Patterns under Axiom 0
Mapping, branch resolution, context-mediated synchronization, and recursion are recurring execution patterns of the calculus, not additional semantic primitives. Each is realized through the same Axiom 0 interaction among the accumulated context C, the active ontological realization procedure ωτ, and the eschatological admission criterion τ. Unresolved execution may arise at either stage: ontological non-availability when no realization is yet defined, or eschatological preemption when a realization exists but the criterion is false. Commitment occurs only at the Axiom 0 admission boundary.
• Mapping — the degenerate pattern in which realization is deterministic and the relevant admission condition is already satisfied; execution therefore reduces to a deterministic context transformation.
• Branch resolution — an ontological specification may admit multiple possibilities in the abstract, while a fixed invocation exposes at most one realization through the context-mediated procedure ωτ(C). Admission of that realization remains separately governed by τ.
• Context-mediated synchronization — an abstraction may depend on an event admitted by another abstraction. The dependence is realized through the shared C and detected by the Collapse flip of §4.1.4; no additional synchronization or interaction semantics is introduced.
Priority among abstractions in conflict—when ordering is correctness-relevant—belongs to the executable specification rather than to an additional semantic primitive. Whatever the governing criterion needs to determine priority—registration order, resource balance, waiting condition, or an admitted scheduling fact—must be available from C or from the invocation’s specified inputs. An implementation may use a scheduler, queue, or broker, but a semantically relevant ordering decision must be represented in the execution record rather than remain outside accountable execution.
• Recursion — a derived execution pattern in which an abstraction inherits and specializes its parent’s eschatological condition (τ′ ⊏ τ), lower-level admissions enrich the shared context, and the enclosing level is then re-evaluated. Iteration is the depth-one case in which no further specialization is introduced.
Degenerate case. If ontological realization is total and deterministic for every relevant invocation and τ ≡ true, the abstraction reduces to deterministic mapping. Ontological availability and eschatological admissibility remain distinct stages, jointly closed by Axiom 0.
3.2.8. Origin of Three-Stage Execution and the Fixed Axiom 0 Kernel
Extensional collapse and executable factorization. An ordinary coordinate-free mapping appears as a single act because the extensional relation suppresses the distinct construction roles by which an execution fact is realized, judged, and recorded. In the executable lifting those roles are separated. Thus three-stage execution is not an implementation convention: it is the operational consequence of the asymmetric OEE constitution.
Cn → ωτ(Cn) → τ(Cn,ω) ∈ 𝔹 → K0(Cn,ω,true) = Cn+1
3.2.9. Uniform Functional Form, Different OEE Content
The realization and criterion interpretations share the general form of deterministic typed mappings but have different codomains and constitutive roles: ωτ is partial and returns a realization in Ω, whereas τ is total on realized inputs and returns a value in 𝔹. Their specification objects remain independently versioned and distinct in the OEE rank discipline.
Sω : Dω ⇀ Ω Sτ : Dτ × Ω → 𝔹
Fixed execution kernel. Axiom 0 may itself be read operationally as a fixed partial deterministic mapping K0 whose typed contract is supplied by the calculus rather than redesigned for each domain. Thus Sω, Sτ, and K0 share the broad form of typed deterministic mappings, but only Sω and Sτ carry domain-variable content; K0 is the invariant admission kernel. Repeated application of K0 over the growing context is Eschatological Induction.
Executeα = K0[Sω,Sτ] with Sω,Sτ variable and K0 fixed
Degenerate mapping. If Sω is total and deterministic and the relevant criterion is identically true, the internal OEE factorization remains conceptually present but its observable behavior collapses to an ordinary deterministic context transformation. Classical one-stage mapping is therefore the degenerate extensional case of the three-stage executable construction.
4. Results
Section 3 fixes the executable object and its local admission rule. The results below are separated by scope. Repeated admission constructs one shared append-only context and yields a contextual causality criterion; forgetful projection recovers the classical relational view and locates the Choice problem outside Axiom 0; shared context and immutable specification lineage yield local functionality, OEE-closed governance, and deterministic verification replay; the fixed-regime admissibility space admits the topological and cardinality analysis stated in Section 4.4; and fixed points, recursive finiteness, terminality, and evolutive change are characterized only under their respective additional assumptions. No global convergence or universal scheduling result is claimed.
4.1. Context, Eschatological Induction, and Interaction
With the local rule now fixed by §3.2, this section studies what repeated admissions build. Eschatological Induction constructs the shared execution context C; recursion follows one abstraction’s criterion hierarchy, while multiple abstractions interact horizontally through the growth of the same record. The section then separates invocation context, enabling context, serialization, and direct causal dependence.
4.1.1. The Execution Context
Context is the execution sequence grown from ∅ by successive successful applications of Axiom 0. It is the append-only record of admitted events. C is not a timeline or a state snapshot: it is an epistemic sequence whose positions are knowledge increments. Every admitted event adds one fact to system knowledge; its position in C is itself a fact, independently of any clock or elapsed time. An extensional set records extension—which values belong. C records construction—which OEE-addressed facts were admitted, in what recorded order, and with what causal provenance. The sequence as a whole is the execution history from which state-like or temporal views may later be projected.
C0 =⟨⟩, Cn+1 = Cn ⁀⟨en+1⟩ where Execute(Aτ, Cn) = en+1, n ≥ 0
Remark. Anything not written into the context is not part of execution.
Remark. The execution context C is the formal primitive; “database”, “log”, “ledger”, and “knowledge base” are implementation names for realizations of C and add no semantic content to the definition. Together with the active ontological and eschatological specifications, C provides the information required for deterministic verification replay (§4.3.5): the recorded prefix fixes the context consulted at admission, immutable addresses recover the specification versions in force, and the event preserves the realization that was tested. The empty sequence ⟨⟩ is identified with the empty set ∅ by the standard set-theoretic encoding of finite sequences; where the paper writes C0 = ⌀, it denotes that identification rather than a change of type.
4.1.2. Admission Count and Sequence Position
n counts admissions, not elapsed time. idinst is computed only at the moment of admission, once Collapse(Aτ, Cn) holds — it is the position e takes in the record, assigned by deterministic append and not chosen. This is distinct from idesh and idont, which are addresses referring to immutable specification versions fixed before the admission (§3.1.5).
Cn+1 = Cn ⁀ ⟨en+1⟩ exists only when the admission was actually performed. n is not a variable ranging over a clock, and its increment is not guaranteed the way Peano succession guarantees S(n) — it is admitted, not postulated (§4.1.3).
4.1.3. Eschatological Induction
Definition 3 (Eschatological Induction). Eschatological Induction is the recursive construction of executable history through successive Axiom 0 admissions. Base case: C0 = ⌀. Inductive step: for a fixed invocation of Aτ at Cn, if Collapse(Aτ, Cn) holds then Execute(Aτ, Cn) is defined and Cn+1 = Cn⌢⟨Execute(Aτ,Cn)⟩; otherwise that invocation is preempted and contributes no local extension. System-level C may nevertheless grow through another admissible abstraction.
Relation to Axiom 0. Axiom 0 is the single local step of this construction; Eschatological Induction is that same step viewed recursively over the history it generates. The distinction is therefore one of scale, not mechanism: locally the abstraction determines whether Cn is extended to Cn+1; globally the repeated admissibility act generates C itself.
Remark (resolution and projected Choice). Eschatological Induction is the recursive mechanism by which relational possibilities become admitted execution facts. §4.2 shows how the classical global-selection problem appears only after the constitutive execution structure is forgotten in the coordinate-free relational projection.
Remark (shared admission semantics for governance and execution). This is also, and separately, the mechanism used by the OEE-closure result of §4.3.3: the induction step does not require a different local rule for an ordinary admission and for a governing admission that activates a new ontology or criterion version (§4.5.6). Under the closure assumption, both are applications of Axiom 0 and both remain attributable in the same execution record.
Remark (specification and execution). The higher-rank specification objects ⌜ωτ⌝ and ⌜τ⌝ are not themselves inserted into C as ordinary events. Instead, ontological and eschatological specification events in C record or address which immutable versions are in force (§3.2.6). Their operational interpretations are then used at evaluation time. For an internal abstraction, ωτ may depend on the accumulated context; for an environmental abstraction, the candidate may arise from a bound external occurrence. In both cases Eschatological Induction determines whether the resulting candidate becomes part of execution by evaluating τ against the full current context.
Bare Peano succession does not by itself model conditional execution. The successor operation S(n) = n+1 supplies unconditional numerical continuation once its argument is given. The present execution problem is different: the extension Cn → Cn+1 exists for a particular abstraction only when its admissibility condition holds. Where that condition fails, the abstraction contributes no local successor, although the shared context may still grow through another admissible abstraction. In this sense the successor of an execution context is admitted rather than postulated.
Product-closure distinction. Peano-style induction can index repeated applications of a successor rule, but it does not by itself supply the closure property of the execution carrier required by the successor construction. In the present calculus, each successful step must combine a recorded context, a realized candidate, and a Boolean judgment while remaining inside the same admissible representation class. S0 states this separate closure obligation; §4.4.7 proves, under the fixed-regime finite-branching assumptions, that the coded local products and the resulting execution-outcome space remain standard Borel/Borel. Eschatological Induction therefore uses numerical iteration only after the execution product itself has been shown to remain well formed.
The same local rule also bounds continuation at a given eschatological level: an abstraction extends C only on invocations for which its admission condition holds. Persistent failure leaves that abstraction pending; it does not by itself define global program termination. Whether the system as a whole can extend C further is treated separately in §4.5.5.
Two properties follow. Succession is history-conditioned: en+1 depends on the complete prefix Cn, not on en alone. Continuation also need not be monotone: an abstraction admissible at one prefix may be preempted at a later one (§4.5.2).
Each reached evaluation is required to be effective and deterministic relative to its fixed invocation and prefix; direct causal dependence is defined separately in §4.1.4. The purpose of the calculus is to make this full admission context explicit rather than hide it inside another representation.
Self-similarity across eschatological levels. The same admission structure appears at the scale of one event and at every level of a specialized criterion. At the local scale, Execute(Aτ, Cn) admits one event and extends the context by one position. At the recursive scale, the same rule is applied under each τ-level in the specialization hierarchy, with lower-level admissions enriching the context against which enclosing levels are evaluated. Recursion is therefore execution repeated under progressively specialized purpose. The recorded sequence remains linear; the hierarchy is carried by the event address rather than by branching the concrete execution record.
4.1.4. Contextual Causality
Notational note. Cᵐ ≼ Cᵃ denotes that Cᵐ is a prefix of Cᵃ (equivalently, Cᵃ ⪰ Cᵐ extends Cᵐ). Contexts and passages are ordered by this prefix relation throughout the paper rather than by set inclusion, because C and σ are sequences, not sets.
Definition 4 (Invocation and enabling contexts). For an admitted event e produced by the actual invocation Execute(Aτ,Ca) = e, define InvocationContext(e):=Ca. This is the exact recorded prefix against which admission was evaluated and is always well-defined. If, for that fixed invocation, both ontological availability and criterion satisfaction are prefix-stable — equivalently, once Collapse(Aτ, C) becomes true it remains true under later context extensions that do not alter the relevant invocation — define EnableContext(e) as the least Cm≼Ca such that Collapse(Aτ,Cm) holds. When this stability condition is absent, no earlier prefix is substituted for the actual invocation context.
InvocationContext and EnableContext answer different questions. InvocationContext records the context actually used when e was admitted. EnableContext, when defined, records the earliest stable prefix at which the abstraction had already become admissible. Neither should be confused with serialization position: two events may be written in one order while having the same enabling context or no direct causal dependency between them. For an environmental event, the bound realization is preserved by the admitted event itself (§4.3.5).
Direct causal dependence is determined by an admission flip rather than by position or by inclusion of enabling contexts. For abstractions Aj and events e, f, event e is a direct causal precondition of f at prefix Cn when Collapse(Aj, Cn) is false but Collapse(Aj, Cn⌢e) is true. This single test covers both ways e may matter: it may make the ontological realization available, or it may make the eschatological criterion hold once a realization is available.
4.1.5. Several Admissions Enabled by One Context
Suppose the record has reached a context Cn in which k ≥ 2 active invocations Aτ1, …, Aτk are independently admissible: Collapse(Aτi, Cn) holds for i = 1, …, k, and intervening admissions by any one of them do not change the Collapse status of the others. This is a one-to-many enabling relation between context and possible next admissions; it does not introduce simultaneous execution — the record remains a single sequence and admissions occur one at a time.
After one abstraction is admitted, the context grows, and every remaining abstraction is re-evaluated against the new context, as required by §4.3.2. Independence means precisely that these intervening admissions do not alter the facts on which the remaining admission conditions depend. Hence, although the context grows, each remaining criterion stays satisfied and its event is admitted at a subsequent step.
The original Cn is therefore a common enabling context for all k abstractions when the relevant Collapse conditions are prefix-stable. Their actual InvocationContexts may be later prefixes because admissions are serialized one at a time. When stability is absent, only the actual InvocationContext is used for causal attribution.
Thus the common Cn is what made all k abstractions admissible, while their actual admissions occupy different later positions in the sequence. Those positions carry no causal meaning among the k events: they record only the order in which independently admissible facts were written. If admission of one event changes whether another remains admissible, the abstractions are not independent, and the case belongs instead to the interaction semantics of §3.2.7 and the non-commutative case of §4.5.3.
Corollary 1 (Sequence position is not causal order). Let e,f ∈ C be produced by abstractions independently enabled by the same context Cn in the sense above, with intervening independent admissions preserving their admissibility. Then idinst(e) < idinst(f) does not imply that f causally depends on e, or that e’s admission was a precondition for f’s. The comparison records serialization only; direct causal dependence is determined by the Collapse flip of Definition 4.
Corollary 2 (When order is causal). Event e is a direct causal precondition of f when adding e changes the relevant abstraction from non-collapsed to collapsed at the relevant prefix. If the abstraction producing f was already collapsed before e and remains so after e, then f’s admission does not directly depend on e, regardless of their later serialization positions. This is weaker than saying that swapping their order changes nothing downstream: a later abstraction may itself read their relative positions.
This does not weaken §4.3.1: once an event is written, the realized record is fixed and immutable. What §4.1.4–§4.1.5 add is that serialization order is not itself a proof of causal dependence between adjacent events. Proposition 3 (§4.5.3) covers the complementary case in which an earlier admission changes the later abstraction’s Collapse status and therefore makes order semantically relevant.
Both cases use the same one-at-a-time admission mechanism. When several abstractions remain independently admissible as C grows (Corollary 1), their local admission conditions do not determine a serialization order. When one admission changes another abstraction’s admissibility, the interaction is resolved by a criterion specialized to that dependency (§3.2.7). If invocation order itself is correctness-relevant, the fact or rule that determines it must be specified or represented in C; implementation schedulers, queues, or brokers do not constitute a second admission semantics.
4.2. Classical Projections and the Role of Choice
Within an executable abstraction, ωτ and τ are specified, while the accumulated context determines the conditions under which their interaction yields an admission. For each fixed invocation, ωτ yields at most one realization when defined and τ evaluates that realization against C. No additional act of selection is introduced: the realized outcome is constituted by contextual realization followed by admission. Only when the criterion, context, and execution coordinates are forgotten does the reduced relation retain a family of possible pairs without the constitutive process by which one became an execution fact. The role of Choice considered in this section therefore belongs to that projected family of relation fibers, not to Axiom 0 itself.
4.2.1. Forgetful Projection (U)
Let U be the event-level forgetful map introduced conceptually in §1.1. It discards the OEE address and retains only extensional content: U(⟨coord, payload⟩) = payload. For a context C define its extensional image Ext(C) = {U(e) : e ∈ ran(C)}; Ext forgets order, multiplicity of identical payloads, specification lineage, and admission history.
Proposition 1 (event-level forgetful projection). U maps each admitted event to an ordinary extensional value, and Ext(C) is the ordinary extensional collection obtained from the realized execution record by forgetting its execution coordinates and order.
Proof. By definition U removes coord(e) and retains payload(e); Ext then takes the set of those projected payloads. Distinct admitted events may therefore collapse to the same extensional element whenever they have equal payloads. ∎
Remark (function as the degenerate case). Functionality is a claim about ontological multiplicity alone: a function f ⊆ X × X has, for each input, at most one candidate; it says nothing about whether that candidate is admitted. Since ωτ is itself single-valued for a fixed invocation (§3.2.2), one abstraction never selects among several ontological candidates at that invocation, but its criterion τ may remain non-trivial (§3.2.4). Multiplicity instead appears at system level when several active abstractions contribute their individually single-valued candidates to Cand(σ) (§4.4.1). A fully degenerate system-level case is one in which that aggregate candidate set never exceeds size one; even then the admission criterion need not be trivial.
4.2.2. Admitted Event as the Source of the Set Element
As already illustrated in §1.1, two admitted events may carry the same extensional value while remaining distinct execution facts because their coordinates differ. The forgetful map removes precisely the information that distinguishes those executions.
A selector over already-admitted coordinated events is definable from the fixed address coding: choose the event whose address has least natural-number code (or, for sequence position, least idinst). The ordering is used only after admission for identification, attribution, query, replay, or serialization. Over the image of U those execution coordinates are absent; for an arbitrary family of nonempty relation fibers, the projected representation itself need not define a global selector.
Russell’s familiar example illustrates the distinction. Given infinitely many pairs of shoes, a representative is definable — take the left shoe. Given a family of otherwise indistinguishable pairs, the objects themselves supply no corresponding selection rule; a choice principle may therefore be required to obtain a simultaneous selector, while full AC guarantees such a selector for an arbitrary family of nonempty sets [1].
Observation. Axiom 0 requires no application of the Axiom of Choice for local admission: Execute never selects a member from an arbitrary family of nonempty sets. Fixed address coding supplies definable order only for post-admission operations such as identification, attribution, query, replay, and serialization. §§4.2.5–4.2.6 locate where Choice language reappears after projection and how deterministic representative rules are handled.
4.2.3. Abstraction as the Source of the Binary Relation
This section reads the construction in reverse at two distinct levels. At specification level, the relational reduct Red(Aτ) = R is obtained by forgetting the explicit ontology/criterion specifications and execution coordinates from the executable abstraction. At realized-execution level, the event projection U maps admitted records to their extensional payloads; the set of payloads actually realized under a regime need only be a subset of what R permits. These two forgetful operations should not be conflated.
Define the contextual execution relation ExecRel(Aτ) = {(Cn, en+1) : Execute(Aτ, Cn) = en+1}. It records exactly the contexts in which Axiom 0 succeeds and the corresponding unique event record. Its extensional realized image is Adm(Aτ) = {U(e) : ∃C, (C, e) ∈ ExecRel(Aτ)}. In general Adm(Aτ) ⊆ R; equality is not required because τ may permanently preempt ontologically possible pairs. The full coordinate-free relation R is the specification-level reduct Red(Aτ), not the image of one realized execution relation.
Remark (structure and contextual interaction). The active specification versions are fixed for the invocation; their operational interpretations have the single-valued and Boolean roles defined in §3.2. What varies across execution is the context against which those interpretations interact. ExecRel(Aτ) records precisely the contexts in which that interaction succeeds and a unique event is admitted. It therefore resolves possibility into recorded execution without conflating specification-level well-formedness with context-dependent admission.
A projection formalizes which events belong to which abstraction once both are in view: π_{Aτ}(C) = ⟨ei ∈ C | idesh(ei) = id(Aτ)⟩ selects, from the total sequence, only the events written by a given abstraction. A projection does not exist without an abstraction, and does not create a new context — it selects a subsequence from the one that exists. If multiple abstractions write into the same C, their projections are formally disjoint by eschatological coordinate, since each abstraction’s events carry a unique idesh.
4.2.4. What Is Lost by Projection
Corollary 3 (Non-Regenerability from Projection). In any multi-abstraction context family in which an event outside A’s projection may vary while A’s own projected events remain fixed, πA is non-injective: there exist C ≠ C' with πA(C) = πA(C'). Consequently πA has no global left inverse on that context family.
Proof. By hypothesis there exist C ≠ C′ in the considered context family that agree on every event selected by πA while differing outside that projection. Hence πA(C) = πA(C′), so πA is non-injective. A left inverse r with r∘πA = id would have to map the same projected value to both C and C′, which is impossible. ∎
This is why time, state, architecture, and process—as proper projections—and syntax and external semantic interpretation—as associated representational layers—are useful views but not full executable reality (§4.3.4). Corollary 3 applies directly to the proper projections; §4.3.4 separately explains why the representational layers are non-constitutive and need not reconstruct the whole context.
4.2.5. Role of AC in the Projected Representation
Within the OEE core (§3.1–§4.1), the fixed natural-number coding of event addresses provides a definable well-order over already-admitted coordinated objects, but admission itself is not decided by sorting those addresses. Axiom 0 evaluates one specified realization and one specified criterion for a fixed invocation. idinst plays no part in reaching that admission; it is assigned to the outcome only after admission occurs. Thus the coordinate-based ordering supports later operations, not the admission mechanism itself.
The language of AC belongs to the projected, classical reading of this same structure — the one obtained by applying U (§4.2.1) and forgetting the coordinates. Once an abstraction is read as an ordinary binary relation R ⊆ X × X, with no criterion attached, simultaneous selection from an arbitrary family of nonempty fibers has exactly the form to which AC applies. The coordinate-free representation itself neither defines such a selector nor, in ZF alone for an arbitrary family, guarantees that a global one exists; AC supplies that guarantee. That is a fact about what survives projection, not a fact about how Axiom 0 operates. Concretely:
• In the full OEE execution object, a fixed invocation is unresolved until ontological realization is available and the eschatological criterion holds; at that point exactly one event is admitted. This local admission requires no global choice selector.
• In the projected classical reading — the abstraction stripped to R ⊆ X × X, with the criterion and execution coordinates discarded — a simultaneous selector over an arbitrary family of nonempty fibers is exactly the kind of object whose existence AC guarantees.
The distinction is therefore structural. Axiom 0 evaluates one specified realization and one specified criterion at a time; it does not construct or invoke a global selector. The global choice problem appears only in the coordinate-free family of fibers obtained after projection. Appendix B.4–B.5 state the same distinction at the level of the abstraction and its projected fibers.
4.2.6. Definable Selection and Equivalence Classes
A total order by itself is not sufficient for a canonical selector over every nonempty set; what is needed is a definable least-element rule, such as the fixed well-ordering of encoded addresses used above. Tolerance classes illustrate the distinction: candidates may be indiscernible under the application criterion even though already-admitted instances remain individually addressable in the execution record.
This occurs wherever comparison is approximate rather than exact: floating-point arithmetic up to ε, measured quantities equal within instrument error, semantic matching up to a distance. In each case candidates within one tolerance class are indiscernible under the criterion, and any order among them is imposed from outside.
Every admitted event carries idinst, unique by construction. Ties within a tolerance class are resolved, after the fact, by the record itself: among already-admitted events in that class, the least idinst is a definable and reproducible representative for query or replay. idinst does not decide which candidate is admitted. The tolerance and representative rule belong to the abstraction specification, and the corresponding specification event makes that rule attributable in C.
The calculus does not distinguish among candidates that its own ontological specification treats as indiscernible. A concrete admission nevertheless records one value, never an equivalence class. The specification of ωτ must therefore contain any canonical representative rule required by the domain — rounding, truncation, or another deterministic convention. The execution record then preserves which representative was admitted and which recorded specification governed that realization.
4.3. Structural Consequences: Governance, Representation, and Replay
This section collects the consequences most directly needed by the paper’s two target requirements. The local rule first yields local functionality and stable event identity; shared C then supplies coordination without a second admission mechanism. Under OEE closure, governing and operational acts share that same semantics (R1), while immutable specification lineage and append-only history yield deterministic verification replay (R2). Representation and infrastructure claims are stated only after these execution results are fixed.
4.3.1. Local Functionality and Event Identity
Corollary 4 (Execute is a partial function). For a fixed invocation of Aτ at a fixed context Cn, Execute(Aτ,Cn) is either undefined or has exactly one event-record value.
Proof. The ontology interpretation is single-valued for the fixed invocation. If it is undefined or the Boolean criterion is false, Axiom 0 leaves Execute undefined. If both stages succeed, the realization ω is unique and Rec(Aτ, Cn, ω) is deterministic, so Execute has exactly one value. ∎
This is local functionality. Given C0 and a fixed sequence of invocations, induction on the admissions therefore yields a unique recorded execution. It is not a claim that a context containing several independently enabled invocations determines a unique serialization order; §4.1.5 separates that scheduling question from local admission.
Every new sequence position is a minimal knowledge increment: Position(en+1) = n+1, and this holds even when Payload(en+1) = ∅ — the increment is guaranteed by position alone, independent of what the event carries.
The composite key’s three coordinates are existentially dependent: an execution event presupposes an ontological event, which presupposes an eschatological event (§3.2.6). This ordering is not imposed by convention — it follows from the fact that idont and idesh are addresses fixed before admission, while idinst is computed only at admission (§4.1.2), so the computed coordinate cannot exist without the addressed ones already being in place.
4.3.2. Coordination and Causality through Shared Context
For a fixed context Cn and a fixed family of active invocations sharing it, the currently admissible invocation set is the derived set
𝓕(Cn) = {Ai : Collapse(Ai, Cn)}, where Ai ranges over active invocation instances, not merely distinct abstraction specifications (§4.4.1).
Each membership fact in 𝓕(Cn) is determined by the fixed invocation, the active immutable specification versions, and Cn. The set therefore requires no additional coordination semantics beyond the local Collapse predicate; if more than one invocation belongs to 𝓕(Cn), serialization is treated separately as in §4.1.5.
In addition, once admitted, an event occupies a fixed position in C and cannot be removed or reordered. This immutability concerns the realized record, not the causal relation among its events. §§4.1.4–4.1.5 distinguish direct dependence from mere serialization: two events may appear in one order because they were written sequentially even when neither admission was a precondition of the other.
A fixed invocation is preempted at C exactly when ¬Collapse(Aτ, C). If the same bound invocation later becomes admissible at an extension C′ ⪰ C, it is Deferred in the terminology of §3.2.1. Context growth therefore defines when re-evaluation is semantically relevant, although an implementation may use schedulers, queues, or messages to realize that re-evaluation.
Abstractions interact through the shared execution context: an admitted event may alter the context over which other abstractions compute their realizations and evaluate their criteria. C is therefore the common resolving medium of the system: the output admitted by one abstraction becomes part of the resolution basis and admission context of the others. This does not mean that C determines a unique serialization among all simultaneously possible events. Each fixed invocation remains resolved locally by its own ωτ and τ against C, while serialization among several independently admissible invocations is treated separately (§4.1.5). Whether the implementation uses threads, messages, brokers, or another coordination mechanism does not add a second execution semantics; where such mechanisms make semantically relevant decisions, those decisions must themselves be represented in C.
Operationally, each relevant re-evaluation repeats the two Axiom 0 stages: attempt realization; if no realization is available, remain preempted; otherwise evaluate τ over the current C; if false, remain preempted; if true, construct the unique event with Rec, append it, and re-evaluate affected invocations. Local admission remains deterministic relative to a fixed invocation; global termination is treated separately in §4.5.5.
4.3.3. Governance and Execution Share One Admission Semantics
Conventional architectures may implement control as a second system that observes execution, evaluates policy, and intervenes through its own state and view. The claim here is conditional on OEE closure: assume every correctness-relevant governing act that can change the executable system is itself represented as a governing executable abstraction sharing C. Under that condition, governance introduces no second admission semantics.
Definition 5 (OEE closure). A realization is OEE-closed for the purposes of this paper when every correctness-relevant governing change that can alter executable behavior is represented as an invocation of an executable abstraction sharing C and can affect the execution record only through Axiom 0.
Corollary 5 (single admission semantics under OEE closure). In an OEE-closed realization satisfying the preceding closure assumption, a governing abstraction may write an event exactly when its own Collapse condition holds, just as an operational abstraction may. Thus governing and operational acts share the same Axiom 0 admission semantics; no separate control predicate is required by the calculus.
Proof. By the closure assumption, every correctness-relevant governing change is an invocation of an executable abstraction over C. Axiom 0 is the only rule by which any such invocation, governing or operational, can extend C. Therefore both classes of acts are authorized by the same local condition Collapse(A, C) and recorded by the same Execute/Rec mechanism. ∎
There is therefore no separate control execution path inside the calculus: the condition under which a governing event is admitted is the same kind of condition that governs any other event. This is structurally aligned with the Good Regulator principle (Conant & Ashby [42]) without claiming to reproduce its proof in full generality. Management is not eliminated; it is internalized as governing abstractions whose changes to ontology or criterion are ordinary, attributable admissions. This establishes the admission-semantic part of R1; §4.5.6 closes R1 by making specification change itself an admitted act. For evolutive AI, the practical consequence is that self-revision need not become an out-of-band controller operation whose governing rationale disappears from the execution history.
4.3.4. Derived Views and Representation Agnosticism
Time = π_{Atime}(C), State = π_{Astate}(C), Architecture = π_{Aarch}(C), and Process = π_{Aprocess}(C) are representative projection-defined views of the shared execution record. None is an independent admission primitive, and §4.2.4 shows why no proper projection can in general reconstruct the whole context. Process, read this way, is a derived trace of admissions associated with an abstraction; standard simulation and workflow formalisms provide related process views [43,44]. Parallelism is likewise represented through temporal or architectural descriptions around admissions rather than as a second execution record.
Syntax and external semantics require a different statement. They are not necessarily subsequences of C: syntax is the language or notation used to specify an abstraction, while external semantics is an interpretive or denotational framework applied to a specification or to projected execution data. When a system chooses to represent such descriptions internally, they may themselves be admitted and projected like other facts. What matters here is that neither constitutes a second admission rule. This does not make ωτ optional: the ontology referenced by the executable abstraction remains a constitutive part of admission, whereas the calculus is agnostic to the external language and interpretive framework used to express or analyze it.
Time, state, architecture, and process are projection-defined execution views, while syntax and external semantic interpretation are contingent representational layers. None creates a second execution axis: every admitted event remains one entry in C, and these views only select, order, specify, or interpret that execution record.
The calculus therefore separates execution from contingent representation and realization. Its invariant is the Axiom 0 interaction among shared C, the active ontological realization procedure, and the active eschatological criterion. Representation, methodology, and infrastructure may vary provided they preserve that admission structure and the execution information required by the stated results. Methodological agnosticism also permits structural analogies between distinct domain ontologies without requiring equality or logical equivalence; such analogies may guide specification but introduce no new admission rule.
Executional invariance. Within the representation class stated in this paper, local admission has the same Axiom 0 form across programming languages, modeling methodologies, and discrete physical realizations. This is a claim about execution representation, not computational universality or superiority over another model of computation.
Infrastructure agnosticism is conditional on four operational capabilities. A discrete realization must be able to generate event records, extend the canonical context, preserve recorded order and causal provenance, and project by abstraction. The shared C is a logical/canonical execution record, not a requirement that storage be physically centralized: distributed realizations may partition or replicate physical storage if they preserve the same execution invariants. This four-capability view is distinct from §5.1’s five constitutive realization conditions: the four are capabilities an infrastructure supplies; the five are calculus components those capabilities realize.
The scope is representation-based rather than domain-based. A system is within scope whenever its execution can be represented by binary-relational abstractions whose admissions are evaluated against a shared accumulated C. The set of executable relations need not be fixed before execution begins: a governing abstraction may admit a specification event introducing a new relation R′ and immutable versions of its associated ontological specification ⌜ωτ′⌝ and criterion ⌜τ′⌝, after which the new abstraction participates through the same admission mechanism. Earlier specification versions remain immutable and addressable for replay. The executable relational structure may therefore evolve while all admitted changes remain in the same append-only record.
4.3.5. Deterministic Verification Replay
Corollary 6 (Deterministic Verification Replay). Assume append-only C, immutable versioned specification references, deterministic interpretations of the referenced ωτ and τ versions, and the event-record invariant that each admitted event contains or losslessly references the realization originally tested. Then every admitted event is deterministically verifiable from the recorded execution prefix and the specification versions in force at its admission. Environmental source occurrences need not be regenerated; verification uses the recorded realization. Events never admitted into C are outside the replay claim.
Proof. Let ei+1 be an admitted event and Ci its preceding prefix. Append-only order uniquely fixes Ci. The event lineage resolves immutable ontology and criterion versions, and the event payload supplies the original realization or a lossless reference to it. The referenced interpretations are deterministic; τ is total and single-valued on the recorded pair (Ci, ω). Re-evaluating that criterion therefore yields the same admission value. Environmental generation is irrelevant because verification uses the realization already recorded. ∎
An environmental abstraction illustrates the distinction directly: its external source occurrence need not repeat under generative re-execution, yet verification replay evaluates the recorded realization against the same preserved prefix and immutable specification versions. The composite address identifies the event’s specification lineage and recorded instance. Deterministic verification replay is therefore a structural consequence of Axiom 0, append-only history, and immutable versioned specification references. Under the assumptions of Corollary 6, this establishes R2 for admitted execution. For evolutive AI, this is the minimum accountability condition needed before previous executions can be treated as reliable evidence rather than opaque outcomes of a changing system.
4.4. Admissibility Space under a Fixed Specification-and-Invocation Regime
Section 3.2 and Section 3.3 define how one realized execution is constituted. This section has two complementary tasks. First, it asks where branching, persistence, and termination possibilities reside before one path becomes the recorded execution. Second, it discharges S0 for the fixed-regime finite-branching construction by showing that the reachable local execution products remain standard Borel and that the complete finite/infinite outcome space is Borel in a standard coding. The admissibility tree is analytical only; it introduces no second execution mechanism.
4.4.1. Local Execution versus the Global Space of Executions
The tree constructed here is a meta-level representation of admissible execution records, not the operational semantics of one abstraction. Axiom 0 produces one realized append-only sequence C. Branching belongs to the possibility space; concrete execution remains one singular recorded branch. The question of this section is therefore: under fixed ontological specifications, criteria, and active invocations, what is the structure of the complete admissibility space?
Invocation scope. The admissibility tree is relative to a fixed specification-and-invocation regime: the active immutable specification versions and the active invocation instances are fixed for the tree being analyzed, including any external occurrences already bound to environmental invocations under §3.2.2. Cand(σ) therefore collects the at-most-one realization contributed by each active invocation at σ. Changing the specification versions or invocation set induces a different tree. Finite branching requires only that finitely many invocation instances contribute candidates at any finite node; it imposes no global finiteness assumption on the environment or on the universe of possible abstractions.
Notation. In §§4.4–4.5, τ(e, σ) := τ(σ, e) abbreviates the canonical context-first criterion (§3.2.3) only when e denotes a candidate realization in Cand(σ), not a Rec-encoded event record. For a recorded event, the criterion is evaluated on its preserved realization. If no ωτ produces e at σ, then e is absent from Cand(σ) and τ is not reached. This convention changes neither the three-stage factorization of §3.2.8 nor the single-valuedness of individual ωτ.
In the definitions below, Ai ranges over active invocation instances of the fixed regime, rather than merely over distinct abstraction specifications. Two invocations of the same abstraction specification are therefore distinct contributors whenever they are distinct invocations in that regime.
Let ET be the event carrier used for the fixed-regime tree. Write σ = ⟨e1, …, en⟩ for a finite passage and σ↾i for its prefix of length i; σ is itself the accumulated context. Let Cand(σ) = {ωτi(σ) : Ai shares σ, ωτi(σ)↓} collect the at-most-one realization contributed by each active invocation, and let Succ(σ) = {Rec(Ai, σ, ωτi(σ)) : Ai shares σ, ωτi(σ)↓, τi(σ, ωτi(σ)) = true}. Thus Cand(σ) contains realized candidates, while Succ(σ) contains the event records constructed from admissible candidates; both are indexed by the fixed regime.
The admissibility tree is T = {σ : ei+1 ∈ Succ(σ↾i) for all i < |σ|}, with [T] its infinite branches. Finite terminating executions are terminal nodes Term(T) = {σ ∈ T : no proper one-step successor of σ lies in T}. By Lemma 2 (§4.4.3), every level Tn is finite. Because every event address has a fixed natural-number code, finite nodes are explicitly coded by finite sequences of naturals; hence T and Term(T) are countable. The full outcome space is Exec(T) = [T] ∪ Term(T).
A trace records what was realized; a state space records what may be represented; T records what may be admitted under the fixed regime. It is therefore the natural meta-object for the cardinality and termination analysis that follows.
4.4.2. Admissibility Tree
Lemma 1 (T is a tree). If σ ∈ T and m ≤ |σ|, then σ↾m ∈ T.
Proof. Membership σ ∈ T is the conjunction of e_{i+1} ∈ Succ(σ↾i) over i < |σ|. For σ↾m one requires the same conjunction over i < m, and since (σ↾m)↾i = σ↾i for i ≤ m, this is a sub-conjunction of one that already holds. ∎
The proof follows directly from the structure of Axiom 0: Cand is well-defined at each node from the active invocation instances and their single-valued realizations, τ is evaluated over the accumulated context, and the context is append-only. No retroaction ⟹ locality ⟹ prefix-closure.
4.4.3. Prefix Closure and Finite Branching
Lemma 2 (finite branching). Succ(σ) is finite for every σ ∈ T.
Two facts suffice: under the fixed-regime finite-contribution assumption of §4.4.1, finitely many invocation instances produce defined realizations at each finite node σ, and each invocation contributes at most one such candidate (§3.2.2). Each successful candidate produces at most one successor event through the deterministic constructor Rec. Hence both Cand(σ) and Succ(σ) are finite. No global finiteness assumption on the ontology or the invocation universe is required.
Proof. Only finitely many invocations at σ contribute defined values, each at most one, so Cand(σ) is finite. The Boolean criterion filters those contributions, and Rec deterministically constructs at most one event record per successful invocation. Therefore Succ(σ) is finite. ∎
The ontology may therefore be unbounded in the limit even though each admission step is finite. Axiom 0 never evaluates an actually completed infinite context: every admission is decided over one finite recorded prefix.
4.4.4. Compactness and Measurability
For n ∈ ℕ let An be the finite set of event records that occur at position n on some node of T of length at least n+1. If [T] = ∅, compactness is trivial. Otherwise every infinite branch is an element of the product ∏n An, with each An given the discrete topology.
Proposition 2 (closed and compact path space). Under the fixed-regime finite-branching assumptions, and hence compact in the standard product topology [45].
Proof. If p ∉ [T], some finite prefix p↾n is not a node of T; the cylinder determined by that prefix is therefore an open neighbourhood of p disjoint from [T], so [T] is closed. Each An is finite and discrete. The countable product ∏n An is compact and metrizable in the standard product topology, and a closed subset of a compact space is compact. ∎
The path space is therefore compact, metrizable, and zero-dimensional and may be embedded as a closed subspace of Cantor space. Since closed sets are Borel, [T] is measurable with respect to any Borel measure defined on the coded path space; the calculus itself supplies no probability measure.
Remark (Topological interpretation of execution). The calculus does not treat execution merely as an extensional collection of outcomes: admissible histories carry ordering, prefix dependence, and constitutive admission conditions. The product topology represents the structure of possible execution histories through finite-prefix cylinders, while the associated Borel σ-algebra provides the measurable representation used for their analysis. Thus, Borel structure is appropriate not because individual execution events are topological spaces, but because repeated admission generates a topologically structured space of admissible execution paths.
These are meta-level properties of the fixed-regime possibility space, not execution primitives. The fixed address coding gives an explicit coding of every finite node and of every event position used in this analysis.
4.4.5. The Dichotomy
For a finitely branching coded tree, [T] is a closed subset of a Polish path space. The standard perfect-set/Cantor–Bendixson theorem for closed subsets of Polish spaces therefore yields the dichotomy used below [45]: a closed path space is either countable or contains a nonempty perfect subset. A nonempty perfect subset corresponds to the body of a perfect pruned subtree of T.
The argument here is purely meta-level. It is independent of the operational claim that Axiom 0 itself invokes no Choice selector; no stronger foundational claim about the descriptive-set-theoretic theorem is required by this paper.
When an explicit branch must be selected inside the coded finitely branching tree, the fixed natural-number address code supplies a definable least-code successor among candidates satisfying the stated property. This observation concerns the meta-level coding only and does not add a selector to Axiom 0.
Theorem 2 (cardinality dichotomy of the fixed-regime path space). Exactly one of the following holds: (a) T has a nonempty perfect pruned subtree, in which case |[T]| = 𝔠; or (b) T has no nonempty perfect pruned subtree, in which case [T] is countable.
Proof. By Proposition 2, [T] is closed in a Polish space. The perfect-set form of the Cantor–Bendixson theorem [45] implies that an uncountable closed set contains a nonempty perfect subset P, while if its perfect kernel is empty it is countable. The set of finite prefixes of P forms a perfect pruned subtree of T, and conversely the body of any perfect pruned subtree is a nonempty perfect subset of [T]. Any nonempty perfect Polish subspace has cardinality 𝔠, while the fixed natural-number coding embeds [T] into ℕ^ℕ and therefore gives |[T]| ≤ 𝔠. Hence case (a) has cardinality exactly 𝔠; otherwise case (b) is countable. The cases are mutually exclusive. ∎
Finite terminal executions do not alter this dichotomy: Term(T) is countable, so Exec(T) = [T] ∪ Term(T) is either countable or of cardinality 𝔠. Countability still does not imply termination because a countable closed path space may contain isolated infinite branches.
Accordingly, three execution-space regimes remain useful: a terminating regime with no infinite branch; a persistent non-branching regime with one or more isolated infinite branches but no perfect subtree; and a perfect-splitting regime with a nonempty perfect subtree. These are properties of one fixed specification-and-invocation regime.
A fixed-regime tree is well-founded exactly when it has no infinite branch. Theorem 4 (§4.5.4) gives a sufficient condition for finiteness of recursive descent inside such a regime; it does not claim that every fixed regime is well-founded.
An evolutive specification change is orthogonal to the above classification: admitting a new ontological or criterion version ends the regime analyzed by T and induces a new tree T′ for subsequent execution.
4.4.6. Proof about Executions and Proof in Execution
Observation (per-step admissibility lifts to branches). By the definition of T (§4.4.1), each successor event is a Rec record of a realization for which τ(σ,ω) = true at the preceding prefix. Hence every p ∈ [T] satisfies its active admission criterion at each step, as do all finite paths in T.
A family-level proof can establish a property of all branches, but it does not identify which branch was realized. Per-step admission retained with OEE coordinates adds attribution: it records the context and governing specification under which the realized event entered C. Governance requires this second property in addition to ordinary family-level soundness.
The implication therefore runs one way. Per-step admissibility lifts to a property of every admissible branch, but a branch-level or family-level property does not reconstruct the provenance of a particular admitted step. This distinction motivates the replay result of §4.3.5 and the meta-level admissibility space of §4.4.
4.4.7. S0: Borel Execution Closure
Local reachable carriers. Let Er be the set of event records appearing on nodes of the fixed-regime tree T, and let Ωr = ⋃{Cand(σ) : σ ∈ T}. By Lemma 2 every finite level contributes finitely many nodes and each node contributes finitely many candidates; because T is countable, both Er and Ωr are countable. Equipped with their discrete σ-algebras, they are standard Borel spaces, as is the Boolean carrier 𝔹. Standard Borel spaces are closed under finite and countable products [45]. Hence the finite-context carrier Er<ω and the local typed execution carrier Er<ω × Ωr × 𝔹 remain standard Borel.
Corollary 7 (S0 — Borel execution closure). Under the fixed-regime finite-branching assumptions, the OEE execution system satisfies S0. Let Yr be the disjoint union of the finite-sequence carrier Er<ω and the infinite product ∏n An. The terminal outcome set Term(T) is countable and therefore Borel in the first summand. By Proposition 2, [T] is closed and therefore Borel in the second summand. Consequently Exec(T) = Term(T) ⊔ [T] is Borel in Yr. Together with the local product closure above, the complete fixed-regime execution construction remains within the required measurable representation class.
Proof. Countability of T follows from finite levels; countability of Er and Ωr follows from countable unions of finite contributions. Finite and countable products and countable disjoint unions of standard Borel spaces are standard Borel [45]. Proposition 2 supplies closedness of [T], while Term(T) is countable. The two components are therefore Borel in their respective summands, and their disjoint union is Borel in Yr. ∎
Evolution and S0. An admitted ontology or criterion change ends the regime r and induces a new regime r′ with its own coded carriers and admissibility tree. S0 is therefore required and verified regime by regime; the calculus does not require a completed global limit containing all future regimes.
4.5. Order, Termination, and Evolutive Change
The companion application [9] used monotonicity as a sufficient condition for a Tarski fixed-point result. The present calculus separates four questions that should not be conflated: preservation of an already-recorded admission, existence of a fixed point for a monotone set-factored admission operator, finiteness of one recursive decomposition episode, and terminality of a fixed execution regime. Append-only C guarantees the first. Theorem 3 addresses the second under explicit monotonicity and set-factoring assumptions. Theorem 4 addresses the third under a supplied well-founded measure. §4.5.5 defines the fourth independently.
4.5.1. Admission Preservation
Definition 6 (monotone criterion). τ is monotone if τ(e,σ) = 1 and σ'≽σ imply τ(e,σ') = 1 — once admissible, always admissible.
Monotonicity is useful because it supports fixed-point arguments, but it excludes many criteria that consume bounded resources or whose permission changes as the context grows.
For example, τbalance may reject a transfer once an accumulated limit has been consumed. Budgets, quotas, rate limits, and deadlines have the same form: a candidate admissible against one prefix may cease to be admissible against a later prefix without invalidating the historical fact that an earlier admission was correct when made.
Lemma 3 (preservation of recorded admission facts). Let e be admitted against prefix σ↾n under immutable criterion version ⌜τv⌝. Then the historical proposition τv(e,σ↾n) = 1 remains deterministically verifiable from every later context that preserves that prefix and the version reference.
Proof. Append-only execution preserves σ↾n exactly, and versioned specification discipline preserves the identity and interpretation of ⌜τv⌝. The proposition evaluated at admission is therefore a permanent fact about that recorded prefix and criterion version, irrespective of whether the same candidate would remain admissible under a later prefix or a later criterion version. ∎
Non-monotonicity does not entail retroactive invalidation. A recorded admission remains valid under the prefix and specification version in force when it occurred, even if the same candidate would no longer be admissible at a later prefix.
4.5.2. Monotone and Non-Monotone Criteria
Definition 7 (anti-monotone criterion). τ is anti-monotone in a resource r if r is non-decreasing along admissions and τ(e,σ) = 0 implies τ(e,σ') = 0 for all σ'≽σ.
4.5.3. Context-Sensitive Non-Commutativity
Proposition 3 (context-sensitive non-commutativity). Non-monotone admission can make serialization order semantically relevant: there exist a context σ and two individually admissible events e and f such that σ⌢e⌢f ∈ T but σ⌢f⌢e ∉ T.
Proof. Define a derived projection b(σ) = 1 exactly when no closing event f occurs in σ. Let e be admissible when b(σ)=1, and let f be always admissible. At the original σ with b(σ)=1, both events are admissible. If e is admitted first, b remains 1 and f can still be admitted, so σ⌢e⌢f ∈ T. If f is admitted first, the extended context contains the closing event, hence b(σ⌢f)=0 and e is no longer admissible; therefore σ⌢f⌢e ∉ T. No mutable state outside C is used: b is a projection of the recorded context. ∎
This is precisely the case where the admission of f changes the context relevant to a later evaluation of e (§4.1.4–§4.1.5): f does not depend on e — f is always admissible — but e’s continued admissibility depends on whether f has already been admitted, since f’s own effect on the shared flag is what later closes e off. This is unlike the independent-enabling case of §4.1.5, where several abstractions are admissible against the same already-fixed context and intervening independent writes preserve that admissibility. Order dependence is therefore a property of the admission conditions, not of serialization alone.
4.5.4. Fixed Points and Well-Founded Termination
Theorem 3 (least fixed point under monotone set-factored admission). Fix a specification regime whose meta-level admission decision factors through the set S ⊆ Ω of already admitted realizations: contexts with the same admitted realization set induce the same predicate a(ω,S). Assume a:Ω × (Ω) → {0,1} is monotone in S, meaning S ⊆ S' and a(ω,S) = 1 imply a(ω,S') = 1. Define Φ(S) = S ∪ {ω ∈ Ω:a(ω,S) = 1}. Then Φ is monotone and inflationary on the complete lattice ((Ω),⊆), has a least fixed point, and its transfinite iteration from ∅ stabilizes at that least fixed point. Proof. If S⊆S′ and x∈Φ(S), either x∈S⊆S′⊆Φ(S′), or a(x,S)=1 and monotonicity gives a(x,S′)=1, so x∈Φ(S′). Thus Φ is monotone; it is inflationary by definition. Tarski’s theorem gives a least fixed point. Define at limits. This sequence is increasing. By Hartogs’ theorem [46], there is an ordinal θ that does not inject into (Ω); if the iteration had not stabilized before θ, α→Sα would give such an injection. Hence Sγ = Sγ+1 for some γ<θ, so Sγ is fixed. Induction shows Sα is contained in every fixed point at every stage, making the stabilized fixed point the least one. ∎
Theorem 4 (finite recursive descent under a supplied well-founded measure). Let r be the contexts reachable during one recursive decomposition episode, with C⇝rC' denoting a recursive admission that advances that decomposition. Suppose there is a map μ:r → (W,≺) into a well-founded strict order such that C⇝rC' implies μ(C')≺μ(C). Then every recursion chain C0⇝rC1⇝r… is finite. Proof. An infinite recursion chain would yield an infinite strictly descending sequence μ(C0)≻μ(C1)≻… in W, contradicting well-foundedness. ∎
Theorems 3 and 4 answer different questions and have different hypotheses. Theorem 3 applies only to regimes whose admission decision factors through an admitted-realization set and is monotone there; general sequence-sensitive criteria need not satisfy that hypothesis. Theorem 4 concerns finiteness of one recursive decomposition episode and does not imply that the surrounding system terminates. Neither theorem claims universal convergence.
Concrete finite bounds are application-specific corollaries of Theorem 4. A finite eschatological hierarchy, bounded budgets, quotas, or other resources may be combined into a global well-founded measure if the specification proves strict descent at every recursive admission. The calculus does not derive such a measure or a universal numerical bound from hierarchy depth alone.
4.5.5. Persistent Preemption and the Boundary
Oscillatory criteria need separate treatment. An active-capacity condition, for example, may rise on admission and fall on completion and therefore be neither monotone nor anti-monotone. Where no well-founded measure or other convergence argument is supplied, non-convergence remains a real possibility. A governing abstraction can respond only to evidence available in C or to an explicitly admitted evaluation signal; Axiom 0 does not create a record of unsuccessful evaluations by itself.
Terminality is defined relative to a fixed specification and invocation regime r, including the environmental invocations already bound in that regime. Write C ⇝_r C′ when one active invocation in r can extend C to C′ by Axiom 0. Then
Terminalr(C) ⟺ ∄C′ (C ⇝_r C′).
Thus terminality means that the current fixed regime has no admissible next extension; it does not mean that every previously pending possibility was admitted. A later external occurrence or an admitted specification change defines a new invocation/specification regime rather than a hidden continuation of the terminal one.
4.5.6. Governing Abstractions and Evolution
Axiom 0 has two local outcomes for a fixed invocation: admission, when Collapse holds, and preemption otherwise. It produces no rejection event. If refusal, timeout, persistent-preemption evidence, or a terminal decision must become part of execution, a governing or diagnostic abstraction must admit that fact explicitly.
Evolution occurs when a governing abstraction admits and activates a new executable specification version, (⌜ωτ⌝,⌜τ⌝) → (⌜ωτ′⌝,⌜τ′⌝). Earlier versions remain immutable and addressable for replay. The specification change itself is an ordinary Axiom 0 admission; after activation, subsequent invocations use the new operational interpretations. As stated in §4.4.5, this admission ends the previous fixed regime and induces a new admissibility tree T′.
Deterministic verification replay (§4.3.5) and shared admission semantics for governance and execution (§4.3.3) are not themselves evolution. Together they make evolution accountable: replay establishes what was admitted and under which governing specification, while a governing abstraction can change that specification through the same admission mechanism used for ordinary execution. A system is evolutive exactly when such a specification change is itself admitted.
Evolution is therefore represented by governing specification changes admitted through the same execution mechanism, rather than by an additional execution primitive.
Evolutivity is independent of the cardinality regime of §4.4.5. A governing change may occur once, finitely many times, or indefinitely; it may create new branching possibilities or may reduce them. Thus evolutivity neither implies a continuum of executions nor implies non-termination. It is the endogenous capacity to admit changes to the executable specification while preserving one accountable execution record.
This distinction also separates ordinary regulation from structural evolution. A governing abstraction may regulate execution without changing (ωτ, τ), or it may admit a new specification when the current one no longer supports the required continuation. Both acts remain ordinary admissions; only the second is evolutive. Under OEE closure and immutable versioning, admitting the governing specification change through the same mechanism as ordinary execution closes R1. In an evolutive AI realization, policy, ontology, tool-use rules, or other executable specifications may therefore change without creating a second, non-replayable governance history.
Design as governance. Specification and redesign are software-lifecycle activities, but they need not remain outside execution. When design decisions are delegated to governing abstractions with explicit specifications, the resulting ontology, criterion, policy, model, or tool-use changes become effective only through ordinary attributable admission. This makes design, deployment, operation, monitoring, and governed redesign representable in one accountable execution loop and provides a formal setting in which end-to-end automation of software lifecycle processes—DevOps, MLOps, LLMOps, or future operational paradigms—can be analyzed without moving specification change outside the replayable execution history.
5. Realization and Applications
Section 3.1, Section 3.2, Section 3.3, Section 3.4 and Section 3.5 establish the calculus independently of implementation. This section first states the minimal realization contract and then follows one governed transfer example through admission, policy change, replay, and compensation. The example is deliberately conventional: although R1 and R2 are motivated in part by evolutive AI, the same execution-level problem also appears in conventional settings where correctness-relevant nondeterminism, policy change, and auditability meet. The examples demonstrate how the formal roles map to software; they introduce no additional axioms or execution primitives.
5.1. Minimal Realization Conditions
Five minimal realization conditions remain sufficient at the execution level: an append-only context C, an executable abstraction able to produce a candidate realization, an explicit eschatological admission criterion τ, an explicit ontological specification interpreted by ωτ, and preemption with re-evaluation as the relevant context grows. The service decomposition below makes the resulting implementation contract explicit without adding a new programming language or runtime.
Table 5.
Minimal realization conditions.
| Calculus construct | Illustrative software realization |
|---|---|
| Empty set ∅ | Initial empty persistent execution context |
| Aτ / Execute(Aτ, C) | Executable abstraction exposing realization and criterion behavior; Axiom 0 admits only when the active realization is defined and the criterion is true. |
| Eschatological criterion τ | Versioned deterministic Boolean API/predicate over the relevant context and realized candidate. |
| Ontological specification / ωτ | Versioned domain/interface specification and its deterministic partial realization procedure. |
| Preemption | Re-attempt realization and criterion evaluation when relevant context growth occurs. |
| Event e | Addressed event record ⟨(idesh, idont, idinst), payload⟩; normalization is an implementation choice subject to §3.2.6 assumptions |
| Context C | Persistent append-only execution store preserving the canonical record from ∅. |
| Projection πA | Key-prefix lookup over the composite key; O(log card(C) + card(result)) with a suitable index |
| Layered architecture L | Set of stateless services sharing one knowledge store, each with τi ⊏ τarch |
| Axiom 0 kernel K0 | Fixed admission/orchestration component: invokes the active realization and criterion APIs, constructs Rec on true, and appends the event. |
| Event Horizon EHα | Optional ontology-defined local context/interface; for separated systems, may bind an external admitted event/reference through an environmental abstraction. |
Any substrate satisfying these conditions realizes Axiom 0 as stated in §3.2.5. Abstractions may be coordinated by queues, schedulers, brokers, or other implementation mechanisms, but no such mechanism is an additional semantic primitive of the calculus: correctness-relevant interaction is represented through admissions to and evaluations over the shared context C.
Not every deployed system already satisfies these conditions. Memoryless combinational systems have no accumulated C; systems that permanently discard preempted candidates provide no revisable preemption; systems whose admission logic is distributed implicitly across implementation layers provide no explicit τ. Such systems may be represented within the calculus, but the accountability and evolutive properties proved here belong to realizations that preserve the stated execution invariants.
The calculus does not require a new programming language, runtime, or software architecture. §4.3.4 establishes representation, methodological, and infrastructure agnosticism: any process whose execution can be represented as admitted events over an accumulating context can use the same admission structure. In implementation terms, correctness-relevant software design can be exposed primarily through ontologically specified executable APIs, while Axiom 0 supplies the invariant admission kernel. Those APIs may be implemented as ordinary functions, modules, processes, microservices, workflows, AI components, or whole relational subsystems, provided their externally visible contracts satisfy the calculus and preserve the information required by the stated results.
5.1.1. Ontological API Design and the Fixed Axiom 0 Kernel
Designed specifications, fixed execution law. For an application, the realization ontology and eschatological criterion are the domain-variable specifications. Their operational interfaces may be written Sω:Dω⇀Ω and Sτ:Dτ×Ω→𝔹. Axiom 0 supplies the fixed kernel K0: it resolves or invokes the active specification APIs, obtains at most one realization, evaluates the Boolean criterion, and records the event only when the result is true. Thus software evolution may change Sω and Sτ while the constitutive law of admission remains fixed.
Sω, Sτ variable by design; K0 fixed by the calculus
Three logical invocations. A direct service-oriented realization may expose realization, criterion, and Axiom 0 as three calls for one admission attempt. The first two are specified by the application; the third executes the invariant three-stage rule. A concrete implementation may physically fuse these calls, but their logical separation must remain recoverable when attribution and replay are claimed.
5.1.2. Event Horizon as the Interaction Interface
Definition (Event Horizon). Let Vα be the ontology-defined visibility/localization map used by an invocation of executable abstraction Aα over context C. The event horizon EHα(C)=Vα(C) is the abstraction-relative part of the execution context available to that invocation. It is an interaction interface rather than a second execution context: an event admitted by one abstraction can affect another when it becomes visible within the receiving abstraction’s event horizon. The base calculus remains more general and permits τ to evaluate the complete prefix.
For cross-domain interaction, the environmental designation identifies the source of a bound occurrence, not another admission semantics. An event or immutable reference admitted in system A may be exposed through the interaction horizon H_AB to an invocation in system B; it becomes an execution fact of B only when B’s own eschatological criterion admits it through Axiom 0.
e ∈ C_A → H_AB(e) → ω_B(e) → τ_B(C_B,ω_B(e)) → C_B′
5.2. Running Example: Governed Transfer Execution
Consider one TransferFunds abstraction Atransfer = (Rtransfer, ωtransfer, τtransfer) operating over the shared context C. For a fixed invocation, ωtransfer yields at most one transfer candidate, for example a request to move $50 from account a to account b. The criterion τtransfer may combine balance, fraud, authorization, and accumulated-limit conditions conjunctively over the complete prefix C. Axiom 0 appends the addressed transfer event only when that candidate exists and the criterion is true.
The running example from §1 is now explicit. A $50 transfer admitted after a fraud check passes and an otherwise identical $50 transfer admitted later under an authorized override have the same extensional payload but different specification lineage and execution coordinates. The forgetful map U may identify their payloads; the execution record does not. This is the practical content of the lifting developed in §§3.1–4.2.
Accumulation matters when several invocations share C. If repeated sub-transfers are individually valid but a system-level limit is history-sensitive, each new admission changes the prefix against which the next invocation is evaluated. The criterion therefore sees the aggregate execution history rather than an isolated payload. Non-monotone limit or quota conditions fit the order-sensitive case of §4.5.3 without retroactively invalidating earlier admitted events.
Governance uses the same mechanism. Suppose policy version τv allows one limit and a governing abstraction later admits a new immutable version τ_{v+1}. The specification-change event is itself appended through Axiom 0; subsequent transfer invocations resolve the new version, while earlier transfer events retain the address of τv. No second control log or external policy history is needed for attribution.
Verification replay then reconstructs each transfer’s preceding prefix, resolves the immutable ontology and criterion versions recorded in its lineage, and re-evaluates the recorded realization. A later policy change does not rewrite the historical decision. The example therefore instantiates both target requirements: governing change remains inside execution (R1), and admitted acts remain deterministically verifiable under the versions that governed them (R2).
Compensation is represented in the same way. A reversal, timeout response, or manual correction is not a privileged exception to the calculus; it is another executable abstraction whose own criterion reads the relevant facts already admitted in C and, if satisfied, appends a compensation event. §5.4 states the important boundary: an unwritten failed evaluation cannot trigger compensation unless a separate diagnostic or timeout abstraction first makes the relevant condition an admitted fact.
External realizations require no new rule. A physical measurement, sensor sample, or result returned by an external or quantum service may be bound to an environmental invocation and treated as its ontological realization; it acquires executional status only if the active criterion admits it against C. The calculus makes no quantum-specific claim about the mechanism that produced the measurement.
5.3. System Purpose, Requirements, and Ethics
Definition 8 (Conjunctive system criterion). As one system-level construction, let τΣ:E<ω × Ω → {true,false} be the conjunction of functional, non-functional, and ethical admission predicates, τΣ = τF∧τN∧τE. For a realized candidate ω = ωτ(Cn), admission under this construction requires ωτ(Cn)↓ and τΣ(Cn,ω) = true. The three predicate classes then have identical formal status at the admission boundary; their substantive content remains a domain-specification problem.
τF validates the functional continuation; τN and τE restrict admission according to non-functional and normative conditions. All are evaluated at the same admission boundary. A candidate for which the composite criterion is false is preempted and does not enter C unless a separate abstraction explicitly records the evaluation or its consequence.
Formal equality of requirement types. τF, τN, and τE have the same formal status in the calculus: each is a Boolean component of the governing criterion evaluated over the same accumulated context. No additional execution mechanism is required for safety, compliance, or ethical constraints once their content has been specified as part of τΣ.
The calculus is normatively agnostic. It does not determine the content of τE, nor does it claim that a correct ethical criterion follows from the execution model. It specifies only how any given, effectively evaluable criterion participates in admission. Authoring an adequate τE remains a domain and governance problem.
5.4. Exception Handling and Compensation
Preemption itself produces no event or context extension (§3.2.4), so a compensation abstraction cannot react directly to an unrecorded negative evaluation. A compensation trigger must instead be present in or derivable from the admitted history. One possibility is that a governing abstraction monitors C and admits a compensation event when it detects a relevant pattern, such as a timeout, a retry limit, or an expected event that has not occurred by a specified checkpoint. Alternatively, a diagnostic abstraction can explicitly admit an event recording that the original candidate’s context window has closed without admission. In either case, the compensation abstraction evaluates the resulting information in C. Compensation is an ordinary executable abstraction with its own eschatological criterion τcomp, evaluated over C and admitted through Axiom 0: Acomp: τcomp(C) = true ⇒ C′ = C ⁀ ⟨ecomp⟩ (within the same context). Thus, compensation depends on recorded evidence rather than an unrecorded negative evaluation.
Exception handling can be represented without adding a new admission primitive, provided the triggering condition is itself present in or derivable from C (for example through an admitted timeout or diagnostic event). A compensation abstraction then reads that context and appends its own event under Axiom 0. The result is not that every external failure is automatically recorded, but that represented error-handling paths can remain inside the same append-only execution record.
5.5. Layered and MAPE-K Realizations
A layered architecture can be realized as a family L = {A1, …, Ak} of abstractions sharing one execution context C. Correctness-relevant alternatives may exist in the possibility space, but any alternative that becomes execution is resolved by the active ontological realization procedure and eschatological criterion before admission, and that resolution is attributable in C. No separate correctness-critical histories are required by the calculus between layers; the governance result (§4.3.3) applies at every layer, while layer-specific views remain projections of the same canonical record.
Monitor–Analyze–Plan–Execute over a shared Knowledge base (MAPE-K) [47,48] may be represented as four abstractions sharing one C, each governed by a specialization τi ⊏ τMAPE-K. The calculus does not remove physical communication or computation latency. It removes the need to reconcile separate correctness-critical histories at the semantic level: each stage reads and writes the same execution record, and the control–execution distinction is represented by eschatological specialization rather than by a second control semantics.
The same reading extends to n-tier, microservice, event-driven, agentic, and self-adaptive architectures. Cross-layer waiting can be represented as preemption and re-evaluation over shared context, while physical latency and deployment topology remain implementation concerns. The calculus does not eliminate nondeterminism from the possibility space; it requires correctness-relevant resolution to become attributable before the resulting alternative is admitted as execution.
6. Operational Correspondence and Historical Precedent
The formal results of §§3.1–4.5 follow from the stated proofs. This section proceeds from the closest realization outward: ZTES provides a prior concrete architecture from the same research program (§6.1), recurring engineering mechanisms instantiate parts of the admission pattern (§6.2), and medieval obligationes provide an older functional analogue (§6.3). These correspondences support realizability and recurrence of the structural pattern; they are not premises of the calculus.
The comparisons illustrate how the constitutive conditions of §5.1 can be realized across different domains and infrastructures; the present paper supplies the common execution formalism in which those recurring mechanisms are stated together.
6.1. Prior Formal Realization: ZTES
ZTES [8] is a prior formal realization from the same research program that instantiates several execution requirements developed here in one concrete architecture. It previously established deterministic event serialization, append-only historical knowledge, and the equivalence of governance and operational execution for that architecture. The present calculus abstracts those results: ZTES’s historical knowledge base K realizes C, its purpose-bounded transition discipline realizes admission over context, and its three-phase kernel realizes repeated re-evaluation before commitment. ZTES therefore provides prior evidence that these constitutive conditions can be implemented together, while the present paper supplies the substrate-agnostic formal object and derives its general consequences.
6.2. Correspondence with Engineering Practice
The engineering correspondences take two forms. Long-lived discrete-event mechanisms repeatedly re-evaluate eligibility as the execution record changes; contemporary event-driven architectures independently make durable ordered records central to execution. Neither observation proves Axiom 0, but together they show that accumulated context and admission before commitment recur in several mechanisms relevant to deterministic verification replay and governed continuation.
Tocher’s three-phase kernel and General Purpose Simulation System (GPSS) provide a clear operational correspondence [36,43]. Eligibility is re-tested after the event lists change, so a candidate becomes executable because the accumulated execution context has changed, not because the candidate itself has been rewritten. Current/Future Events List mechanisms in later simulation systems exhibit the same re-evaluation pattern [49]. This is evidence of a recurring admission discipline, not a claim that those simulators are formally verified instances of the present calculus or that their internal structures are identical to C, ωτ, and τ.
The High Level Architecture provides a related but partial correspondence [50,51,52]. Conservative time-management mechanisms gate advancement until a safety condition over accumulated messages is satisfied before the step proceeds; optimistic mechanisms permit speculative advancement followed by rollback. The former therefore shares the pre-admission gating pattern, while the latter does not satisfy the append-only execution condition used by this calculus. No stronger equivalence with Axiom 0 is claimed.
Contemporary event-driven systems—including event sourcing, CQRS, Kafka-oriented pipelines, and Kappa-style architectures—provide durable ordered records that approximate the role of C [29,30,53,54]. Their admission criteria generally remain application-level logic rather than constitutive objects of the architectural formalism. The present calculus identifies the additional structure required to make the admission condition itself explicit and replayable.
A worked application is provided by [9]. In the TransferFunds example, ten $5,000 sub-transfers are ten event instances evaluated against one accumulated context, not ten independent binary relations. A verifier that observes each payload in isolation may admit all ten, whereas a criterion evaluated over the full C can test the aggregate history. The example illustrates the distinction between event instances and the executable abstraction that governs their admission.
Distributed ledgers provide another partial correspondence: an append-only record and an admission mechanism exist at block or transaction boundaries, while application-level governance may still be external to the execution history it governs. The agentic-AI application [9] develops the resulting gap in detail; no additional blockchain result is claimed here.
Across these examples, the recurring pattern is structural rather than technological. Different infrastructures realize pieces of the same execution discipline, which is consistent with the representation, methodological, and infrastructure agnosticism established in §4.3.4.[1]
The examples primarily support realizability and replayability. Endogenous revision of the governing criterion is a stronger property and is addressed formally by §4.5.6; among prior realizations, ZTES provides the closest explicit architectural counterpart.
6.3. Historical Precedent: Obligationes
Medieval obligationes exhibit a functional pattern of governed admission against an accumulating record and a terminal condition [61]. The comparison is historical and structural; it does not imply that Axiom 0 was previously formalized in that practice. Its relevance is narrower: the same organizational need appears wherever successive commitments must remain accountable to what has already been granted.
7. Discussion
The novelty claim is deliberately specific. Contemporary SE roadmaps place AI-driven evolution, verification and validation under uncertainty, runtime reconfiguration, and auditable governance among high-priority directions [2,3,4]. The calculus isolates a common execution boundary relevant to those problems: under the accountability notion studied here, when a correctness-relevant alternative or governing change becomes admitted execution, the rule and context that admitted it must remain attributable within the same execution record. The formal contribution is the executable combination of append-only C, an explicit versioned ontological specification interpreted by a single-valued realization procedure, an explicit eschatological criterion, and Axiom 0 together with its repeated application through Eschatological Induction. Under the stated replay assumptions this structure yields deterministic verification replay; under OEE closure it also supports governing specification change through the same admission semantics as ordinary execution.
A second consequence is representational. Time, state, architecture, syntax, external semantics, methodology, and physical infrastructure are not introduced as additional execution primitives of the calculus. They are treated as projections, specifications, representational choices, or realizations around the same constitutive execution structure. Possibility may branch in the admissibility space, but one realized execution remains one append-only record C. The central representational move can therefore be summarized compactly: classical abstraction suppresses construction to expose structure; executable abstraction restores only the construction information required for accountable computation.
The results are conditional on the stated execution discipline. Deterministic verification replay covers only admitted execution and specification events actually represented in C. A system that permits correctness-relevant mutable state outside C, lets governing acts bypass admission, or discards the information required to reconstruct the active specification does not instantiate the stronger results proved here.
7.1. Interpretation Relative to Other Formal Representations
The SOTA comparison in §2 is not an expressiveness claim. Existing relational, algebraic, process, state-based, and event-sourced formalisms may all be used to specify or interpret parts of an executable abstraction. The distinction made by this paper is constitutive: Axiom 0 fixes how a realized candidate becomes an admitted fact in the shared record, while those other descriptions remain available as specification languages, projections, or analytical views.
Accordingly, no theorem here depends on reducing one formalism to another or on claiming greater computational power. The calculus is intended as a complementary execution layer whose invariant is the explicit interaction of record, realization, and admission criterion; the representational form used to describe those objects may vary.
7.2. Foundational Boundary
Borel-sufficiency boundary. S0 is a requirement on the coded execution representation used by the calculus, neither a claim that arbitrary semantic source domains are intrinsically standard Borel nor a claim that the calculus supplies a probability measure. The product-closure result is applied to the reachable role-typed carriers of a fixed regime; specification change induces a new regime. The local measurable-product interpretation therefore complements, rather than replaces, the ZF rank construction.
The core execution, rank-coding, and projection constructions are formulated in ZF. The meta-level topological analysis of §4.4 invokes standard descriptive-set-theoretic results in their usual classical setting [45]; this paper does not claim that every meta-theoretic theorem used there is itself derivable in ZF without weak choice principles. That distinction does not affect the operational result of §4.2.5: Axiom 0 itself constructs no global selector over an arbitrary family of nonempty sets. The paper also does not claim to derive the axioms of ZF, replace set theory, or establish a bi-interpretation with another foundational theory.
Fixed-point principles require separate foundational care: a fixed-point principle equivalent to the Axiom of Choice is known [62]. This does not affect the operational result of §4.2.5: Theorem 3 is invoked only under its stated complete-lattice and monotonicity assumptions, whereas Axiom 0 itself constructs no global selector.
The same boundary applies to completed infinities. The calculus executes finite admissions over finite prefixes; the admissibility tree of §4.4 is a meta-level mathematical object used to analyze the space of such executions. The calculus itself never needs to hold that completed path space as an execution state.
This separation is sufficient for the present purpose: the paper studies construction and admission, not a reconstruction of general set-theoretic ontology.
Accordingly, foundational analogies beyond the explicit rank and projection results should be read as research directions rather than dependencies of the calculus.
7.3. Convergence Boundary
Theorem 4 (§4.5.4) gives a sufficient condition for finiteness of a recursive decomposition episode whenever the specification supplies a well-founded measure that strictly decreases on every recursive admission. It does not by itself prove that the surrounding execution regime is terminal, and it does not cover recursive regimes for which no such measure is available.
7.4. Open Problems
Perfect-subtree recognition. The existence of a nonempty perfect pruned subtree distinguishes the perfect-splitting regime of §4.4.5, but the present paper gives no general local criterion for recognizing that property directly from an arbitrary family of admission rules.
Order of admission. Under monotone but non-confluent local admission, invocation order may affect which reachable stable record is realized; under non-monotone criteria, order may additionally affect whether a terminal record is reachable. Proposition 3 gives the local non-commutativity result but does not solve the general scheduling problem.
Unbounded dimensional evolution. The calculus permits governing abstractions to introduce new executable relations during execution. A useful characterization of the limit of unbounded relational dimensionality, if one exists, is left open; no execution step itself contains that completed limit.
These open problems are consequences of making the admission structure explicit: they can now be stated precisely without adding new primitives to the calculus.
8. Conclusions
The motivation for this work is practical as well as formal. Software systems are increasingly expected to adapt at runtime, delegate decisions to AI components, and in some cases revise the policies or specifications that govern later behavior. Under the execution model developed here, an adequate abstract system must first remain inside a measurable representation class under the products and iteration required by execution (S0). Under the accountability criterion adopted here, governing change must additionally be executable within the same apparatus it governs (R1), and admitted execution must remain deterministically attributable and replayable (R2). S0, R1, and R2 are requirements of the model developed in this paper; they are not claimed as universal prerequisites for every adaptive or AI system.
The calculus lifts the extensional binary relation into an executable abstraction evaluated over the accumulated context C. Its constitutive roles are the admitted record, the operational realization procedure associated with the active ontological specification, and the eschatological admission criterion. Their asymmetric execution factorization is realization → Boolean judgment → fixed Axiom 0 admission/recording. Repeated Axiom 0 is Eschatological Induction. A concrete system is a family of such abstractions sharing C: recursion follows the depth of one abstraction’s eschatological specialization, while interaction among abstractions occurs because every admission changes the context seen by the others.
Four principal consequences follow under the stated assumptions. First, Corollary 7 (§4.4.7) discharges S0: the reachable local execution products remain standard Borel and the complete fixed-regime outcome space is Borel; Theorem 2 (§4.4.5) further gives its countable/perfect dichotomy. Second, Corollary 5 (§4.3.3), together with admitted specification change in §4.5.6, gives one admission semantics for governing and operational acts and establishes R1 under OEE closure. Third, Corollary 6 (§4.3.5) gives deterministic verification replay for admitted execution and establishes R2. Fourth, Theorems 3 and 4 (§4.5.4) separate least-fixed-point existence under monotone set-factored admission from finiteness of recursive descent under a supplied well-founded measure; neither implies program-level terminality without additional assumptions.
The calculus therefore locates nondeterministic multiplicity in the possibility space rather than in the realized execution record. Possibilities may branch before admission; realized execution remains a single accountable append-only context C. Time, state, architecture, syntax, external semantics, methodology, and infrastructure may vary as projections, specifications, or realizations without changing the constitutive admission rule. The projection analysis locates the Choice boundary in the same structure: Axiom 0 invokes no global choice selector, while the arbitrary-fiber selection problem reappears only after projection to the coordinate-free relational reduct. Under R2, deterministically verifiable histories can also serve as attributable evidence for subsequent learning from a system’s own execution and, where compatible verified records are available, from the experience of other systems; the calculus itself is not a learning algorithm.
The scope is discrete execution represented by finite admissions over finite prefixes. The substantive authoring of domain ontologies or normative criteria remains a software-design task unless that task is itself delegated to a governing abstraction; operationally, those specifications may be exposed as deterministic APIs while the Axiom 0 kernel remains invariant. Ontologically specified APIs, event horizons, and environmental abstractions provide a minimal interface for applying the fixed calculus across local and distributed realizations without introducing a new execution semantics. The calculus does not guarantee convergence without the stated assumptions and does not claim to reconstruct general set-theoretic foundations. Its contribution is the execution calculus itself: a formal object in which measurable execution closure, correctness-relevant resolution, interaction, governance, evolutivity, and deterministic verification replay are expressed through the same admission mechanism. The calculus has not been analyzed in domains beyond those considered here, and no claim of validated applicability is made for such domains; nevertheless, its formal definition does not impose a domain-specific restriction, provided that the execution representation and assumptions required by the calculus are satisfied.
Author Contributions
Conceptualization, M.Š., A.I. and B.R.; Methodology, M.Š., A.I., M.R., S.P., A.L. and B.R.; Formal Analysis, A.I., M.R. and B.R.; Investigation, A.I. and M.R.; Writing—Original Draft Preparation, A.I., M.R., S.P., A.L. and B.R.; Writing—Review and Editing, M.Š., M.R., S.P. and A.L.; Supervision, M.R., S.P., A.L. and B.R.; Project Administration, A.L. All authors have read and agreed to the published version of the manuscript.
Funding
This research was funded, in part, by the Ministry of Science, Technological Development and Innovation of the Republic of Serbia through institutional funding to the University of Belgrade—Faculty of Organizational Sciences (grant number 200151). Additional institutional support was provided by the University of Belgrade—Faculty of Organizational Sciences.
Institutional Review Board Statement
Not applicable.
Informed Consent Statement
Not applicable.
Data Availability Statement
No new data were created or analyzed in this study. Data sharing is not applicable to this article.
Acknowledgments
During the preparation of this manuscript, the authors used ChatGPT (OpenAI, GPT-5.6 Sol), Claude (Anthropic, Claude Sonnet 4.6), DeepSeek (DeepSeek, DeepSeek-V3), and Consensus (Consensus NLP, Inc.) for language refinement, structural and consistency checks, technical formatting assistance, and exploratory literature discovery. The authors reviewed and edited all outputs, independently verified the formal arguments and cited sources, and take full responsibility for the content of this publication.
Conflicts of Interest
The authors declare no conflict of interest.
Appendix A. Rank Separation of the OEE Axes
A.1 The Three Objects and Their Types
Let X be the non-empty rank-homogeneous coding domain obtained from a source carrier by the construction below, and let R ⊆ X × X be a binary-relational reduct. The rank argument compares admitted event records with explicit specification codes. Operational realization and admission functions are interpretations of those codes and are not identified with them for rank purposes.
Convention (rank-homogeneous coding). Rank-homogeneity is a coding choice, not a restriction on source data. Given any nonempty source set D, let α = ρ(D) and map each x∈D to the tagged copy h(x)=⟨x,Vα⟩. This definable injection exists in ZF and every h(x) has the same rank α+2. We therefore take X = h[D] as the homogeneous coding domain. If every x∈X has rank ρX, then ρ(X) = ρX + 1 and the Kuratowski pair ⟨x,y⟩ has rank ρX + 2 = ρ(X) + 1.
Epistemic event-record level. The execution context C is a finite sequence over the event-record carrier RecX = X × X. Each admitted record e ∈ C therefore has rank ρ(e) = ρ(X) + 1 under the chosen coding. The aggregate sequence code for C may have higher rank and is not the epistemic object compared in Theorem 1; the theorem compares the event-record type with the two specification types.
Ontological axis ⌜ωτ⌝. Fix a tagged specification code ⌜ωτ⌝ one construction level above event records, with ρ(⌜ωτ⌝) = ρ(X) + 2 under this convention. The code determines an operational interpretation ⟦ωτ⟧:C⇀Ω, single-valued for a fixed invocation when defined. The function ⟦ωτ⟧ and its specification code are distinct objects; only the latter participates in the rank comparison. For readability the main text writes ωτ(C) for ⟦ωτ⟧(C).
Eschatological axis ⌜τ⌝. Fix a tagged criterion specification code ⌜τ⌝ one construction level above ⌜ωτ⌝, with ρ(⌜τ⌝) = ρ(X) + 3 under the chosen encoding. Its operational interpretation ⟦τ⟧ is a total Boolean predicate once a realization ω exists. Its positive extension Γτ+ = {(σ, ω) : ⟦τ⟧(σ, ω) = true} is a further derived set and is not identified with either the code or the function that defines it.
Coding convention. The exact numerical offsets above are properties of the chosen tagged encoding. Any equivalent coding sufficient for the paper must preserve the strict inequalities ρ(e) < ρ(⌜ωτ⌝) < ρ(⌜τ⌝). The results do not depend on a unique absolute rank for either operational interpretation or for the positive extension Γτ+.
Accordingly, the rank-separation theorem concerns three levels of construction: admitted event records, an explicit ontological specification, and an explicit criterion specification. The active operational interpretations may read the growing context, but their specification identities remain fixed within a version and are changed only by admitting a new specification version. This is the structural separation used by the replay and evolutivity results.
Why three levels. The construction distinguishes what has been admitted, the specification that determines realizable possibility, and the specification that determines admissibility of a realization. These are not three arbitrary geometric directions. They are successive constitutive roles: event → ontological specification → criterion specification. The tagged rank representation supplies one faithful ZF coding of that asymmetry; it is not the source of the asymmetry itself.
Remark (why the criterion is not absorbed into ontology well-formedness). The ontological specification can be well-formed while its realization remains unavailable at one context and available at another; likewise a well-formed criterion can evaluate false at one context and true at another. Specification well-formedness and context-dependent admission are therefore different facts. Axiom 0 evaluates the latter without collapsing the ontology and criterion into one specification role.
A.2 Theorem (Rank Separation) and Proof
Theorem 1 (restated; ZF representation of OEE level separation). Under Appendix A.1, every admitted event record e∈C satisfies ρ(e) = ρ(X) + 1, while the tagged ontology and criterion specification codes are placed at successive higher levels, ρ(⌜ωτ⌝) = ρ(X) + 2 and ρ(⌜τ⌝) = ρ(X) + 3. Hence ρ(e) < ρ(⌜ωτ⌝) < ρ(⌜τ⌝). Only the strict order is invariantly used.
Proof. The definable homogenization gives a carrier X whose event records have the stated uniform pair rank. The ontology and criterion codes are then assigned successive tagged specification levels by the encoding convention. The inequalities follow immediately. ∎
Proposition 4 (orthogonality under explicit versioned specification). Assume that ontology and criterion specifications are explicit versioned parameters of Aτ. Their operational interpretations may read C, and a governing abstraction may later admit new versions, but the active versions are not implicitly inferred from C. Under this assumption, C, ⌜ωτ⌝, and ⌜τ⌝ are constitutively orthogonal: record, realizable-possibility specification, and admission specification remain distinct roles. This claim is separate from rank separation and rests on the explicit-specification discipline.
A.3 Consequences
C1. The active criterion specification is not implicitly derived from C. C may contain an address to the version in force, and later evolution may admit a new version, but the criterion governing the current admission is an explicitly identified specification rather than a value inferred from the record’s payload content.
C2. The active ontological specification is likewise explicit and versioned. Its operational interpretation may depend on C to produce a realization, but the ontological specification itself is not a projection of C.
C3. Ontology and criterion specifications are independently specifiable and separately versioned. The criterion evaluates a realization supplied under the ontology; neither specification role is reducible to the other.
C4. Axiom 0 is the dynamic interaction law of the executable structure. It evaluates the operational interpretations associated with the explicit ontology and criterion specifications against the shared record C. Every executable abstraction has a coordinate-free relational reduct; the reduct alone does not determine the omitted specification versions or admission history.
Remark (separation and interaction). Separation by construction level does not imply isolation. Operational ontology and criterion interpretations interact with C on every invocation. The separation means only that the governing specification versions remain explicit objects rather than being collapsed into the event record they govern.
Remark (what rank alone does not show). Higher rank does not in general imply non-derivability. The non-substitutability result therefore rests on the explicit versioned-specification discipline, while Theorem 1 supplies the compatible rank separation.
A.4 Why the Square, and What Is Not Claimed
Remark (what is not claimed). The theorem does not order the set-theoretic rank of the aggregate history object C against the specification codes, nor does rank separation by itself prove non-derivability. It orders the constitutive record/specification types under the stated coding; non-substitutability additionally uses explicit versioned specification.
A heterogeneous relation R ⊆ A × B is not an endorelation and therefore does not self-compose without an identification or embedding of its codomain back into its domain. The homogeneous carrier X × X used here supplies the canonical endorelation setting for iterative composition. This is a convenience of the execution coding, not a claim that heterogeneous relational chains cannot generate sequences by other constructions.
The event sequence C should not be confused with the graph of Execute. The graph of Execute is the execution relation ExecRel(Aτ) defined in §4.2.3, whose arguments are contexts and admitted events. C is one realized append-only sequence produced by successive applications of that relation. No cardinality comparison between C and X × X is required for the Choice argument of this paper.
The “axes” are therefore levels of constitutive construction and interaction, not vector-space directions: no addition, metric, or bilinear form on X is assumed.
A.5 Scope of the Forgetful Map
The paper uses U only as a set-theoretic forgetful projection from OEE-addressed event records to extensional payloads, together with Red(Aτ)=R at the specification level. No algebraic signature, congruence theorem, or homomorphic-quotient structure is assumed. The only properties used later are those proved in §§4.2.1, 4.2.4, and 4.2.5: distinct events may share one projected payload, proper abstraction projections can be non-injective, and the projected relation may lack the admission structure present in the executable abstraction.
Appendix B. The Rank of the Abstraction and the Location of Choice under Projection
This appendix locates the bundled abstraction relative to its specification components and then locates the classical choice problem after projection. The exact rank of a particular tuple encoding of Aτ is encoding-dependent; the only property used here is that the bundled abstraction is represented strictly above its highest-ranked specification component. The admission test itself evaluates the operational interpretations associated with the referenced specification versions and never requires a global selector over projected relation fibers.
B.1 The Ontological Specification and the Relational Reduct
Appendix A.1 places the ontological specification code ⌜ωτ⌝ above admitted event records. The coordinate-free relation R, the specification code ⌜ωτ⌝, and the operational interpretation ⟦ωτ⟧ are three related but distinct objects: R is the specification-level extensional reduct Red(Aτ); ⌜ωτ⌝ is the immutable ontological specification; and ⟦ωτ⟧ is the single-valued realization procedure used during execution.
B.2 The Abstraction Outranks Its Highest Component
An abstraction is bundled, prior to any admission, from R together with the ontology and criterion specification objects. Under any standard tagged tuple encoding chosen for this paper, its code is placed strictly above its highest-ranked component: ρ(Aτ) > ρ(⌜τ⌝). No exact offset such as +4 is required by any theorem.
This is a statement about the abstraction as a specification object, independent of any later admission. It is not a claim about the rank of the event records that reference the abstraction.
B.3 The Record of an Abstraction Is an Address, Not the Object
What enters C when an abstraction or a new version is registered is not the higher-rank specification object itself, but an event carrying an immutable address/reference to that specification version. The event remains at the event-record level; the referenced specification may occupy a higher rank. This separation is what permits replay to recover the governing version without embedding or mutating the higher-rank object inside ordinary execution events.
B.4 Where the Choice Problem Appears
The family relevant to the Axiom of Choice arises in the projected specification-level relation, not in the operational candidate set of a fixed invocation. Let R = Red(Aτ) ⊆ X × X and, for x in its domain, let Rx = {y ∈ X:(x,y) ∈ R}. After the criterion and execution structure are forgotten, R alone need not determine which member of a nonempty fiber Rx should be selected. For an arbitrary family R = {Rx:x ∈ D,Rx ≠ ⌀}, a simultaneous choice function has exactly the form whose existence full AC guarantees. Particular relations may of course possess definable selectors without AC.
This is deliberately different from Cand(σ) in §4.4.1. There, each individual ωτi contributes at most one realization at a fixed context, and Axiom 0 evaluates that realization by a Boolean criterion. No choice among the members of an arbitrary nonempty set occurs inside Execute.
B.5 Why Axiom 0 Does Not Invoke Such a Selector
Execute(Aτ,Cn), unpacked, evaluates Cn, the single value ωτ(Cn) when defined, and the Boolean value τ(Cn,ωτ(Cn)). It neither constructs nor assumes a global selector over the fibers of the projected relation.
The sense in which the calculus operates without Choice is therefore operational rather than a consequence of a rank inequality: the choice problem appears only after the criterion and execution structure have been forgotten. In the full executable object, the realization procedure and admission criterion are already specified, so Axiom 0 requires no application of the Axiom of Choice.
The rank analysis of B.1–B.3 remains useful for locating the abstraction relative to its constitutive components, but no additional rank-distance theorem for a global choice function is required for this conclusion.
B.6 Reading §2 against This Hierarchy
Several of the formalisms surveyed in §2 reached one or more structures adjacent to the present ontology/criterion distinction without assembling the same executable object. Tarski’s fixed-point theorem guarantees the existence of a least fixed point for a given monotone operator on a complete lattice; it does not supply an append-only execution context with explicit versioned ontology and criterion specifications. Mesarović supplies purposive relational structure but, by scope decision, not the admission mechanism over an accumulated record. DEVS performs admission-like work inside transition functions without separating an explicit history-conditioned criterion as the governing object of execution. In each case, what is missing relative to this calculus is not a generic fact about relations or existence but the combined executable structure: relational reduct, explicit ontology and criterion specifications, shared accumulated context, and Axiom 0 as the local interaction law. The bundle defines Aτ; Axiom 0 supplies its execution dynamics.
References
- Herrlich, H. Axiom of Choice. In Lecture Notes in Mathematics; Springer: Berlin, Germany, 2006; Vol. 1876. [Google Scholar] [CrossRef]
- Pezzè, M.; Abrahão, S.; Penzenstadler, B.; Poshyvanyk, D.; Roychoudhury, A.; Yue, T. A 2030 Roadmap for Software Engineering. ACM Trans. Softw. Eng. Methodol. 2025, 34, 118. [Google Scholar] [CrossRef]
- Sartaj, H.; Ali, S.; Cavalcanti, A.; Esterle, L.; Gomes, C.; Larsen, P.G.; Tefas, A.; Woodcock, J.; Zhang, H. Software Engineering for Self-Adaptive Robotics: A Research Agenda. ACM Trans. Softw. Eng. Methodol. 2026, 35, 276. [Google Scholar] [CrossRef]
- Migliarini, P.; Autili, M.; Inverardi, P.; Pelliccione, P. Ethical Prompt Engineering for AI-Driven SE: Evidence-Informed Interaction-Time Governance Roadmap to 2030. ACM Trans. Softw. Eng. Methodol. 2026, 35, 267. [Google Scholar] [CrossRef]
- Bacchus, F.; van Beek, P. On the Conversion between Non-Binary and Binary Constraint Satisfaction Problems. In Proceedings of the Fifteenth National Conference on Artificial Intelligence and Tenth Innovative Applications of Artificial Intelligence Conference (AAAI-98/IAAI-98), Madison, WI, USA, 26–30 July 1998; pp. 310–318. [Google Scholar]
- Dubois, C. Formally Verified Transformation of Non-Binary Constraints into Binary Constraints. In Functional and Constraint Logic Programming, 28th International Workshop, WFLP 2020; Lecture Notes in Computer Science; Hanus, M., Sacerdoti Coen, C., Eds.; Springer: Cham, Switzerland, 2021; Vol. 12560, pp. 117–128. [Google Scholar] [CrossRef]
- Dechter, R. Decomposing a Relation into a Tree of Binary Relations. J. Comput. Syst. Sci. 1990, 41, 2–24. [Google Scholar] [CrossRef]
- Ivanović, A.; Radenković, M.; Prokhorov, S.; Labus, A.; Radenković, B. Zero Tier Execution Substrate for Evolutionary Software Systems. Systems 2026, 14, 547. [Google Scholar] [CrossRef]
- Radenković, M.; Radosavljević, N.; Labus, A.; Prokhorov, S.; Radenković, B. Evolutive Consensus for Agentic AI: OEE Incompleteness of External Guardrails and the Execution Calculus for Safe Evolutive Agents. Facta Univ. Ser. Electron. Energ. 2026, 39, 723–765. [Google Scholar] [CrossRef]
- Leibniz, G.W. Monadology. In Philosophical Essays; Ariew, R., Garber, D., Eds.; Hackett: Indianapolis, IN, USA, 1989. [Google Scholar]
- Leibniz, G.W. Discourse on Metaphysics. In Philosophical Essays; Ariew, R., Garber, D., Eds.; Hackett: Indianapolis, IN, USA, 1989. [Google Scholar]
- Tarski, A. The Concept of Truth in Formalized Languages. In Logic, Semantics, Metamathematics: Papers from 1923 to 1938. Original work published 1933, 2nd ed.; Corcoran, J., Ed.; Hackett Publishing: Indianapolis, IN, USA, 1983; pp. 152–278. [Google Scholar]
- Tarski, A. A Lattice-Theoretical Fixpoint Theorem and Its Applications. Pac. J. Math. 1955, 5, 285–309. [Google Scholar] [CrossRef]
- Turing, A.M. On Computable Numbers, with an Application to the Entscheidungsproblem. Proc. Lond. Math. Soc. 1937, s2-42, 230–265. [Google Scholar] [CrossRef]
- Turing, A.M. Systems of Logic Based on Ordinals. Proc. Lond. Math. Soc. 1939, s2-45, 161–228. [Google Scholar] [CrossRef]
- Turing, A.M. The Chemical Basis of Morphogenesis. Philos. Trans. R. Soc. Lond. B Biol. Sci. 1952, 237, 37–72. [Google Scholar] [CrossRef]
- Bezruchko, B.P.; Smirnov, D.A. Constructing Nonautonomous Differential Equations from Experimental Time Series. Phys. Rev. E 2000, 63, 016207. [Google Scholar] [CrossRef] [PubMed]
- Bezruchko, B.P.; Karavaev, A.S.; Ponomarenko, V.I.; Prokhorov, M.D. Reconstruction of Time-Delay Systems from Chaotic Time Series. Phys. Rev. E 2001, 64, 056216. [Google Scholar] [CrossRef] [PubMed]
- Prokhorov, M.D.; Ponomarenko, V.I.; Karavaev, A.S.; Bezruchko, B.P. Reconstruction of Time-Delayed Feedback Systems from Time Series. Physica D. 2005, 203, 209–223. [Google Scholar] [CrossRef]
- Sysoeva, M.V.; Ponomarenko, V.I.; Prokhorov, M.D.; Sysoev, I.V. Reconstruction of Time-Delay Systems under External Periodic Driving. Russ. J. Nonlinear Dyn. 2013, 9, 613–625. [Google Scholar] [CrossRef]
- Sysoev, I.V.; Ponomarenko, V.I.; Kulminskiy, D.D.; Prokhorov, M.D. Recovery of Couplings and Parameters of Elements in Networks of Time-Delay Systems from Time Series. Phys. Rev. E 2016, 94, 052207. [Google Scholar] [CrossRef] [PubMed]
- Koronovskii, A.A.; Moskalenko, O.I.; Hramov, A.E. On the Use of Chaotic Synchronization for Secure Communication. Phys.-Usp. 2009, 52, 1213–1238. [Google Scholar] [CrossRef]
- Codd, E.F. A Relational Model of Data for Large Shared Data Banks. Commun. ACM 1970, 13, 377–387. [Google Scholar] [CrossRef]
- Milner, R.; Parrow, J.; Walker, D. A Calculus of Mobile Processes, I. Inf. Comput. 1992, 100, 1–40. [Google Scholar] [CrossRef]
- Hoare, C.A.R. Communicating Sequential Processes. Commun. ACM 1978, 21, 666–677. [Google Scholar] [CrossRef]
- Petri, C.A. Kommunikation mit Automaten. Doctoral Dissertation;Schriften des IIM, No. 2, Technische Hochschule Darmstadt, Darmstadt, Germany, Rheinisch-Westfälisches Institut für Instrumentelle Mathematik, Bonn, Germany, 1962. [Google Scholar]
- Dijkstra, E.W. Guarded Commands, Nondeterminacy and Formal Derivation of Programs. Commun. ACM 1975, 18, 453–457. [Google Scholar] [CrossRef]
- Lamport, L. Time, Clocks, and the Ordering of Events in a Distributed System. Commun. ACM 1978, 21, 558–565. [Google Scholar] [CrossRef]
- Fowler, M. Event Sourcing. 12 December 2005. Available online: https://martinfowler.com/eaaDev/EventSourcing.html (accessed on 1 October 2026).
- Young, G. CQRS Documents. November 2010. Available online: https://cqrs.files.wordpress.com/2010/11/cqrs_documents.pdf (accessed on 1 October 2026).
- Mesarović, M.D.; Takahara, Y. General Systems Theory: Mathematical Foundations. In Mathematics in Science and Engineering; Academic Press: New York, NY, USA, 1975; Vol. 113. [Google Scholar]
- Mesarović, M.D.; Macko, D.; Takahara, Y. Theory of Hierarchical, Multilevel, Systems. In Mathematics in Science and Engineering; Academic Press: New York, NY, USA, 1970; Vol. 68. [Google Scholar]
- Takahara, Y. A Meaning of a Complex System Representation. Trans. Soc. Instrum. Control Eng. 1980, 16, 673–679. [Google Scholar] [CrossRef]
- Drack, M.; Schwarz, G. Recent Developments in General System Theory. Syst. Res. Behav. Sci. 2010, 27, 601–610. [Google Scholar] [CrossRef]
- Zeigler, B.P.; Praehofer, H.; Kim, T.G. Theory of Modeling and Simulation: Integrating Discrete Event and Continuous Complex Dynamic Systems, 2nd ed.; Academic Press: San Diego, CA, USA, 2000. [Google Scholar]
- Tocher, K.D. The Art of Simulation; English Universities Press: London, UK, 1963. [Google Scholar]
- Tarski, A. On the Calculus of Relations. J. Symb. Log. 1941, 6, 73–89. [Google Scholar] [CrossRef]
- Tarski, A.; Givant, S. A Formalization of Set Theory without Variables. In American Mathematical Society Colloquium Publications; American Mathematical Society: Providence, RI, USA, 1987; Vol. 41. [Google Scholar] [CrossRef]
- Takahara, Y.; Mesarović, M.D. Goal Seeking System. In Organization Structure: Cybernetic Systems Foundation; IFSR International Series on Systems Science and Engineering; Springer: Boston, MA, USA, 2003; Vol. 22, pp. 15–35. [Google Scholar] [CrossRef]
- Batz, K.; Katoen, J.-P.; Randone, F.; Winkler, T. Foundations for Deductive Verification of Continuous Probabilistic Programs: From Lebesgue to Riemann and Back. Proc. ACM Program. Lang. 2025, 9(OOPSLA1, Article 95), 421–448. [Google Scholar] [CrossRef]
- Date, C.J.; Darwen, H.; Lorentzos, N.A. Temporal Data & the Relational Model; Morgan Kaufmann: San Francisco, CA, USA, 2003. [Google Scholar] [CrossRef]
- Conant, R.C.; Ashby, W.R. Every Good Regulator of a System Must Be a Model of That System. Int. J. Syst. Sci. 1970, 1, 89–97. [Google Scholar] [CrossRef]
- Schriber, T.J. Simulation Using GPSS; John Wiley & Sons: New York, NY, USA, 1974. [Google Scholar]
- Cicekli, N.K.; Cicekli, I. Formalizing the Specification and Execution of Workflows Using the Event Calculus. Inf. Sci. 2006, 176, 2227–2267. [Google Scholar] [CrossRef]
- Kechris, A.S. Classical Descriptive Set Theory. In Graduate Texts in Mathematics; Springer-Verlag: New York, NY, USA, 1995; Vol. 156. [Google Scholar] [CrossRef]
- Jech, T. Set Theory: The Third Millennium Edition, Revised and Expanded; Springer: Berlin, Germany, 2003. [Google Scholar] [CrossRef]
- Rutten, E.; Marchand, N.; Simon, D. Feedback Control as MAPE-K Loop in Autonomic Computing. In Software Engineering for Self-Adaptive Systems III. Assurances; Lecture Notes in Computer Science; de Lemos, R., Garlan, D., Ghezzi, C., Giese, H., Eds.; Springer: Cham, Switzerland, 2018; Vol. 9640, pp. 349–373. [Google Scholar] [CrossRef]
- Esposito, M.; Bakhtin, A.; Ahmad, N.; Robredo, M.; Su, R.; Lenarduzzi, V.; Taibi, D. Autonomic Microservice Management via Agentic AI and MAPE-K Integration. In Software Architecture. ECSA 2025 Tracks and Workshops; Lecture Notes in Computer Science; Springer: Cham, Switzerland, 2026; Vol. 15982, pp. 105–118. [Google Scholar] [CrossRef] [PubMed]
- Schriber, T.J.; Brunner, D.T.; Smith, J.S. Inside Discrete-Event Simulation Software: How It Works and Why It Matters. In Proceedings of the 2017 Winter Simulation Conference (WSC), Las Vegas, NV, USA, 3–6 December 2017; pp. 735–749. [Google Scholar] [CrossRef]
- IEEE Standard for Modeling and Simulation (M&S) High Level Architecture (HLA)—Framework and Rules. IEEE; Std 1516-2025. IEEE: Piscataway, NJ, USA, 2025.
- Dahmann, J.S.; Fujimoto, R.M.; Weatherly, R.M. The Department of Defense High Level Architecture. In Proceedings of the 1997 Winter Simulation Conference (WSC), Atlanta, GA, USA, 7–10 December 1997; pp. 142–149. [Google Scholar] [CrossRef]
- Fujimoto, R.M.; Weatherly, R.M. Time Management in the DoD High Level Architecture. In Proceedings of the 10th Workshop on Parallel and Distributed Simulation (PADS), Philadelphia, PA, USA, 22–24 May 1996; pp. 60–67. [Google Scholar] [CrossRef]
- Kreps, J. Questioning the Lambda Architecture. O’Reilly. 2 July 2014. Available online: https://www.oreilly.com/radar/questioning-the-lambda-architecture/ (accessed on 1 October 2026).
- Kreps, J.; Narkhede, N.; Rao, J. Kafka: A Distributed Messaging System for Log Processing. Proceedings of NetDB’11, Athens, Greece, 12 June 2011; pp. 1–7. [Google Scholar]
- Atamian Hahn-Petersen, L.; Hansen Eeg, S. How Agentic AI Is Reshaping Supply Chain Resilience through a New Generation of Start-Ups; World Economic Forum, 24 September 2026; Available online: https://www.weforum.org/stories/supply-chains-and-transportation/agentic-ai-reshaping-supply-chain-resilience/ (accessed on 1 October 2026).
- Metzger, D. Why Autonomous Orchestration Is the Next Frontier in Supply Chain Management. World Economic Forum. 3 November 2025. Available online: https://www.weforum.org/stories/supply-chains-and-transportation/autonomous-orchestration-next-frontier-supply-chain-management/ (accessed on 1 October 2026).
- NVIDIA. NVIDIA OpenShell: Open, Secure Runtime for AI Agents. Available online: https://www.nvidia.com/en-us/ai/openshell/ (accessed on 1 October 2026).
- Kim, J.F. Offloading and Isolating Data Center Workloads with NVIDIA BlueField DPU. NVIDIA Technical Blog. 19 August 2021. Available online: https://developer.nvidia.com/blog/offloading-and-isolating-data-center-workloads-with-bluefield-dpu/ (accessed on 1 October 2026).
- Siemens Digital Industries Software Catapult High-Level Synthesis and Verification. Available online: https://eda.sw.siemens.com/en-US/eda-cloud-solutions/ic/catapult-high-level-synthesis/ (accessed on 1 October 2026).
- Synopsys Design Compiler: Timing, Area, Power, & Test Optimization. Available online: https://www.synopsys.com/implementation-and-signoff/rtl-synthesis-test/design-compiler.html (accessed on 1 October 2026).
- Dutilh Novaes, C.; Uckelman, S.L. Obligationes. In The Cambridge Companion to Medieval Logic; Dutilh Novaes, C., Read, S., Eds.; Cambridge University Press: Cambridge, UK, 2016; pp. 370–395. [Google Scholar] [CrossRef]
- Abian, A. A Fixed Point Theorem Equivalent to the Axiom of Choice. Arch. Math. Log. Grundl. 1985, 25, 173–174. [Google Scholar] [CrossRef]
Table 1.
Extensional–Executable Correspondence.
| Extensional representation | Executable epistemic–ontological–eschatological (OEE) representation | What execution retains |
|---|---|---|
| Value / element x | Event e = ⟨addrOEE(e), payload(e)⟩ | The same content may occur as distinct execution facts. |
| Element content | payload(e) | The extensional value is preserved. |
| Element identity | addrOEE(e) = (idesh,1, …, idesh,k, idont, idinst) | Purpose lineage, ontological relation, and admitted instance. |
| Set / realized collection | Context C = ⟨e1, …, en⟩ | Deterministic construction history preserving causal provenance. |
| Membership x ∈ A | Admission of en+1 into Cn+1 under Axiom 0 | Entry into the executable record is generated and attributable; forgetting the address recovers extensional membership. |
| Binary relation R ⊆ X × X | Executable abstraction Aτ = (R, ωτ, τ) | Possibility, ontological realization, admission criterion, and accumulated context. |
| Multiplicity of possible successors | ωτ(Cn)↓ followed by τ(Cn, ω) = true | Context-mediated realization and admission are explicit; no independent selecting operation is introduced. |
| Forgetful projection | U(e) = payload(e); the relational reduct of Aτ is R | The classical extensional view is recovered by discarding execution structure. |
Table 2.
Glossary of symbols and terms.
| Symbol / term | Meaning |
|---|---|
| C, Cn | The shared execution context: the finite append-only sequence of everything admitted so far, up to step n. C0 = ∅. |
| Aτ | Executable abstraction: relational reduct R together with active versioned ontological and eschatological specifications, evaluated against the shared context C. |
| ωτ | Operational realization procedure associated with the active ontological specification; partial and single-valued for a fixed invocation. |
| τ | Operational eschatological admission criterion: total and Boolean once a realization exists, evaluated against the accumulated context. |
| R | The coordinate-free binary-relational reduct recovered from the executable abstraction by forgetting admission structure (§4.2.3). |
| e = ⟨addrOEE(e), payload(e)⟩ | An admitted event: its OEE address paired with its extensional content. |
| addrOEE(e) | The composite address (idesh,1, …, idesh,k, idont, idinst) locating purpose lineage, ontological relation, and admitted instance. |
| Ω | The space of ontological realizations over which the active realization procedure ranges. |
| Execute(Aτ, Cn) | The local execution operation: undefined under preemption; otherwise returns the unique event record admitted by Axiom 0. |
| eont, eesh | Ontological and eschatological specification events in C that record or address the immutable specification versions in force; they are not the higher-rank specification objects themselves (§3.2.6). |
| idinst | The instance coordinate: an event’s position in the append-only record. |
| Admission | The act of Execute writing a new event into C. |
| Preemption | Absence of admission: either ωτ(C) is undefined (“not yet available”) or τ(C, ωτ(C)) = false. |
| Epistemic / ontological / eschatological axes | The constitutively distinct roles of record (C), realizable possibility (ωτ under its active specification), and admission criterion (τ) (§3.1.2). |
| Evolutive | A system whose governing abstraction admits and activates a new ontology or criterion specification version (§4.5.6). |
| S0 | Borel execution-closure requirement: within each fixed regime, the coded reachable execution representation is closed under the finite/countable products used by execution and has a Borel complete outcome space (§4.4.7). |
| 𝔹 | Boolean eschatological judgment carrier {false, true}. |
| K0 | Fixed deterministic Axiom 0 execution kernel: invokes the active realization and criterion specifications and records an event only on positive admission (§3.2.8). |
| EHα | Optional abstraction-relative event horizon: ontology-defined localization of the context used by an invocation; for inter-system interaction, a shared horizon may expose an external event identity/reference (§5.1.2). |
Table 3.
Structural comparison with prior formalisms.
| Contribution | Relevant result | Difference from the present calculus |
|---|---|---|
| Tarski, concept of truth [12] | Truth/metalanguage separation for formalized languages | Does not define an append-only execution context or history-conditioned admission rule. |
| Turing [14,15,16] | Mechanical execution; oracle as external decision boundary; global form from interacting local processes | No append-only execution object combining explicit ontology, criterion, and replayable admission; no historical claim that morphogenesis was intended as an execution calculus. |
| Saratov nonlinear-dynamics reconstruction and synchronization [17]–[22] | Time-series reconstruction of nonautonomous and delayed dynamics; attractor/Lyapunov characterization; recovery of network coupling; conditional-Lyapunov criterion for generalized chaotic synchronization and secure communication | Domain-specific reconstruction and synchronization of nonlinear dynamics; does not provide the append-only accountable context, explicit realization/admission separation, versioned governance, or replay semantics of the present calculus. |
| Tarski, calculus of relations [37]; Tarski & Givant [38] | Relational composition and variable-free relational formalization | No append-only execution context or explicit admission criterion of the form studied here. |
| Tarski, fixed-point theorem [13] | Least-fixed-point existence for monotone operators on complete lattices | Addresses monotone operators rather than local history-conditioned admission. |
| Codd [23] | Relational data model and data independence | A data model, not an execution/admission semantics. |
| Mesarović–Takahara [31,32,33,39] | General/input–output system as relation; hierarchical and multilevel composition of component systems | Provides a highly general relational system ontology and hierarchy, but not the append-only, history-conditioned admission semantics used here. |
| Tocher [36] | Three-phase execution with repeated condition testing | Operational precursor of re-evaluated eligibility; criterion not isolated as the constitutive execution object used here. |
| Zeigler (Discrete Event System Specification, DEVS) [35] | Discrete-event input/output and transition semantics | Transition functions perform admission-like work without the separately identified append-only criterion/context structure used here. |
| Milner (π, Calculus of Communicating Systems, CCS) [24]; Hoare (Communicating Sequential Processes, CSP) [25] | Compositional concurrency, interaction, and alternative continuation | Does not make the particular append-only accumulated admission context of this calculus constitutive. |
| Petri [26]; Dijkstra [27]; Lamport [28] | Concurrency/conflict, explicit nondeterminism, and causal ordering | Formalizes conflict and order, but not the same combined history-conditioned admission object. |
| Event sourcing [29]; Command Query Responsibility Segregation (CQRS) [30] | Durable event history as source of truth | Admissibility is normally application-level rather than a constitutive criterion of the architecture. |
| Batz et al., continuous probabilistic program verification [40] | Standard Borel σ-algebra on program states; Borel-measurable expectations; n-fold product Borel structures for multidimensional integration and measurable expectation-transformer semantics | Uses Borel/measurable structure for probabilistic semantics, integration, and loop verification; does not formulate product closure as S0 for an append-only OEE execution calculus with endogenous governance and deterministic replay. |
| Zero Tier Execution Substrate (ZTES) [8] | Concrete architecture with append-only history and governed commitment | Architecture-specific realization; the present paper develops the general calculus and its boundary results. |
Table 4.
Shared representational boundary.
| Bare representation | Not constitutively retained | Execution consequence considered here |
|---|---|---|
| the set element | execution provenance | Membership alone does not identify the execution context or criterion under which the value entered a record. |
| the binary relation | admission criterion and accumulated history | Possible pairs do not by themselves identify which successor became an executed fact. |
| the process | admission provenance | A trace records progression but need not record the criterion authorizing each step. |
| the state | accumulated execution history | Current state alone need not support replay or attribution of the path that produced it. |
| the record alone | admission rule | A log records what occurred; its admissibility semantics may remain external. |
| the abstraction (this paper) | — | Context, realizable possibility, and admission criterion are represented within one executable structure. |
Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content. |
| 1 | Contemporary engineering practice exhibits partial structural correspondences. WEF describes agentic supply-chain orchestration over connected, contextualized operational, supplier, risk, and unstructured records, and reports that organizations advancing toward autonomous capabilities expect recovery-time reductions of 60% [55], [56]. WEF does not formulate these records in measure-theoretic terms; interpreting such contextual histories through the Borel-analyzable fixed-regime execution space of §4.4 is a reading of the present paper. NVIDIA OpenShell separates agent execution from externally enforced policy, logs allow/deny decisions, and is paired with BlueField hardware that isolates infrastructure services from host workloads [57], [58]. EDA synthesis systems such as Catapult and Design Compiler transform high-level or RTL descriptions plus constraints into concrete optimized implementations [59], [60]; in the terminology of this paper, this is a domain-specific reduction of implementation multiplicity under constraints, not a claim that synthesis tools implement Axiom 0. These examples instantiate fragments of the pattern but not the full shared-context, realization/admission, governance, replay, and evolutive formalism. |
© 2026 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license (http://creativecommons.org/licenses/by/4.0/).
Copyright: This open access article is published under a Creative Commons CC BY 4.0 license, which permit the free download, distribution, and reuse, provided that the author and preprint are cited in any reuse.