Equational Axiomatization for Dynamic Threads

• The paper introduces an equational axiomatization that precisely models dynamic thread creation, synchronization, and interaction using algebraic effects.
• It employs parameterized algebraic theories with semilattice operations to rigorously encode thread behavior and dependency management.
• The approach is validated by demonstrating soundness, completeness, and full abstraction, linking syntactic terms to labelled poset and trace-based models.

Equational axiomatization for dynamic threads provides a mathematically precise foundation for modeling, reasoning, and analyzing the behaviors of thread-based concurrent computation. At its core, this approach encodes the semantics of dynamic thread creation, synchronization, and interaction using algebraic theories, specifically within the context of strong monads and parameterized operations. The landscape encompasses a spectrum from poly-threading execution models to fully dynamic, name-passing, and resource-sensitive concurrent systems. Current frameworks deliver soundness, completeness, and full abstraction for a variety of operational observables, including labeled posets (pomsets), process traces, and sequential effectful computations.

1. Algebraic and Parameterized Theories for Dynamic Threads

The equational approach to dynamic threads is rooted in algebraic effects, where thread behaviors are described via effect signatures and parameterized operations. The central idea is to capture thread-dependence and explanation of thread identifiers within concrete syntactic operations. Recent work has highlighted the use of parameterized algebraic theories built atop semilattices with signature: $\Sigma_{\mathit{SL}} = \{\oplus:2, 0:0\}$ and corresponding axioms for associativity, commutativity, idempotency, and unit. This semilattice provides the variable-binding context for thread IDs throughout the algebra (Kammar et al., 5 Feb 2026).

The signature for dynamic threads typically includes:

• $\mathit{fork}$: $(0\mid 1, 0)$, enabling the creation of new child threads (with names bound in continuations).
• $\mathit{wait}$: $(1\mid 0)$, representing synchronization on the completion of given child threads.
• $\mathit{stop}$: immediate thread termination.
• $\#_\sigma$: atomic observable actions.

The syntax of dynamic threads is thus parameterized by thread-ID expressions, and the equational theory is closed under congruence and substitution for these parameters (Kammar et al., 5 Feb 2026).

2. Equational Axioms Governing Thread Composition

The axiomatization specifies laws that ensure compositionality, concurrency reasoning, and operational adequacy:

• Wait Neutrality and Accumulation:

$$\mathit{wait}(0, x) = x \quad,\quad \mathit{wait}(a, \mathit{wait}(b, x)) = \mathit{wait}(a \oplus b, x)$$

$\oplus$ accumulates dependencies on sets of threads.

• Wait Binding:

$$\mathit{wait}(a,\, x(b)) = \mathit{wait}(a,\, x(a\oplus b))$$

showing the invariance under substitution for named threads.

• Fork–Wait Commutation:

$$\mathit{wait}(b,\; \mathit{fork}(a.x(a), y)) = \mathit{fork}(a.\mathit{wait}(b, x(a)),\, \mathit{wait}(b, y))$$

indicating that waiting for a thread after forking commutes to waiting in each branch.

• Fork Commutativity and Associativity:

$$\mathit{fork}(a.\mathit{fork}(b.x(a,b), y), z) = \mathit{fork}(b.\mathit{fork}(a.x(a,b), z), y)$$

$$\mathit{fork}(a.x(a),\; \mathit{fork}(b.y(b),z)) = \mathit{fork}(b.\mathit{fork}(a.x(a), y(b)), z)$$

Encoding independent child creation and nesting of forks.

• Unit for Fork (Child becomes main):

$$\mathit{fork}(a.\mathit{wait}(a, \mathit{stop}),\, x) = x$$

• Fork Substitution (Dead Child Removal):

$$\mathit{fork}(a.x(a),\, \mathit{wait}(b, \mathit{stop})) = x(b)$$

All equations are preserved under parameter substitution and context construction, aligning with the semantics of parameterized algebraic theories (Kammar et al., 5 Feb 2026).

3. Complete and Sound Models: Labelled Posets and Free Models

Closed terms of threads correspond semantically, up to isomorphism, to finite labelled posets (pomsets) encoding events and causality. The free model in the presheaf category $[\mathit{FinRel}, \mathrm{Set}]$ provides:

