Concurrent Kleene Algebra with Observations: From Hypotheses to Completeness

Concurrent Kleene Algebra (CKA) extends basic Kleene algebra with a parallel composition operator, which enables reasoning about concurrent programs. However, CKA fundamentally misses tests, which are needed to model standard programming constructs such as conditionals and \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\mathsf {while}$$\end{document}while-loops. It turns out that integrating tests in CKA is subtle, due to their interaction with parallelism. In this paper we provide a solution in the form of Concurrent Kleene Algebra with Observations (CKAO). Our main contribution is a completeness theorem for CKAO. Our result resorts on a more general study of CKA “with hypotheses”, of which CKAO turns out to be an instance: this analysis is of independent interest, as it can be applied to extensions of CKA other than CKAO.

The development of CKA raises a natural question, namely how tests, which were essential in KAT for the study of sequential programs, can be integrated into CKA. At first glance, the obvious answer may appear to be to merge KAT with CKA, yielding Concurrent Kleene Algebra with Tests (CKAT) -as attempted in [12]. However, as it turns out, integrating tests into CKA is quite subtle and this naive combination does not adequately capture the behaviour of concurrent programs. In particular, using the CKAT framework of [12] one can prove that for any test b and CKAT program e: thus b · e · b ≡ CKAT 0, meaning no program e can change the outcome of any test b. Or equivalently, and undesirably, that any test is an invariant of any program! The core issue is the identification in KAT of sequential composition · and Boolean conjunction ∧. In the concurrent setting this is not sound as the values of variables -and hence tests -can be changed between the two tests.
In order to fix this issue, we have presented Kleene Algebra with Observations (KAO) in previous work [13]. Algebraically, KAO differs from KAT in that conjunction of tests b ∧ b and their sequential composition b · b are distinct operations. In particular, b∧b expresses a single test executed atomically, whereas b·b describes two distinct executions, occurring one after the other. As mentioned above, this distinction is crucial when moving from the sequential setting of KA to the concurrent setting of CKA, as actions from another thread that happen to be scheduled after b but before b may as well change the outcome of b .
This newly developed extension of KA enables a novel attempt to enrich CKA with the ability to reason about programs that also have the traditional conditionals: in this paper, we present Concurrent Kleene Algebra with Observations (CKAO) and show that it overcomes the problems present in CKAT.
The traditional plan for developing a variant of (C)KA is to define a separate syntax, semantics, and set of axioms, before establishing a formal correspondence with the base syntax, semantics and axioms of (C)KA proper, and arguing that this correspondence allows one to conclude soundness and completeness of the axioms w.r.t. the semantics, as well as decidability of equivalence in the semantics. Instead of such a tailor-made proof, however, we take a more general approach by first proposing CKA with hypotheses (CKAH) as a formalism for studying extensions of CKA, akin to how Kleene algebra with hypotheses [5,18,20,7] can be used to extend Kleene algebra. We then apply CKAH to study CKAO, but the meta-theory developed can also be applied to extensions other than CKAO.
Using the CKAH formalism, we instantiate CKAO as CKAH with a particular set of hypotheses, and we immediately obtain a syntax and semantics; we can then use the meta-theory of CKAH to argue completeness and decidability in a modular proof, which composes results about CKA [15] and KAO [13].
The technical roadmap of the paper and its contributions are as follows.
-We introduce Concurrent Kleene Algebra with Hypotheses (CKAH), a formalism for studying extensions of CKA; this is a concurrent extension of Kleene Algebra with Hypotheses (Section 4). We show how CKAH is sound with respect to rational pomset languages closed under an operation arising from the set of hypotheses. We propose techniques to argue completeness of the extended set of axioms with respect to the sound model as well as decidability of equivalence, capturing methods commonly used in literature to argue completeness and decidability for extensions of (concurrent) KA. -We prove that CKAO can be presented as an instance of CKAH, for a certain set of hypotheses (Section 5). This gives us a sound model of CKAO 'for free'. We then prove that the axioms of CKAO are also complete for this model, and that equivalence is decidable, using the techniques developed previously.
We conclude this introduction by giving an example of how hypotheses can be added to CKA to include the meaning of primitive actions. Suppose we were designing a DSL for recipes, specifically, the steps necessary, and their order. A recipe to prepare cookies might contain the actions mix (mixing the ingredients), preheat (pre-heating the oven), chill (chilling the dough) and bake (baking the cookies). Using these actions, a recipe like "mix the ingredients until combined; chill the dough while pre-heating the oven; bake cookies in the oven" may be encoded as mix * · (chill preheat) · bake. Now, imagine that we have only one oven, meaning that we cannot bake two batches of cookies concurrently. We might encode this restriction on concurrent behaviour by forcing the equation As a consequence of this hypothesis, one could then derive properties such as bake (bake · mix) = bake · bake · mix + bake · mix · bake In a nutshell, this paper provides an algebraic framework -CKAH -together with techniques for soundness and completeness results. The framework is flexible in that different instantiations of the hypotheses generate very different algebraic systems. We provide one instantiation -CKAO -that enables analysis of programs with both concurrency primitives and Boolean assertions. This is the first sound and complete algebraic theory to reason about such programs.
For the sake of brevity, some proofs appear in the extended version [14].

