Concurrent Convolution Kleene Algebras

• Concurrent Convolution Kleene Algebras are algebraic structures that integrate sequential and parallel compositions with convolution and lax exchange laws.
• They employ models such as partial strings, pomsets, and quantales to capture refinement, iteration, and true concurrency.
• Applications include verification of relaxed-memory computations and weighted automata, despite limitations like termination assumptions and finiteness conditions.

Concurrent Convolution Kleene Algebras are algebraic structures for concurrent computation in which two monoidal compositions—sequential and parallel—coexist with idempotent choice and iteration, and are linked by a lax exchange or interchange law. In the literature, this theme appears in several closely related forms: as partial-order models of Concurrent Kleene Algebra built from partial strings and programs; as function-space convolution algebras over structures carrying sequential and parallel composition; and, for the commutative fragment, as semilinear-set models in which product is additive convolution on Parikh vectors. Across these formulations, the defining objective is the same: to obtain a compositional calculus in which sequential behaviour, true concurrency, refinement, and iteration can be treated within one algebraic framework (Horn et al., 2014, Cranch et al., 2020, Cranch et al., 29 Aug 2025, Brunet, 2019).

1. Algebraic idea and historical setting

Concurrent Kleene Algebra (CKA) was introduced as an algebraic structure that unifies laws of concurrent programming, with its unifying power resting largely on the exchange law that governs how concurrent and sequential composition can be interchanged (Horn et al., 2014). In its standard concurrent form, one has an idempotent additive structure, a sequential product, a parallel product, and star operations; the parallel product is commutative, and the central interaction law is lax rather than equational. This point is fundamental: the theory is designed around inequalities of refinement, not around an identification of the two products.

The adjective “convolution” enters in two complementary ways. First, in abstract lifting constructions, sequential and parallel composition on a base structure induce convolution products on function spaces, typically of the form

$$(f \ast_i g)(x)=\sum_{y,z} f(y)\cdot g(z)\cdot [x\in y\odot_i z].$$

Second, in commutative fragments, product is explicitly realised as additive convolution, for example Minkowski sum on subsets of $\mathbb{N}^d$ (Cranch et al., 2020, Cranch et al., 29 Aug 2025, Brunet, 2019). The resulting viewpoint treats concurrent behaviour as algebra over spaces of behaviours, languages, weighted traces, pomsets, or categorical cells.

A historically important structural distinction is between interchange Kleene algebras and concurrent Kleene algebras. In the former, the second product need not be commutative. In the latter, parallel composition is commutative and usually shares the unit of sequential composition. This distinction is explicit in the convolution literature on 2-catoids and relational interchange monoids, where the commutative specialization yields the genuinely concurrent case (Cranch et al., 29 Aug 2025, Cranch et al., 2020).

The commutative fragment supplies a canonical algebraic base. The free commutative Kleene algebra on $d$ generators is isomorphic to the algebra of semilinear subsets of $\mathbb{N}^{d}$ under union, additive convolution, and Kleene star, with $0=\emptyset$ and $1=\{\vec{0}\}$; this result is used as a key component in completeness proofs for algebraic models of concurrent computations, including bi-Kleene algebra and concurrent Kleene algebra (Brunet, 2019).

2. Partial strings, pomsets, and refinement

One of the most explicit semantics for CKA is the partial-string model. A partial string is a triple

$p=\langle E_p,\alpha_p,\preceq_p\rangle,$

where $E_p$ is a set of events, $\alpha_p:E_p\to\Gamma$ labels events over an alphabet $\Gamma$, and $\mathbb{N}^d$0 is a partial order (Horn et al., 2014). Refinement is defined using Ésik’s monotonic bijective morphisms: $\mathbb{N}^d$1 when there exists a bijection $\mathbb{N}^d$2 preserving labels and order. On finite partial strings, antisymmetry holds up to isomorphism.

The model is pomset-like but not merely a theory of isomorphism classes. It retains event identities and uses morphisms rather than equality of representatives. This matters because the exchange law is validated as an inequation, because fixed-point constructions are carried out over sets of behaviours, and because the model accommodates uncountable collections and refinement reasoning (Horn et al., 2014).

Sequential and parallel composition are defined on partial strings by disjoint coproduct. If $\mathbb{N}^d$3 and $\mathbb{N}^d$4 are partial strings, the concurrent composite $\mathbb{N}^d$5 preserves the internal orders of $\mathbb{N}^d$6 and $\mathbb{N}^d$7 and makes cross-events incomparable. The strongly sequential composite $\mathbb{N}^d$8 preserves the same internal orders and additionally forces all events of $\mathbb{N}^d$9 to precede all events of $d$0:

$d$1

Parallel composition is commutative, and both products are associative up to isomorphism. A basic refinement law is

$d$2

which expresses that a fully ordered implementation refines a more concurrent specification (Horn et al., 2014).

Programs are then defined as downward-closed sets of finite partial strings under $d$3. Their order is subset inclusion, and program composition is obtained by lifting the partial-string operations and then closing downward:

$d$4