• A canonical translation from syntactic terms to labelled posets with causal ordering induced by fork and wait primitives.
• Isomorphism of pomsets as the semantic criterion of equality for closed thread terms:

$t = t' \iff P(t) \cong P(t')$

• The presheaf model is the free strong monad generated by the parameterized algebraic theory, ensuring that syntactic equivalence is precisely modelled by poset isomorphism (Kammar et al., 5 Feb 2026).

For open terms, the syntactic completeness theorem asserts: if closing substitutions in all contexts yield observationally equivalent structures, then an equational proof exists in the syntax, ensuring completeness relative to contextual equivalence.

4. Denotational and Operational Semantics

The denotational semantics arises via the strong monad structure: $$T : [\mathit{FinRel}, \mathrm{Set}] \to [\mathit{FinRel}, \mathrm{Set}]$$ with generic effects provided by the interpretations of fork, wait, stop, and atomic actions.

Operationally, the semantics is captured by configurations $C = (W, \prec, \mathit{threads})$, where $W$ is the set of active thread IDs, $\prec$ the current waiting (dependency) relation between threads, and $\mathit{threads}$ maps IDs to code or status. The reduction rules precisely model fork-creation with name-passing, wait-induced causality constraints, and termination.

A term's observable semantics—its labeled poset of atomic actions and causal dependencies—is constructed inductively over the operational steps (Kammar et al., 5 Feb 2026).

5. Properties: Soundness, Adequacy, and Full Abstraction

Letting $t, u$ be closed terms of type $A$, contextual equivalence $t \approx_{\mathit{ctx}} u$ holds iff, for every evaluation context $C[-]$, their observed labelled posets are isomorphic.

• Adequacy: The denotation of a term uniquely determines its operationally observed poset.
• Soundness: Equational equality in the model implies contextual equivalence.
• Full Abstraction (First Order): The model is fully abstract at first-order types; denotational equality coincides exactly with contextual equivalence for $A \to B$ where $A,B$ are first order.

These results secure both the expressiveness and precision of the equational axiomatization for dynamic threads (Kammar et al., 5 Feb 2026).

6. Poly-threading, Sequencing, and Relation to Process Algebra

An alternative approach characterizes "dynamic threads" via thread algebra with sequencing and poly-threading operators. The key syntactic constructs include:

• $spt(p, \alpha)$: binds a current thread $p$ to a vector of possible continuations/fragments $\alpha$.
• $Switch_i$: triggers autonomous selection of the $i$th fragment in $\alpha$.
• $Extern$: enables non-autonomous (external) selection.
• $DeadEnd, Stop$: deadlock and termination.

The equational axioms cover

• Absorption and distribution rules over sequencing and fragment selection.
• A precise formalization of autonomous and external fragment switching.
• Direct correspondence with classical process algebra (ACP) axioms, e.g. associativity, sequential composition, and communication.

This framework provides a concrete mechanism for modeling run-time thread selection and interleaving, supporting both analytic and synthetic reasoning about dynamic thread behaviors (0803.0378).

7. Cooperative Threads, Trace-based Models, and Monadic Structure

The algebraic treatment extends further to imperative LLMs with cooperative threads, captured by a rich effect signature comprising store operations, nondeterminism, suspension/yielding, halting/blocking, and asynchronicity via spawning and yielding:

• $\mathsf{update}_{x,n}$ and $\mathsf{lookup}_x$: mutable state.
• $\cup, \Omega$: nondeterminism and divergence.
• $d$: suspension/yield.
• $\mathsf{halt}$: non-resumable block.
• $\mathsf{asynch}_P, \mathsf{yield}_P$: thread spawning mechanisms.

The induced monad $T_{Proc}$ on $\omega$-cpos precisely encodes the operational intuitions via a trace-based denotational semantics. Monad unit models immediate return; bind (Kleisli extension) realizes sequencing and trace splicing. The equations are shown to be both sound and complete with respect to a fully abstract trace model, in which operational equivalence and denotational equivalence coincide (Abadi et al., 2010).

A plausible implication is that the variety of dynamic thread models—parameterized algebraic theories, labelled-poset semantics, trace monads—form a robust mathematical scaffold to uniformly describe and analyze thread-based concurrency at both theoretical and practical levels.