Preliminaries
We recall basic definitions on pomset languages, used in the semantics of CKA, which generalise languages to allow letters in words to be partially ordered. We fix a (possibly infinite) alphabet Σ. When defining sets parametrised by Σ, say S(Σ), if Σ is clear from the context we use S to refer to S(Σ).
Definition 2.1 (Labellet poset). A labelled poset over Σ is a tuple u = S, ≤, λ , where S is a finite set (the carrier of u), ≤ u is a partial order on S (the order of u), and λ : S → Σ is a function (the labelling of u).
We will denote labelled posets by bold lower-case letters u, v, etc. We write S u for the carrier of u, ≤ u for the order of u, and λ u for the labelling of u. We assume that any labelled poset has a carrier that is a subset of some countably infinite set, say N; this allows us to speak about the set of labelled posets over Σ. The precise contents of the carrier, however, are not important -what matters to us is the labels of the points, and the ordering between them. Definition 2.2 (Poset isomorphism, pomset). Let u, v be labelled posets over Σ. We say u is isomorphic to v, denoted u ∼ = v, if there exists a bijection h : S u → S v that preserves labels, and preserves and reflects ordering. More precisely, we require that A pomset over Σ is an isomorphism class of labelled posets over Σ, i.e., the class [v] = {u : u ∼ = v} for some labelled poset v.
We write Pom(Σ) for the set of pomsets over Σ, and 1 for the empty pomset. As long as we have countably many pomsets in scope, the above allows us to assume w.l.o.g. that those pomsets are represented by labelled posets with pairwise disjoint carriers; we tacitly make this assumption throughout this paper.
Pomsets can be concatenated, creating a new pomset that contains all events of the operands, with the same label, but which orders all events of the left operand before those of the right one. We can also compose pomsets in parallel, where events of the operands are juxtaposed without any ordering between them.
Similarly, we write U · V for the sequential composition of U and V , that is, the pomset represented by the labelled poset u · v, where Just like words are built up from the empty word and letters using concatenation, we can build a particular set of pomsets using only sequential and parallel composition; this will be the primary type of pomset that we will use. Definition 2.4 (Series-parallel). The set of series-parallel pomsets ( sppomsets) over Σ, denoted SP(Σ), is the smallest set s.t. 1 ∈ SP(Σ), a ∈ SP(Σ) for every a ∈ Σ, and it is closed under parallel and sequential composition.
The following characterisation of SP is very useful in proofs.
Theorem 2.5 (Gischer [9]). Let U = [u] ∈ Pom. Then U ∈ SP if and only if U is N-free, which is to say that if there exist no distinct s 0 , s 1 , s 2 , s 3 ∈ S u such that s 0 ≤ u s 1 and s 2 ≤ u s 3 and s 0 ≤ u s 3 , with no other relation between them.
One way of comparing pomsets is to see whether they have the same events and labels, except that one is "more sequential" in the sense that more events are ordered. This is captured by the notion of subsumption [9], defined as follows.
Definition 2.6 (Subsumption). Let U = [u] and V = [v]. We say U is subsumed by V , written U V , if there exists a label-and order-preserving bijection h : Subsumption between sp-pomsets can be characterised as follows [9]. Lemma 2.7. Let sp be restricted to SP. Then sp is the smallest precongruence (preorder monotone w.r.t. the operators) such that for all U, V, W, X ∈ SP: CKA: syntax and semantics. CKA terms are generated by the grammar e, f ∈ T(Σ) : Semantics of CKA is given in terms of pomset languages, that is subsets of SP, which we simply denote by 2 SP . Formally, the function − : T → 2 SP assigning languages to CKA terms is defined as follows: Here, we use the pointwise lifting of sequential and parallel composition from pomsets to pomset languages, i.e., when U , V ⊆ SP(Σ), we define Furthermore, the Kleene star of a pomset language U is defined as U * = n∈N U n , where U 0 = {1} and U n+1 = U n · U . Equivalence of CKA terms can be axiomatised in the style of Kleene algebra. The relation ≡ is the smallest congruence on T (with respect to all operators) such that for all e, f, g ∈ T: in which e f is the natural order e + f ≡ f . The final (conditional) axioms are referred to as the least fixpoint axioms. Laurence and Struth [23] proved this axiomatisation to be sound and complete. A decision procedure was proposed in [4]. Readers familiar with CKA will notice that the algebra defined here is not in fact CKA as defined in [11]. Indeed the signature axiom of CKA, the exchange law, has been omitted. However, as we show in Section 4.2, the standard definition of CKA, as well as its completeness proof [15], may be recovered using hypotheses.