This yields a complete lattice of programs with $d$5 and $d$6, where $d$7 is the empty partial string. At the program level, both $d$8 and $d$9 are monoids, and $\mathbb{N}^{d}$0 is commutative (Horn et al., 2014).

3. Convolution and quantale formulations

The partial-string program algebra already admits a quantale-style reading. Because program composition distributes over arbitrary joins, the structures

$\mathbb{N}^{d}$1

are unital quantales. In this sense, the lifted operations behave as convolutions over a poset of behaviours: one combines elements pointwise by a product and then closes downward under refinement (Horn et al., 2014). This is one of the principal meanings of “concurrent convolution” in the partial-order setting.

A more general construction starts from a base carrying two compositions. In the relational formulation, the base set $\mathbb{N}^{d}$2 is equipped with two ternary relations, $\mathbb{N}^{d}$3 and $\mathbb{N}^{d}$4, encoding sequential and parallel combination. In the categorical formulation, the base is a Möbius 2-catoid

$\mathbb{N}^{d}$5

whose two catoid structures satisfy coherence conditions and a lax interchange inclusion (Cranch et al., 2020, Cranch et al., 29 Aug 2025). Given a semiring, dioid, or Kleene algebra $\mathbb{N}^{d}$6 or $\mathbb{N}^{d}$7, one defines function spaces $\mathbb{N}^{d}$8 or $\mathbb{N}^{d}$9 with pointwise addition and dimension-wise convolution:

$0=\emptyset$0

The units are indicator functions of the identity sets:

$0=\emptyset$1

Under finite decomposability, these sums are finite; in quantale settings, arbitrary joins replace finite sums (Cranch et al., 29 Aug 2025, Cranch et al., 2020).

The corresponding lifting theorem states that if the base carries the required relational or catoid-level interchange law and the coefficient algebra is an interchange semiring or interchange Kleene algebra, then the function space inherits the same structure. In the commutative specialization, when the parallel product is commutative and the units agree, one obtains a concurrent convolution Kleene algebra (Cranch et al., 29 Aug 2025, Cranch et al., 2020).

The commutative fragment has a particularly concrete convolution semantics. For semilinear subsets of $0=\emptyset$2, product is additive convolution:

$0=\emptyset$3

and star is

$0=\emptyset$4

This supplies the free commutative Kleene algebra on $0=\emptyset$5 generators and provides the algebraic basis for the parallel, commutative component used in concurrent completeness arguments (Brunet, 2019).

4. Exchange, iteration, and least fixed points

The central interaction law is the exchange law. In the partial-string model it appears as

$0=\emptyset$6

and, after lifting to programs,

$0=\emptyset$7

Its immediate consequences include

$0=\emptyset$8

The law is strict in general: even for single-event partial strings one can have

$0=\emptyset$9

while the refinement still holds (Horn et al., 2014). This strictness is not a defect but a design feature: it prevents collapse of sequential and parallel structure.

Iteration is treated by least fixed points. In the partial-string program model, for fixed $1=\{\vec{0}\}$0 and $1=\{\vec{0}\}$1, define

$1=\{\vec{0}\}$2

Because the complete lattice of programs is ordered by inclusion and composition is monotone, Knaster–Tarski yields least fixed points

$1=\{\vec{0}\}$3

These can be approximated by Kleene iteration:

$1=\{\vec{0}\}$4

The resulting induction principle has the standard order-theoretic form: if $1=\{\vec{0}\}$5, then $1=\{\vec{0}\}$6 (Horn et al., 2014).

In the generalized Möbius-categorical setting, star cannot simply be imported from arbitrary complete suprema when one works in ordinary Kleene algebras rather than quantales. The solution is a recursive star over finite decompositions. For a Möbius catoid $1=\{\vec{0}\}$7 and $1=\{\vec{0}\}$8,

$1=\{\vec{0}\}$9

while for non-identities $p=\langle E_p,\alpha_p,\preceq_p\rangle,$0 the star is defined recursively using source identities and finite decomposition sums. The main theorem states that if $p=\langle E_p,\alpha_p,\preceq_p\rangle,$1 is Möbius and $p=\langle E_p,\alpha_p,\preceq_p\rangle,$2 is a Kleene algebra, then $p=\langle E_p,\alpha_p,\preceq_p\rangle,$3 with convolution and this star is again a Kleene algebra; in the two-dimensional case, the same holds dimension-wise, yielding an interchange convolution Kleene algebra and, in the commutative specialization, a concurrent convolution Kleene algebra (Cranch et al., 29 Aug 2025).

Quantale-based and Möbius-based stars therefore play complementary roles. Quantales define star as a supremum of powers, whereas Möbius finiteness replaces infinitary suprema by finite recursive summation over decompositions (Cranch et al., 29 Aug 2025).

5. LLMs, automata, logics, and variants

Pomset languages provide the classical denotational domain for concurrent algebra. A pomset is an isomorphism class of finite labelled partial orders, and the powerset of pomsets carries both sequential and parallel language products, sequential star, and parallel iteration. Every valid universal equality over pomset languages using the bi-Kleene operations is a consequence of the equational theory of regular languages together with that of commutative-regular languages, and rational pomset languages are closed under all Boolean operations (Laurence et al., 2017). In the bw-rational fragment, the ideal semantics of pomsets validates the exchange law, with a convolution-like operator $p=\langle E_p,\alpha_p,\preceq_p\rangle,$4 on ideal languages satisfying