Pomset contexts
The linear one-dimensional structure of words makes it straightforward to define occurrences of subwords: if one wants to state that a word w appears in another word v, one can simply say that v = xwy for some x and y. Due to the twodimensional nature of pomsets, it is not straightforward to define when a pomset occurs inside another pomset, because the pomset could appear below a parallel, which is nested in a sequential, which is in a parallel, etc. In what follows we define pomset contexts, that will enable us to talk about pomset factorisations in a similar fashion as we do for words, and prove some useful properties for these.
Intuitively, * is a placeholder or gap where another pomset can be inserted. We write PC(Σ) for the set of pomset contexts over Σ, and PC sp (Σ) for the series-parallel pomset contexts over Σ.
Given a C ∈ PC and U ∈ Pom, we can "plug" U into the gap left in C to obtain the pomset C[U ] ∈ Pom. More precisely, let U = [u] and C = [c] with u disjoint from c. We write C[U ] for the pomset represented by It follows easily that ≤ c[u] is a partial order. We may also apply contexts to lan- We now prove some properties of contexts that will be useful later in our technical development. First, we note that pomset contexts respect subsumption.
Series-parallel pomset contexts can be given an inductive characterisation.
We will identify totally ordered pomsets with words, i.e., Σ * ⊆ SP. If the pomset U inserted in a context C is a non-empty word, and the resulting pomset is a parallel pomset, then we can infer how to factorise C. Lemma 3.4. Let C ∈ PC sp be a pomset context, let V, W ∈ Pom, and let U ∈ Σ * be non-empty. If C[U ] = V W , then there exists a C ∈ PC sp such that either Application of series-parallel contexts preserves series-parallel pomsets.
If we plug the empty pomset into a context, then any subsumed pomset can be obtained by plugging the empty pomset into a subsumed context. If the subsumed pomset is series-parallel, then so is the subsumed context.
An analogue to the previous lemma can be obtained if instead of the empty pomset one inserts a single letter pomset a.

Concurrent Kleene Algebra with Hypotheses
Kleene algebra has basic axioms about how program composition operators should work in general, and hence does not make any assumptions about how these operators work on specific programs. When reasoning about equivalence in a programming language, however, it makes sense to embed domain-specific truths about the operators into the axioms. For instance, if a programming language includes assignments to variables, then subsequent assignments to the same variable could be merged into one, giving rise to an equation such as which says that the behaviour of first assigning n, then m to x (on the right) includes the behaviour of simply assigning m to x directly (on the left). Kleene algebra with hypotheses (KAH) [5,18,20,7] enables the addition of extra axioms, called hypotheses, to the axioms of KA. The appeal of KAH is that it allows a wide range of such hypotheses about programs to be added to the equational theory, while retaining the theoretical boilerplate of KA. In particular, it turns out that we can derive a sound model for any set of hypotheses, using the language model that is sound for KA proper [7]. Moreover, the completeness and decidability results that hold for KA can be leveraged to obtain completeness and decidability results for some specific types of hypotheses [5,20,7]; in general, equivalence under other hypotheses may turn out to be undecidable [18].
In this section, we propose a generalisation of so-called Kleene algebra with hypotheses to a concurrent setting, showing how one can obtain a sound (pomset language) model for any set of hypotheses. We then discuss a number of techniques that allow one to prove completeness and decidability of the resulting system for a large set of hypotheses, by relying on analogous results about CKA.
When H is a set of hypotheses, we write ≡ H for the smallest congruence on T generated by the hypotheses in H as well as the axioms and implications that build ≡. More concretely, whenever e ≤ f ∈ H, also e H f .
A hypothesis that declares two programs to be equivalent, such as in (1), can be encoded by including both e ≤ f and f ≤ e in H.
Example 4.2. Suppose the set of primitive actions Σ includes the increments of the form incr x, as well as a statement print, which writes the complete state of the machine (including variables) on the standard output. Since we would like to depict the state consistently, the state should not change while the output is rendered; hence, print cannot be executed concurrently with any other action. Instead, when a program containing print is scheduled to run in parallel with an assignment, it must be interleaved such that the assignment runs either entirely before or after print. To encode this, we can include in H the hypotheses for all variables x. This allows us to prove, for instance, that That is, if we run some number of increments and print statements in parallel, it is possible that x is incremented twice between print statements.
To obtain a model of CKAH, it is not enough to use − , as some programs equated by the hypotheses might have different semantics. To get around this, we adapt the method from [7]: take − as a base semantics, and adapt the resulting language using hypotheses, such that the pomsets that could be obtained by rearranging the term using the hypotheses are also present in the language: Formally, L↓ H may be described as the smallest language satisfying the following inference rules: We observe the following useful properties about the interaction between closure and other operators on pomset languages. Lemma 4.5. Let L, K ⊆ Pom and C ∈ PC sp . The following hold.
Remark 4.6. Property (1) states that −↓ H is a closure operator. However, it is not in general a Kuratowski closure operator [22], since it fails to commute with union.  The converse of the above, where semantic equivalence is sufficient to establish axiomatic equivalence, is called completeness. Similarly, we may also be interested in deciding whether e ↓ H and f ↓ H coincide.  Note that, in the special case where H = ∅, we know that H is complete and decidable by Theorem 2.8. One method to find out whether H is complete or decidable is to reduce the problem to this special case. More concretely, suppose we know e ↓ H = f ↓ H , and want to establish that e ≡ H f . If we could find a set of hypotheses H that is complete, and we could map e and f to terms r(e) and r(f ) such that r(e) ↓ H = r(f ) ↓ H , then we would have r(e) ≡ H r(f ). If we could then "lift" that equivalence to prove e ≡ H f , we are done. Similarly, if we would know that r(e) ↓ H = r(f ) ↓ H is equivalent to e ↓ H = f ↓ H , we could decide the latter. To formalise this intuition, we first need the following.  If H implies H and vice versa, then H is complete (resp. decidable) precisely when H is. In general, however, this is not very helpful; we need something more asymmetrical, in order to get from a complicated set of hypotheses H to a simpler set of hypotheses H , where completeness or decidability might be easier to prove. Ideally, we would like to reduce to H = ∅, which is complete and decidable.
One idea to formalise this idea of a reduction is as follows. It is straightforward to show that reductions do indeed carry over completeness and decidability results, in the following sense.  c. An inductive argument on the structure of e shows that r reduces H to ∅, and hence H is complete and decidable.
It is not very hard to show that reductions can be chained, as follows.
Lemma 4.14. If H reduces to H , which reduces to H , then H reduces to H .
Another way of reducing H is to find two sets of hypotheses H 0 and H 1 , and reduce each of those to another set of hypotheses H [7]. The idea is that a proof of e ≡ H f can be split up in a phase where we find e , f ∈ T such that e ≡ H0 e and f ≡ H0 f , after which we find e , f ∈ T with e ≡ H1 e and f ≡ H1 f . Finally, we establish that e ≡ H f , before lifting those equivalences to H, One way of achieving this is as follows. In order to use factorisation to compose simpler reductions into more complicated ones, we need a slightly stronger notion of reduction, as follows.
Definition 4.16. We say that r is a strong reduction from H to H if it is a reduction such that for e ∈ T, it holds that e ↓ H = r(e) ↓ H .
Note that this additional condition essentially strengthens the second condition in Definition 4.11. Factorisation then lets us compose strong reductions. The remainder of this section is devoted to developing techniques that can be used to design reductions, based on the properties of the sets of hypotheses under consideration. Using the lemmas we have established so far, these techniques may then be leveraged to obtain completeness and decidability results.