$p=\langle E_p,\alpha_p,\preceq_p\rangle,$5

This makes the ideal semantics a direct pomset-language realization of concurrent algebra with exchange (Laurence et al., 2017).

The operational side is given by pomset automata. Series-parallel rational expressions, with sequential and parallel products and their respective iteration operators, admit a denotational semantics over series-parallel pomset languages, and pomset automata implement this semantics. For finitely supported, well-nested pomset automata, one can translate automata back to expressions; unrestricted finite pomset automata characterize context-free pomset grammars, from which undecidability of universality, equivalence, and series-parallel rationality follows for the general case (Kappé et al., 2018). Closely related work uses Brzozowski derivatives to construct automata for a relaxed version of CKA over series-parallel pomset languages, again aiming at a free-model characterization (Kappé et al., 2017).

Variants of the basic concurrent calculus extend or delimit the CCKA picture. Pomsets with boxes add a protection operator $p=\langle E_p,\alpha_p,\preceq_p\rangle,$6 that restricts legal interleavings by requiring external events to treat internal boxed events uniformly. The algebra keeps the exchange law,

$p=\langle E_p,\alpha_p,\preceq_p\rangle,$7

and adds monotonicity of boxing, $p=\langle E_p,\alpha_p,\preceq_p\rangle,$8, thereby supporting behavioural frame rules and locality reasoning while remaining conservative over unboxed terms (Brunet et al., 2019). By contrast, concurrent dynamic algebra, developed from multirelations, shows that not every convolution-like concurrent semantics fits the standard CCKA template: in that setting sequential composition need not be associative, even though parallel composition and least-fixed-point star remain available (Furusawa et al., 2014). A plausible implication is that “concurrent convolution” names a broader semantic family than standard CKA, and that associativity of sequential convolution is a substantive semantic assumption rather than a tautology.

6. Applications, related frameworks, and limits

The partial-order account is particularly suited to relaxed-memory reasoning. Partial orders directly represent “sequenced-before” and concurrency by incomparability, and labels can encode reads and writes over locations, for example with $p=\langle E_p,\alpha_p,\preceq_p\rangle,$9. In this setting, the refinement

$E_p$0

models the fact that a sequential implementation refines a more concurrent specification; the data explicitly notes its usefulness for proving correctness of lock insertion or conservative fences. The existence of least fixed points then supplies an algebraic foundation for loops in such analyses (Horn et al., 2014).

Convolution liftings broaden the application domain to weighted and probabilistic settings. The generalized Möbius-category construction is presented as relevant to verification of weighted and probabilistic sequential and concurrent programs, quantitative Hoare logics, predicate transformer algebras, and higher-dimensional rewriting. The same paper extends the construction to Conway semirings, linking it to weighted automata and formal power series (Cranch et al., 29 Aug 2025). Earlier convolution work likewise exhibits models of weighted words, digraphs, posets, isomorphism classes of finite digraphs, and pomsets, with the Boolean case recovering powerset semantics (Cranch et al., 2020).

Related algebraic frameworks emphasize different operational intuitions. Concurrent refinement algebra develops sequential composition, synchronous parallel composition, and weak conjunction over a complete lattice of commands. Each primitive operation satisfies a weak quantale structure, and each relevant pair forms a biquantale with a weak interchange law. The framework supports rely/guarantee reasoning, tests, atomic and pseudo-atomic commands, and is mechanized in Isabelle/HOL (Hayes et al., 2024). This suggests that the CCKA perspective is not confined to pomset or LLMs; it also organizes refinement calculi whose concurrency is synchronous rather than interleaving.

Several limitations recur across the literature. In the partial-string program model, programs are downward-closed sets of finite partial strings, so termination is assumed; the coproduct construction presupposes an infinite event universe; and fences and conflicts, in the sense of event structures, are outside scope (Horn et al., 2014). In the Möbius-categorical setting, the base must satisfy finite 2-decomposability and related finiteness conditions in each dimension; domain and codomain modalities require finite valency; and pair groupoids or matrix-like structures do not support the recursive Möbius star, requiring Conway matrix-star methods instead (Cranch et al., 29 Aug 2025). More generally, the exchange law remains an inequality, not an isomorphism, and this is essential to avoiding collapse of the two monoidal structures.

Taken together, these developments identify Concurrent Convolution Kleene Algebras not as a single presentation but as a family of closely aligned models. Their common core is an idempotent additive order, sequential and parallel convolution-like products, star or least-fixed-point iteration, and a lax exchange principle that mediates between sequencing and concurrency. The major semantic realizations—partial strings, pomset languages, semilinear Parikh models, relational liftings, and Möbius-categorical convolution algebras—differ in base structure and proof technology, but they agree on that core architecture (Horn et al., 2014, Cranch et al., 2020, Cranch et al., 29 Aug 2025).