Reification
It can happen that the hypotheses in H impose an algebraic structure on the letters in Σ; for instance, as we will see later on, the letters in H could be propositional terms, whose equivalence is mediated by the axioms of Boolean algebra. In order to peel away this layer of axioms and reduce to a smaller H , we can try to reduce to terms over a smaller alphabet, making the algebraic structure on the letters irrelevant to equivalence. In a sense, performing this kind of reduction is like showing that the equivalences between letters from the hypotheses can already be guaranteed by replacing them with the right terms.
Example 4.18. Let Σ be the set of group terms over a (finite) alphabet Λ, that is, Σ consists of the terms generated by the grammar g, h ::= u | a ∈ Λ | g • h | g. Furthermore, let ≡ G be the smallest congruence generated by the group axioms, i.e., for all g, h, i ∈ Λ it holds that Lastly, let group = {g ≤ h : g ≡ G h}. We can then define a reduction from group to ∅ by replacing every letter (group term) in a term e with its reduced form, that is, with the (unique) equivalent group term of minimum size. For instance, if Λ = {a, b, c}, then we send the term a • a b • c • c to the term u b.
For the remainder of this section, we fix a subalphabet Γ ⊆ Σ. When r : Σ → T(Γ ), we extend r to a map from T(Σ) to T(Γ ), by inductively applying r to terms. We can also apply r to a series-parallel pomset, obtaining a pomset language. More precisely, when U is a pomset, we define r(U ) as follows: Lastly, when L ⊆ SP, we write r(L) for the set {r(U ) : U ∈ L}.
The following then formalises the idea of reducing by replacing letters. Example 4.20. Continuing with the previous example, let r be the map that sends a group term to its reduced form; we claim that r is a reification from group to ∅. By definition, we then know that for a group term g ∈ Σ, we have r(g) ≡ G g, and hence r(g) ≡ group g. Furthermore, the reduction of a reduced term is that term itself; hence, the second condition is satisfied. The third condition holds trivially. Lastly, if e ≤ f ∈ group, then e, f ∈ Σ such that e ≡ G f . Since reductions are unique, we then know that r(e) = r(f ), and hence r(e) ∅ r(f ).
We have the following general properties of a map r, which we will use in demonstrating how to obtain a reduction from a reification. The following technical lemma is a consequence of property (iv). Using this, we can then show how to obtain a reduction from a reification. Specifically, in the third step, property (ii) ensures that for L ⊆ SP(Γ ) we have L ⊆ r(L). We can use this property because H -closure preserves the Γ -language by property (iii). This completes the proof.

Factoring the exchange law
In the basic axioms that generate ≡, there is no interaction between sequential and parallel composition. One sensible way of adding that kind of interaction is, as suggested by Hoare, Struth and collaborators [11], by adding an axiom of the form (e f ) · (g h) (e · g) (f · h), known as the exchange law. Essentially, this axiom encodes the possibility of (partial) interleaving: when e · g runs in parallel with f · h, one possible behaviour is that, first e runs in parallel with f , and then g runs in parallel with h. The core observation of this section is that the exchange law can be treated as another set of hypotheses, as we show below, and this can then be used to recover the completeness result of CKA [15].
Definition 4.24. We write exch for the set The semantic effect of adding exch to our hypotheses is that, if U is a pomset in a series-parallel language L, and V is a series-parallel pomset subsumed by U , then V is in the exch-closure of L. Intuitively, the exch-closure adds pomsets that are more sequential, i.e., have more ordering, than the ones already in L. Indeed, exch-closure coincides with the downward closure w.r.t. sp . We have previously shown that exch is complete [15]; as a matter of fact, the pivotal result from op. cit. can be presented as follows.
Theorem 4.26. The set of hypotheses exch is strongly reducible to ∅.
When exch is contained in our hypotheses, it is not immediately clear whether those hypotheses can be reduced. What we can do is try to factorise our hypotheses into exch and some residual set of hypotheses, and prove strong reducibility for that residual set. To this end, we first note that, in some circumstances, the H-closure of the exch-closure remains downward-closed w.r.t. sp . Lemma 4.27. Suppose that for each e ≤ f ∈ H we have that e = 1 or e = a for some a ∈ Σ, and let L ⊆ SP. If U, V ∈ SP such that U sp V and V ∈ (L↓ exch )↓ H , then U ∈ (L↓ exch )↓ H .
Using this fact, we can now show that, under the same precondition, exch ∪ H factors into exch and H. This factorisation is what we were looking for: it tells us that whenever H strongly reduces to ∅, so does H ∪ exch.

Lifting
A number of reduction procedures already exist at the level of Kleene algebra [20,7]; ideally, one would like to lift those procedures to CKA.
Example 4.29. The reductions in Example 4.13 and Example 4.18 worked out for terms without , and then extended inductively, by defining the reduction of e f to be the parallel composition of the reductions of e and f respectively. As a non-example, consider H = {a ≤ 1}. Even though this hypothesis can be reduced to ∅ within Kleene algebra [5], it is not obvious how this would work for pomset languages. In particular, if 1 ∈ L, then 1 · · · 1 ∈ L for any number of 1's, and hence a · · · a ∈ L↓ H for any number of a's. This precludes the possibility of a strong reduction to ∅, because 1 ↓ H is a pomset language of unbounded (parallel) width, which cannot be expressed by any e ∈ T [25].
We now establish a set of sufficient conditions for such a lifting to work. To this end, we first formally define Kleene algebra syntax, axioms and semantics.
Definition 4.30. Write T KA for the set of Kleene algebra terms, i.e., the terms in T that do not contain . Furthermore, we write ≡ KA for the smallest congruence on T KA that is generated by the axioms of ≡ that do not involve .
When e ∈ T KA , it is not hard to see that e contains totally ordered pomsets, i.e., words, exclusively. Using these definitions, we can now specialise the notions of hypotheses, context, and closure to the sequential setting, as follows.
Definition 4.31. The relation ≡ H KA is generated from H and ≡ KA as before. A context C ∈ PC sp is sequential if it is totally ordered, i.e., if it is a word with one occurrence of * ; we write PC seq for the set of sequential contexts.
Given a set of hypotheses H and a language L ⊆ Σ * , we define the sequential closure of L with respect to H, written L↓ H seq , as the least language containing L such that for all e ≤ f ∈ H and C ∈ PC seq , if C[ f ] ⊆ L↓ H seq , then C[ e ] ⊆ L↓ H seq . If does not occur in any hypothesis, then the definition of sequential closure coincides with the closure operator from [7]. Thus, if L ⊆ Σ * , then L↓ H seq ⊆ Σ * . The analogue of strong reduction for the sequential setting is as follows. To lift a sequential reduction to a proper reduction, the following class of hypotheses will turn out to be useful.

Definition 4.33.
A hypothesis e ≤ f with e, f ∈ T KA is called grounded if f = {W } for some non-empty word (totally ordered pomset) W , and e ∈ T KA . We say that a set of hypotheses H is grounded if every e ≤ f ∈ H is grounded. Example 4.34. Any hypothesis of the form e ≤ a 1 · · · a n for n > 0 is grounded. On the other hand, the hypothesis a ≤ 1 that we saw in the previous example is not grounded, since the semantics of 1 contains the empty pomset.
The closure of a language of words can be expressed in terms of its sequential closure, provided that the set of hypotheses is grounded. The above then allows us to turn a sequential reduction into a reduction.

Instantiation to CKA with Observations
In this section, we will present Concurrent Kleene Algebra with Observations (CKAO), an extension of CKA with Boolean assertions that enable the specification of programs with the usual guarded conditionals and loops. We will obtain CKAO as an instance of CKAH by choosing a particular set of hypotheses. First, we define the set of propositional terms or Boolean observations. Definition 5.1. Fix a finite set Ω of primitive observations. The set of propositional terms, written T BA , is generated by The relation ≡ BA is the smallest congruence on T BA s.t. for p, q, r ∈ T BA , we have We will write p BA q as a shorthand for p ∨ q ≡ BA q.
We write At for 2 Ω , the set of atoms of the Boolean algebra. It is well known that every α ∈ At corresponds canonically to a Boolean term π α , such that every Boolean term p ∈ T BA is equivalent to the disjunction of all π α with π α BA p [2]. To simplify notation we identify α ∈ At with π α .
We can now use T BA in defining the terms and axioms of CKAO, which will be given as a CKA over a specific alphabet with the following hypotheses: Definition 5.2 (CKAO). We define the terms of CKAO, denoted T CKAO , as T(Σ ∪ T BA ), that is, as the CKA terms over T BA ∪ Σ. We furthermore define the following set of hypotheses over T CKAO : The semantics of CKAO is then given by − ↓ obs .
The hypotheses bool contain the boolean identities, and glue identifies the disjunction with the union (and their respective units as well). contr specifies that if p and q hold simultaneously, then it is possible to observe them in sequence. Note that the converse inequality is not included: observing p and q in sequence has strictly more behaviour than observing p and q simultaneously, as some intervening action can happen between the two observations.
The above definition gives us the semantics of CKAO as the standard pomset language model obtained from taking the obs-closure of the semantics of CKA. As a matter of fact, we find by Lemma 4.7 that if e, f ∈ T CKAO with e ≡ obs f , then e ↓ obs = f ↓ obs ; hence, we already have a sound model of CKAO.
To prove completeness, we will use the techniques from the previous section.
First step: reification. We start by using reification to rid ourselves of the hypotheses from bool and glue, and to simplify the hypotheses in contr. To this end, let contr be the set of hypotheses given by {α ≤ α · α : α ∈ At}. Let Γ = At ∪ Σ ⊆ T BA ∪ Σ. We define r : Σ ∪ T BA → T(Γ ) by setting r(a) = α BA p α a = p ∈ T BA a a = a ∈ Σ Lemma 5.3. The hypotheses obs reduce to exch ∪ contr .
Proof. By Lemma 4.23, it suffices to show that r is a reification, and that obs implies exch ∪ contr . To see that r is a reification, we check the conditions. (i): If a ∈ Σ, then r(a) = a ≡ obs a immediately. Otherwise, if p ∈ T BA , then we derive r(p) = α BA p α ≡ glue α BA p α ≡ bool p and hence r(p) ≡ obs p. (ii): If a ∈ Σ, then we already know that r(a) = a. Otherwise, if α ∈ At, then r(α) = β BA α β = α (iii): This property holds because all hypotheses in exch ∪ contr preserve Γ -languages, i.e., if e ≤ f ∈ exch ∪ contr where f ⊆ SP(Γ ), then e ⊆ SP(Γ ) too. It follows that exch ∪ contr -closure must preserve Γ -languages.
(iv): We should show that if e ≤ f ∈ obs, then r(e) exch∪contr r(f ). To this end, we analyse the separate sets of hypotheses that make up obs.
-Let e ≤ f ∈ bool, then e = p and f = q such that p ≡ BA q. In that case, -Let e ≤ f ∈ contr; then e = p ∧ q and f = p · q for p, q ∈ T BA . Then -Let e ≤ f ∈ glue. On the one hand, if e = p ∨ q and f = p + q, then This also establishes the case for f ≤ e ∈ glue. On the other hand, if e = 0 and p = ⊥, then r(0) = 0 = α BA ⊥ α = r(⊥).
To see that obs implies exch ∪ contr , it suffices to show that obs implies contr . To this end, note that if e ≤ f ∈ contr , then e = α and f = α · α for some α ∈ At. We can then derive that α ≡ bool α ∧ α contr α · α, and hence e obs f .
Second step: factorising. Since contr satisfies the precondition of Lemma 4.28, we obtain the following. This means that, by Lemma 4.17 all that remains to do is strongly reduce exch and contr to ∅; we have already taken care of the former in Theorem 4.26.
Third step: reducing contr . In [13], we have already shown that contr sequentially reduces to ∅. Since contr is grounded we find the following, by Lemma 4.36.
Lemma 5.5. The hypotheses contr strongly reduce to ∅.
Last step: putting it all together. Using the above reductions, we can then prove completeness of ≡ obs w.r.t. − ↓ obs , and decidability of semantic equivalence, too. Proof. For the first claim, we already knew the implication from left to right from Lemma 4.7. Conversely, and for the second claim, first note that that obs reduces to exch ∪ contr by Lemma 5.3. By Lemma 5.4 and Lemma 4.17, the latter reduces to ∅, if we apply Theorem 4.26 and Lemma 5.5. By Lemma 4.12, we then conclude that obs is complete and decidable, hence establishing the claim.

Discussion
The first contribution of this paper is to extend Kleene algebra with hypotheses [7] with a parallel operator. The resulting framework, concurrent Kleene algebra with hypotheses (CKAH), is interpreted over pomset languages, a standard model of concurrency. We start from simple axioms, known to capture equality of pomset languages [23]. CKAH allows to add custom axioms, the so-called hypotheses. These may be used to include domain-specific information in the language. We develop this framework by providing a systematic way of producing from the hypotheses a sound pomset language model. We also propose techniques that may be used to prove completeness and decidability of the resulting model.
An important instance of this framework is concurrent Kleene algebra (CKA) as presented in [11]. The only additional axiom there, known as the exchange law, may be added as a set of hypotheses. We prove that the resulting semantics coincides with the (subsumption-closed) semantics of CKA and, more interestingly, the completeness proof of [15] can be recovered as an instance of this framework.
The second contribution is a new framework to reason about programs with concurrency: concurrent Kleene algebra with observations (CKAO). CKAO is obtained as an instance of CKAH, where we add the exchange law to model concurrent behaviour, and Boolean assertions to model control flow. The Boolean assertions we consider are as in Kleene algebra with observations (KAO) [13] -in fact, CKAO is a conservative extension of KAO. Using the techniques developed earlier, we obtain a sound and complete semantics for this algebra. While CKAO is similar to concurrent Kleene algebra with tests [12], it avoids the problems of the latter by distinguishing conjunction and sequential composition. CKAO provides the first sound and complete algebraic theory that seems sensible as a framework to reason about concurrent programs with Boolean assertions.
Future work is to explore other meaningful instances of CKAH. Synchronous Kleene algebra [29,26] is a natural candidate for this. We also want to try and design domain specific languages, specifically, a concurrent variant of NetKAT [1,8].
The class of hypotheses considered in this paper for which decidability and completeness may be established systematically is somewhat restrictive; identifying larger classes of tractable hypotheses is a challenging open problem.
Because of the compositional nature of our model, the CKAO semantics of a program contains behaviours that are not possible to obtain in isolation. These behaviours are present to allow the program to interact meaningfully with its environment, i.e., when placed in a context. However, for practical purposes one might want to close the system, and only consider behaviours that are possible in isolation. Studying this semantics remains subject of future work.
In the semantics of concurrent programs with assertions, it would be natural to see atoms as partial instead of total functions. This captures the intuition that a thread might not have access to the complete machine state, but instead holds a partial view of it. Pseudo-complemented distributive lattices (PCDL) have been proposed [12] as an alternative to Boolean algebra, modelling this partiality of information. We leave it to future work to investigate the variant of CKAO obtained by replacing the Boolean algebra of observations with a PCDL.