Cyclic proofs for transfinite expressions

We introduce a cyclic proof system for proving inclusions of transﬁnite expressions, describing languages of words of ordinal length. We show that recognising valid cyclic proofs is decidable, that our system is sound and complete, and well-behaved with respect to cuts. Moreover, cyclic proofs can be eﬀectively computed from expressions inclusions. We show how to use this to obtain a Pspace algorithm for transﬁnite expression inclusion. 2012 ACM Subject Classiﬁcation Theory of computation → Automata over inﬁnite objects; Theory of computation → Proof theory; Theory of computation → Logic and veriﬁcation


2
The case of ω-regular expressions In this part, we do not yet look at truly transfinite expressions such as (a + b ω ) ω , but only at ω-regular ones, which are the ones describing languages of words of length at most ω.More formally, these expressions can be described by the following grammar.To associate a language L(g) of finite or infinite words to an ω-regular expression g, it suffices to interpret each constructor on languages in the standard way: We avoid the use of ε, and we use e + instead of e * , to guarantee that an expression e ω only accepts infinite words.
We design a proof system S ω that will provide a certificate for any inclusion between the languages of two such expressions.Starting with the special case of ω-regular expressions allows us to introduce most proof techniques, while staying in a more familiar framework.We also claim that already in this case, such a proof system can bring new insights, as it can offer interesting trade-offs compared to automata models (see Conclusion).

The proof system S ω
The proof system described in this section is strongly inspired from [11], the novelty being the introduction of ω.

Rules for building preproofs
We will first describe the sequents of the system S ω , i.e. the shape of any label of a node in a proof tree.These are identical to the ones we use later, in the proof system for generalised expressions.Definition 1 (Sequent).We call sequent a pair (Γ, B), noted Γ → B, where Γ is a list of expressions and B is a nonempty finite set of such lists.In the rest of the paper, upper case Greek letters will be used for lists of expressions, and upper case Latin letters for sets of lists.Γ will be called the left side of the sequent and B its right side.Their contents will be denoted as follows, with brackets isolating each list in B: Languages are associated to such lists and sets of lists in the following way: The sequent Γ → B is called sound if the inclusion L(Γ) ⊆ L(B) holds.
To describe our proof system, we now need to define the notion of proof tree.These are usually finite objects, but in our setting we allow infinite trees.
A tree is a non-empty, prefix-closed subset of {0, 1} * .We typically represent it with the root ε at the bottom, and the sons v0 and v1 of a node v (if they exist) are represented above v, respectively on the left and on the right.
A branch of a tree T ⊆ {0, 1} * is a prefix-closed subset of T that do not contain two words of the same length, i.e. two nodes at the same depth of the tree.A branch of T is maximal if it is not strictly contained in another branch of T .
A preproof is given by a tree and a labelling π of its nodes by sequents in such a way that for any node v with children v 1 , . . ., v n (with n ∈ {0, 1, 2}), the expression π(v 1 ) π(v) is an instance of a rule from Figure 1.
A preproof is called cyclic or regular if it has finitely many distinct subtrees.Such a proof can be represented using a finite tree, where each leaf x not closed with an id rule is equipped with a pointer to a node y below x, indicating that the infinite trees rooted in x and y are identical.Examples of this representation can be found in Figure 2.

Threads and validity condition
Some preproofs satisfying the conditions described above actually prove wrong inclusions, meaning that we can build such a tree with an unsound sequent at its root.An example of such a preproof can be found in Figure 2.This illustrates the need for a validity condition that will rule out such unsound preproofs.We need a few more definitions before we can state this validity condition.
Occurrences: When talking about "expression" in a preproof, we will actually be talking about particular occurrences of an expression in the preproof, see Appendix A.1 for details on this.If S is a sequent, we will note pos(S) the set of expression positions in S.

Principal expression:
In a sequent of a preproof where a rule r is applied, an expression is called principal for r if it is the one corresponding to the lower case expression in the lower side of the rule r from Figure 1.Note that there is no principal expression when the rule is id, wkn, cut or match, since these rules do not contain lower case letters in the lower sequent.Ancestors: Given an expression e in the lower part of a rule, its immediate ancestors are: if e is principal: the lower case expressions in the upper sequents of the rule if e is in a list Γ or a set of list B: its copies in the same position in each copy of Γ (resp.B) on the upper sequents.Note that an expression can have between 0 (expression in C in the wkn rule) and 3 (e + in any * rule) immediate ancestors.
Threads: A thread is a path in the graph of immediate ancestry (also called the logical flow graph [7]).We say that a thread witnesses a v-unfolding if the current expression is principal for either a * -l rule or an ω-r rule.As in Figure 2, threads will be represented by colored lines, with bullets to mark v-unfoldings.
Note that we purposely talk about the "graph" of immediate ancestry, and not the "tree".Since the right part of a sequent is a set, it does not keep track of multiplicity, and two threads can merge when going upwards.For instance, if we apply the rule Γ → e, e ω ω-r Γ → e ω ; e, e ω • , the red and blue threads are merged.We need to allow that phenomenon in order to be able to build finitely representable proofs.
We can now define the validity condition, that makes a preproof into an actual proof.

Definition 2 (Validity condition).
A thread is validating if it witnesses infinitely many v-unfoldings.A preproof is valid, and is then called a proof, if all its infinite branches contain a validating thread.
We will call * -l thread (resp.ω-r thread) a validating thread on the left side (resp.right side) of sequents, as it witnesses infinitely many * -l (resp.ω-r) rules.
Let us give an intuition for this validity condition.A proof has to guarantee that any word generated by the left side expression can be parsed in the right side one.Branches with a * -l thread do not correspond to a word on the left side, so there is nothing to verify and the branch can be accepted.On the other hand, when a legitimate infinite word from the left side has to be parsed on the right side, it must involve an expression e ω where e is matched to infinitely many factors.This corresponds to an ω-r thread.
We give two examples of preproofs in Figure 2. The left one is an invalid preproof of a wrong inclusion.The validity condition is not satisfied, since there are no * -l or ω-r rules.
The right one is an actual proof.It is comb-shaped, with a "main" branch always going to the right.We can get a validating thread for any branch of that preproof, by taking the red thread on the rightmost branch, and a blue thread on all other branches.
For an example of a non-trivial inclusion, see Appendix A.
An invalid preproof (left) and a valid one (right)

Soundness of the system S ω
In this part, we want to prove that any proof (i.e.any valid preproof) derives a sound sequent.We will do that without any assumption of regularity, since we want every proof from the S ω system to be correct, and not just the regular fragment.We will show soundness of the system with cuts, since this is more general and it allows to write proofs more conveniently.Notice that incorporating the cuts significantly increases the difficulty: unlike what happens in a finitary proof system, it is not enough here to prove that the cut rule is locally sound.Since the cuts can be used infinitely many times along a branch, it calls for a careful argument.Missing details and proofs can be found in Appendix A.3.The following first result is an easy consequence of the local soundness of our rules: Lemma 4. Any finite preproof derives a sound sequent.
To prove the general case, we take any valid proof tree P in S ω , with a root sequent Γ 0 → B 0 .We take an arbitrary w ∈ L(Γ 0 ), and we show that w ∈ L(B 0 ).
We create a tree P (w) that will be a subtree of the original one, with additional information labelling its nodes.The purpose of the tree P (w) is to prove the membership of w in L(B 0 ).
The sequents of P (w) are similar to the ones of a preproof, but we additionally label each expression e on the left side of sequents with a word u.Given a list of expressions Γ, we will denote Γ a labelling of its expressions with words, represented as a list of pairs (expression, word).If Γ = (e 1 , u 1 ), . . ., (e k , u k ), we say that (the labelling of) Γ is correct if for each i ∈ [1, k], we have u i ∈ L(e i ).We define concat(Γ ) as the word u 1 . . .u k .We additionally say that a sequent Γ → B is label-sound if concat(Γ ) ∈ L(B).
We will build P (w) by transforming the initial proof by induction from the root.First we take a correct labelling Γ 0 of Γ 0 such that concat(Γ 0 ) = w.Then we move upwards while replacing each rule by the corresponding one in the table below, while satisfying the condition specified in the table (if possible).This tree will be a subtree of the initial one since we only keep one successor at rules +-l and * -l.

Rule
Notice that if the labelling of the bottom sequent is correct, this guarantees us that we can choose a correct labelling for the upper sequent as well, while satisfying the condition in the table.It is only because of the cut rule that we cannot simply propagate correctness of labellings from the root.Moreover, all these rules are label-sound, in the sense that their lower sequents are label-sound whenever the upper ones are.
If at some point the condition cannot be met, we stop there and call the current node a dead leaf.This is only important for the sake of a complete definition, since we will prove that this actually never occurs if the initial preproof is valid (Lemma 8).
We deal with the remaining rules (right rules, wkn and match) by simply copying the pairs (expression, word) from bottom to top on the left side.
Lemma 5.In P (w), any infinite branch has an ω-r thread.
Proof.This follows from the fact that any expression e + on the left of a sequent in P (w) is associated with a finite word, and therefore can only be principal for finitely many * -l rules, each one decreasing the size of that word (notice that we use an infinite descent argument here).The validity condition then ensures the result.Lemma 6.In P (w), no branch goes infinitely many times to the left at cut rules.
Proof.Let us consider an infinite branch β of P (w).By Lemma 5, the branch β has an ω-r thread.Since the right side of a sequent is not preserved when going to the left at a cut rule, it can only happen finitely many times in β.
If β 1 , β 2 are maximal branches, we note The following Lemma is proved in Appendix A.3.1.Lemma 7. The maximal branches of P (w) are well-ordered by ≤.
The main Lemma for the soundness proof is Lemma 8, which also ensures that there is no dead leaf in P (w).Lemma 8.In P (w), all labellings are correct and all sequents are label-sound.
Proof.(Sketch) We just give the main idea here, a detailed proof can be found in Appendix A.3.2.We proceed by well-founded induction on the maximal branches, using the left-to-right order from Lemma 7. The only interesting case it when dealing with cuts., we need to show that the label (e, u) is correct, i.e. provided u ∈ L(Λ ), we have u ∈ L(e).This will be obtained thanks to the induction hypothesis, guaranteeing that the sequent Λ → e on the left of the cut rule is label-sound.
Theorem 9. Any valid proof from S ω is sound.
Proof.For any word w in L(Γ 0 ), there is a way to correctly label Γ 0 into a Γ 0 with concat(Γ 0 ) = w.By Lemma 8, this correct labelling can be propagated through P (w), and we obtain that the root sequent Γ 0 → B 0 is label-sound, so w ∈ L(B 0 ).Thus we have indeed L(Γ 0 ) ⊆ L(B 0 ), showing that any valid proof is sound.
Remark 10.This result is similar to the soundness in [13], but the shape of the sequents differs, and the transfinite case that follows uses an extension of our proof.

Cut-free regular completeness of the system S ω
In order to prove the completeness of the system, we want to show that any sound sequent can be derived.Moreover, if we want this system to be interesting from a computational point of view, we need to obtain finitely representable proofs.The following lemma will help us do that by ensuring a finite number of different sequents in a proof.Then we will build a regular proof via a deterministic saturation process.
Lemma 11.In a preproof without cut, there can only be finitely many different sequents.
Proof.Let us call expr(Γ) the expression formed by concatenating the expressions in Γ, and similarly expr(B) is the expression Γ∈B expr(Γ).We can verify that for every rule except cut, if Γ 0 → B 0 is the conclusion sequent and if Γ 1 → B 1 is a premise sequent, then expr(Γ 1 ) is in the (Fischer-Ladner) closure of expr(Γ 0 ).Roughly speaking, the closure of an expression e is the set of expressions that can be obtained from e by taking sub-expressions, and unfolding f * or f ω to the left, if this factor was at the beginning of the expression.See Appendix A.4 for a precise definition of closure suited to our framework.Similarly, expr(B 1 ) is in the closure of expr(B 0 ).We can also note that given an expression, there are only finitely many ways to subdivide it into a list or into a set of lists, which gives us finitely many possible sequents.Notice that we rely here on the fact that we allow unfolding of • + and • ω only at the beginning of a list, thereby preventing multiple consecutive unfoldings of the same expression.
We will now take a sound sequent, and build a preproof using only invertible instances of our rules, i.e. rules that are locally sound in both directions: the premises are true if and only if the conclusion is true.We proceed by induction on the outermost operation of the first expression of a list.
We first apply greedily the invertible rules from Figure 3. Notice that at each step, the first expression of the list becomes a (strict) subexpression of the previous one.Since the subexpression relation is well-founded, we must at some point obtain a finite tree with leaves of the form a, Γ → a 1 , Γ 1 ; . . .; a n , Γ n (with a and a i letters).Moreover, each of those leaves are sound sequents, since all the rules we applied were invertible.For each leaf of this form, we can now remove each a i , Γ i with a i = a using the wkn rule, then match the remaining as follows.

Outermost operation
Left side Right side Invertible rules of the system, without the match rule . . .
Since the bottom sequent is sound, we know that the top one is too (we only removed useless options).We can therefore repeat the process to get an infinite tree with only identity rules at the leaves.Any sequent in this tree is sound by a straightforward induction.We now need to check that this is a valid tree.
First note that, as this process will always reach a match rule in a finite number of steps, any infinite branch passes through infinitely many match rules, therefore processing an ω-word (every match rule corresponds to a new letter in the word).In other words, to each infinite branch β of the preproof, we can associate an infinite word word(β) corresponding to the sequence of match rules performed along β.Lemma 12.If β is an infinite branch starting in the root sequent Γ 0 → B 0 , then either β contains a * -l thread, or word(β) ∈ L(Γ 0 ).
Proof.Let us assume β does not contain a * -l thread.Since the match rule strictly decreases the size of the list on the left, we know that β contains infinitely many * -l rules or ω-l rules, because these are the only rules that can increase the size of the list (if we call size the number of characters in the list).
The intuition is then that as soon as no * -l expression is unfolded infinitely many times, the unfoldings of both kinds of fixed points (• + and • ω ) of Γ respect their semantics.It is then natural that the word obtained via such unfoldings, together with arbitrary choices for disjunctions, is in L(Γ).See Appendix A.5 for a detailed proof.

Theorem 13. The regular and cut-free fragment of S ω is complete for ω-regular expressions.
Proof.Given a sound sequent Γ 0 → B 0 , we consider the preproof defined above, and we prove its validity.
Let us consider an infinite branch β without * -l thread.Let w = word(β), by Lemma 12 we have w ∈ L(Γ 0 ).Since Γ 0 → B 0 is sound, we have w ∈ L(B 0 ).We will use this to build an ω-r thread validating the branch β.To do so, the intuition is that at each disjunctive choice C S L 2 0 2 2 15:10 Cyclic proofs for transfinite expressions in the right-hand side, we choose according to a parsing witnessing w ∈ L(B 0 ).However we cannot do that in a greedy manner, see Appendix A.6 for an example showing why.
Let us describe how we build a validating thread for our branch.We start with a list from B 0 that contains our word w, and take the last expression of this list (the one containing • ω ) to begin our thread.We then build it going upwards and always staying on an expression containing • ω .
The only choices we have to make when building this thread upwards are when we meet the rule Γ → e, Σ ; e, e + , Σ ; B * -r Γ → e + , Σ ; B or the rule a, Γ → e, Λ ; f, Λ ; B +-r a, Γ → e + f, Λ ; B .In the first case ( * -r rule), there is a smallest integer n such that e + can be replaced with e n in the lower sequent while preserving the fact that the current remainder of w is in the language of the list.We will then continue while treating e + as e n , and at every * -r rule on that thread we either go to e if n = 1 or e, e n−1 otherwise.This replacement is purely "virtual": we simply keep it in mind as a guide to pick a thread.
In the second case (+-r rule), there is at least one side containing our word (without the prefix we already read), so we simply choose it.Virtual replacements of some e + by e n are still taken into consideration here, as can be seen in the example of Appendix A.6.
We will necessarily unfold infinitely many times the • ω expression chosen at the beginning, since we match all letters of w while keeping the invariant that it belongs to the chosen list.
In the end, we get a valid proof for any sound sequent, which proves the completeness of our system, using only regular proofs thanks to Lemma 11.Note that we could settle here for a weaker match rule, that would only match the first letter.

Deciding the validity criterion
Given a preproof in our system, we want to decide whether it satisfies the validity criterion.
This section is dedicated to proving the following theorem: Theorem 14.It is decidable in Pspace whether a given cyclic preproof of S ω is valid.
The arguments are similar to those in e.g.[18,13].We summarise here the main ideas, we will build on them in the next section and for the transfinite case in Section 3.5.
We start by introducing an auxiliary notion: Definition 15 (Sequent transition).Given two sequents S 1 , S 2 , a transition from S 1 to S 2 is a function ϕ : pos(S 1 ) × pos(S 2 ) → { , , • }.It encodes a way of linking S 1 to S 2 by threads: the value ϕ(p 1 , p 2 ) will be equal to if there is no thread from p 1 to p 2 , if there is a thread with no v-unfolding from p 1 to p 2 , • if there is a thread with v-unfolding from p 1 to p 2 .
We only represent here non-trivial transitions, i.e. we consider only threads of length at least 1.Notice that here S 1 and S 2 are sequents in the finite representation of the proof tree, so they might represent an infinite set of sequents in the unfolded proof tree.Therefore, there might be several different ways of linking them by threads, yielding different transitions ϕ.

Composing transitions:
We define an order on { , , • } by setting < < • , and a product law • by setting as absorbing and as neutral.
If we have transitions ϕ from S 1 to S 2 , and ϕ from S 2 to S 3 , they can be composed to yield a transition ϕ = ϕ ϕ from S 1 to S 3 .This composed transition is defined by ).This gives to the set of transitions a structure of finite monoid.

Guessing a bad transition:
A self-transition on a sequent S is a transition from S to S. A self-transition ϕ is called idempotent if ϕ ϕ = ϕ.An idempotent transition on S is called bad if for all p ∈ pos(S), we have ϕ(p, p) = • .
The validity algorithm is based on the following observation: Lemma 16.A regular proof is invalid if and only if it contains a bad idempotent transition.
We can finally design a nondeterministic algorithm, which will guess such a bad idempotent transition.It amounts to guessing a branch and a segment along this branch witnessing the idempotent bad transition.The transition ϕ is computed on-the-fly on this segment.Since keeping a transition ϕ in memory only takes polynomial space, and NPspace =Pspace, we end up with a Pspace algorithm.
Remark 17.If the size of sequents is logarithmic in the size of the proof, this algorithm is actually in Logspace.This is put to use in the next section.

Pspace inclusion algorithm via proof search
We will now combine the above algorithm with our completeness result, in order to obtain a Pspace algorithm for inclusion of ω-regular expression.This matches the known complexity of expression inclusion, which is Pspace-complete even in the case of finite words.
We are now given only the sequent we aim to prove, and we will non-deterministically explore its proof as built in Section 2.3.Notice that this proof can be exponential in the size of the root sequent, but this is not a problem, since the algorithm only guesses a branch and follows it on-the-fly.We only have to ensure that each sequent, and therefore each transition ϕ, is polynomial in the size of the root sequent.This might however not be the case, because a list e + , Λ can be unfolded into e, Λ ; e, e + , Λ , thereby duplicating an arbitrary sequent Λ. Iterating this could lead to sets of exponential size.This is solved by adding some syntactic sugar in our system: the sequent e + , Λ will be unfolded into e, e + ?, Λ .More precisely, we perform the following rule replacement: The notation e? means that e optional.This is expressed by adding the following pseudo-rule: This does not change the behaviour of the system, but guarantees that all sequents stay polynomial in the size of the root sequent, see Appendix A.10.If the size of sequents is bounded by M , the size of any transition is in O(M 2 ), so a bad idempotent transition, if it exists, can be computed on-the-fly using polynomial space.Since the rules used in the preproof described in Section 2.3 follow deterministically from the root sequent, we can indeed use nondeterminism to guess a bad branch.
Thus we obtain a nondeterministic Pspace algorithm for inclusion of ω-regular expressions, via proof search in the system S ω .

C S L 2 0 2 2 The transfinite proof system
The goal is now to adapt the system in order to deal with transfinite expressions, recognising language of transfinite words.

Ordinals and transfinite words
Ordinals: Let us recall that ordinals are closed under taking successors and limits, and that besides the ordinal 0, every ordinal is either a successor ordinal (i.e. of the form α + 1), or a limit ordinal, such as ω which is the smallest limit ordinal.If β is a limit ordinal and (x i ) i<β is a sequence of length β, a subsequence (x ij ) j<ω of length ω is said cofinal if for all i < β, there exists j ∈ ω such that i < i j .
Transfinite words: If α is an ordinal, a transfinite word of length α on alphabet Σ is a function α → Σ. See Appendix A.7 for formal definitions and properties of transfinite words.
In this work, we will restrict the length α to be strictly smaller than ω ω , i.e. α will be smaller than ω k for some k ∈ N.These ordinals describe the length of words obtained with expressions that are allowed to nest the ω-power finitely many times.
Transfinite expressions: They are similar to ω-regular expressions, except that the ω operators can now be used freely: they do not need to appear once at the end, but can appear anywhere and be nested.That is, transfinite expressions are generated by the grammar: The language L(e) of a transfinite expression e is defined as expected, the formal definitions at the beginning of section 2 for semantics of ω-regular expressions can be used in the transfinite case as well.For instance, the word (a ω b) ω is in the language L((a ω + b + ) ω ).

Adapting the proof system
The new proof system: To build a proof system dealing with transfinite expressions, we will basically keep the same rules as in S ω , except that ω operators are not required to appear at the end of lists anymore.This gives rise to the following relaxed rules for ω: Another difference will be that a preproof will not be a tree anymore, but a forest, i.e. a set of trees with distinct roots.This will allow us to consider branches of ordinal length: after taking ω steps in a tree, a branch can "jump" to the root of another tree via a limit condition, analogous to the validity condition of the previous section.

Branches, threads and limit sequents:
We define inductively these notions as follows.These definitions are mutually recursive, but well-founded: the notions are defined together for a fixed ordinal length, before going to the next one or the limit.
A transfinite (resp.limit) branch is a transfinite sequence of sequent positions in the forest (resp. of limit length), starting at the main root sequent of the proof.The successor of a sequent must be just above it in the forest, and any non successor sequent must be the limit sequent of the limit branch before, as defined below.A transfinite (resp.limit) thread is a transfinite sequence of expression occurrences following a transfinite (resp.limit) branch, while respecting immediate ancestry for successor sequents, and going to the corresponding expression of the limit sequent when jumping to the limit sequent, as defined below.
A limit thread with a cofinal sequence of expressions that are principal for a rule r is called a r thread.The limit sequent of a limit branch, when it exists, is a root sequent from some tree in the proof forest, possibly the tree containing this limit branch.We define it by considering the ω-l and ω-r limit threads following the branch cofinally.On the left side, there must be an ω-l thread, that is principal infinitely often on the same sequent of the form e ω , Γ, such that no rule is applied on Γ after some point.The corresponding limit sequent will have Γ as left-hand side.
We proceed similarly to get the lists on the right side of the limit sequent.Given an ω-r limit thread principal infinitely often on some list e ω , Γ , with Γ untouched after some point, we will have a list Γ on the right-hand side of the limit sequent.Any list on the right that cannot meet these conditions is discarded in the limit sequent.In both cases (left and right of the sequent), we call e ω the frontier expression of that list.
The threads are prolonged to that limit sequent the natural way, by taking the limit of an inactive thread on the right of a frontier expression as the corresponding expression in the limit sequent.These definitions are illustrated in Appendix A.8, with an example of a proof.
A visualisation of a limit branch of length ω 2 is given in Figure 4.Such a branch goes through ω trees, not necessarily distinct.Validity condition: A proof forest is valid if any limit branch either contains a cofinal * -l thread, or has its limit sequent appearing as the root of a tree in the proof forest.
A proof forest is called cyclic (or regular) if it is the unfolding of a finite graph (not necessarily connected), or equivalently if it contains finitely many non-isomorphic subtrees.
Let us call S t this proof system for inclusion of transfinite expressions.

Soundness
The soundness of S t is shown in a similar way to the one of S ω .We first note that as the rules are locally sound, Lemma 4 still holds for S t , meaning that any finite proof is sound.Given a valid proof P in S t , with root sequent Γ 0 → B 0 , and a word w ∈ L(Γ 0 ), we can still build a labelled proof P (w) to witness w ∈ L(B 0 ).This is done in the same way as before, but we also add the limit sequents for every new limit branch that appears, while preserving the labelling in the natural way.
Note that this process can lead to a bigger forest, since a single root sequent in the initial proof P can lead to several ones with different labellings in this proof.We can still build the forest using transfinite recursion, knowing that there are less than ω ω trees.

C S L 2 0 2 2 15:14 Cyclic proofs for transfinite expressions
We will reuse the concept of correct labelling and label-soundness of a sequent Γ → B, meaning that the word concat(Γ ) is in L(Γ ) (and is correctly split if Γ is a list) and L(B) respectively.
Lemma 18.In P (w), any limit branch can be extended (i.e. has a limit sequent).
Proof.This is simply a consequence of the fact that we build P (w) according to a parsing of w in Γ 0 .Therefore we cannot unfold infinitely many times a same expression e + .Since the validity condition asks for either a * -l thread or a limit sequent, we must be in the second case on all limit branches of P (w).

Lemma 19.
In P (w), there is no transfinite branch that goes infinitely many times on the left at a cut rule.
Proof.Suppose that there is a transfinite branch that does go infinitely many times on the left.Let us take the smallest prefix of that branch that still respects that condition (possible by well-foundedness).This is a limit branch (otherwise it can be made even smaller), which goes to the left premise of a cut rule cofinally, which cuts any ω-r thread.Since Lemma 18 ensures a limit sequent for that branch, there has to be an ω-r thread (the right side of a sequent is nonempty), hence the contradiction.
As before, the maximal transfinite branches in P (w) can be ordered from left-to-right, by comparing them at the first cut rule where they take a different direction (which exists by well-order property).We denote that order by <.
Lemma 20.The order < over the maximal transfinite branches of P (w) is well-founded.
Proof.The proof is similar to the one of Lemma 7, the only notable change being that the word over {0, 1} associated to a branch is now transfinite.
Lemma 21.In P (w), all lists on the left side are correctly labelled, and all sequents are label-sound.
Proof.As in Lemma 8, we prove this by a transfinite induction on the left-to-right order < on branches, which is well-founded by Lemma 20.
Let us call C the set of maximal transfinite branches from P (w).Assume that, for some branch β ∈ C, every β < β verifies the property.
The first thing we want to prove is the correct labelling in β.This part is done as for S ω , by induction on the branch.We need to add the limit case since the branch is transfinite.Since limit sequents are untouched in the limiting process, the limit case of the induction is straightforward i.e. limit sequents are correctly labelled.
We now want to prove the second part of the induction.Let us call v the vertex just above the last left cut of β.We want to prove the label-soundness of the proof rooted in v.We call β v the part of β above v.We know that in β v , a sequent is label-sound if its successor in the branch is.We want to prove by transfinite induction on the length of β v that the sequent at v is label-sound if the last sequent of the branch is (recall that in S t , all branches have a last sequent).
What we need for that is to prove that if the limit sequent of a limit branch is label-sound, then so is (at least) one sequent in that branch.
Let us consider such a limit branch, with limit sequent Γ → B. The word concat(Γ ) is in the language of some list Λ ∈ B. We can now use the exact same process as for S ω (see Figure 6 in Appendix A.3.2) to prove that there is a label-sound sequent Π , Γ → f ω , ∆ ; D in the branch before.The only difference is that transfinite branches can be hidden between two ω-r rules, but they are dealt with using the induction hypothesis for shorter branches.
This completes the inductive proof for the label-soundness of β v .Using the global induction on the well-order < on branches, we get the final result.
Theorem 22. Any valid proof in S t is sound.
Proof.By Lemma 21, the root sequent of P (w) is label-sound, and this is true for any w ∈ L(Γ 0 ).This means that for any w ∈ L(Γ 0 ), we have w ∈ L(B 0 ), thus any valid proof has a sound root sequent.

Cut-free regular completeness of S t
We start with the following observation, a straightforward generalisation of Lemma 11: Lemma 23.In a proof forest without cut and without useless trees (that can be removed while preserving the validity), there can only be finitely many different sequents.
Theorem 24 (Completeness).Given two expressions e and f such that L(e) ⊆ L(f ), there exists a cut-free cyclic proof forest for e → f .Moreover, the construction is effective.
Proof.Due to space constraints, we only sketch the proof here, details can be found in Appendix A.9.As before, we build the proof using a straightforward deterministic bottom-up process, which can be done algorithmically.This time however, in order to show that the obtained proof satisfies the validity condition, we use a model of transfinite automata that helps us to exhibit a validating thread or a limit sequent for each limit branch.
The idea of the proof is to follow the runs of automata A e and A f canonically associated to e and f , and to build a proof whose nodes are labelled by states of these automata.A state will be associated to each list of expressions, so for each sequent, we will have one state on the left side and possibly several on the right side.Notice that this intuitively corresponds to building a run in a product automaton A e ×P(A f ), where P(A f ) is a powerset automaton obtained from A f .Since the structure of automata closely follow the structure of expressions, we can always keep the wanted invariants.Limit nodes are built by looking at all the infinite threads in limit branches, and are labelled by the set of states seen cofinally in the corresponding runs.We thereby ensure that the resulting proof is valid.

Decidability and Complexity
We generalise here the decidability and complexity results obtained in Sections 2.4 and 2.5: Theorem 25.Given a cyclic preproof in S t , there is a Pspace algorithm deciding whether it is valid.Given a sequent Γ → B, there is a Pspace algorithm deciding whether there is a valid proof of S t with root Γ → B. As before, the second item is deduced from the first together with Theorem 24.
Given a regular preproof that can be explored (or built) on-the-fly, we will again use the formalism of transitions: if S 1 and S 2 are sequents in the finite representation of a proof, we will use a function ϕ : pos(S 1 ) × pos(S 2 ) → { , , • } to sum up the information about threads from S 1 to S 2 in a particular path of the unfolded proof.We also mark the unfoldings of ω on the left, since we need those to compute limit sequents.

C S L 2 0 2 2 15:16 Cyclic proofs for transfinite expressions
We have to account for the fact that a transition may now represent a path containing (nested) passages to the limit.We verify that such passages to the limit can be effectively computed, and incorporated in our saturation procedure.Remark that the information stored in a transition is enough to identify a frontier expression in an idempotent sequent.By another application of Ramsey's theorem, this will allow us to compute limit sequents, and build transitions corresponding to branches of any length (by keeping only threads to the right of frontier expressions).Now, according to the transfinite validity criterion, an idempotent transition is bad if it does not have a * -l thread or a limit sequent.As before, our goal is to guess a bad idempotent transition corresponding to a transfinite branch, if any exists.Notice that guessing such a transition involves guessing a starting point, and that starting points at different levels of ω nesting may differ.This means that our nondeterministic algorithm has to store a current prefix of guessed transition for each level, in order to build the final bad idempotent transition.An example of a run of this algorithm can be found in Appendix A.8.

Compact notation
When building the proof on-the-fly according to the construction of Section 3.4, we also need to ensure that transitions stay of polynomial size.To this end, as in Section 2.5, we will use the compact notation e? to avoid an exponential blow-up of sequent size.Note that this simplified representation allows passage to the limit sequent, in the sense that the computation of the limit sequent of a branch using compact notation will yield a compact notation of the correct sequent.As before, this compact notation allows us to obtain a bound on the size of sequents which is polynomial with respect to the size of the root sequent, see Appendix A.10 for details.
Thus, we obtain the following corollary, which is a new result to the best of our knowledge.

Conclusion
In our completeness proof, the sets of lists on the right sides of sequents perform some kind of powerset construction.Doing so, we avoid an intricate determinisation procedure such as the Safra construction [19].We believe it can be considered that this complexity of determinisation is "hidden" in the validity condition, following various infinite threads simultaneously.This has the advantage of modularity: we separate the pure powerset construction, located in the sequents of the proof, from the complexity of dealing with the acceptance condition, located in the validity condition of the proof.Whereas when determinising Büchi automata, these two causes for state-blowup are merged in the states of the resulting deterministic Rabin automaton.A more detailed investigation of this phenomenon and its advantages can be the subject of a future work.
Contrarily to what happens on ω words, the transfinite system S t cannot be seen as an instance of a proof system for linear µ-calculus, as • ω is no longer a fixed point operator in the transfinite setting.This manifests concretely by the loss of symmetry between • + and • ω in the validity condition when going from S ω to S t .

A.1 Occurrences of expressions
We will need to consider particular occurrences of expressions in preproofs.To this end, we define notion of occurrence of an expression in a preproof, which is formally defined as a tuple (v, i, j) where v ∈ {0, 1} * is a node of the tree, i is the index of a list in the sequent labelling that node, and j the index of an expression in that list.This means we actually need to represent the right side of any sequent by a sorted set of lists of expression, using some arbitrary order over lists.In the rest of the paper, in order to lighten notations, we will abstract away this formalism and just use the word "expression" to point to particular occurrences of expressions in a preproof.
If S is a sequent, we will note pos(S) the set of expression positions in S, that is identifiers (i, j) that are compatible with the sequent S.

A.2 A cyclic proof of a non-trivial inclusion
Example 27 (A cyclic proof for the inclusion of ω-regular expressions).The following proof shows that L((a + b) ω ) ⊆ L((b * a) ω + (a + b) * b ω ), i.e. any infinite word on alphabet {a, b} has either infinitely or finitely many a's.Black arrows, called backpointers, identify sequents that are roots of isomorphic sub-trees.To simplify the reading, we temporarily suspend our naming convention regarding capital letters, and we note A = (a + b) ω (for "All"), I = (b * a) ω (for "Infinite"), and F = (a + b) + , b ω (for "Finite").Note that our expressions cannot use the Kleene star : b * a is just a shorthand for b + a + a, and that is why This proof forest is valid: the only options for limit branches are either going only right after some point, or going left infinitely many times.In the first case, following the expression b ω (in red) gives us an ω-r thread, and in the second one we get such a thread by following the sequent I (blue).If β, β are branches in P (w), we say that β is to the left of β , noted β < β , if at the first cut where they differ, β goes left and β goes right.We want to prove that this left-to-right < order on branches of P (w) is a well-order.
Let us call C the set of maximal branches in P (w), ordered from left to right.More formally, we can see an element of C as a (finite or infinite) word over {0, 1}, in which each letter corresponds to the choice made at a cut rule: 0 for left and 1 for right (cut rules are the only branching rules in P (w)).With this, the left-to-right order is simply the lexicographic order: We take a nonempty subset X ⊆ C. Consider the subtree T X of P (w) formed by the branches in X.Note that this tree could contain branches that are not in X.For instance if X = {0, 10, 110, 1110, . ..}, then T X also contains the branch 11111 . .., noted 1 ω .We call m the leftmost branch in T X : we can define it by induction, by going left whenever possible.We want to show that m ∈ X.If m = 1 ω , then clearly m ∈ X.Otherwise, by Lemma 6, m can be noted τ 01 ω .There must be a branch β ∈ X starting with τ 0 as well.By minimality of m, we have m ≤ β, and since m = τ 01 ω , we have m ≥ β.Therefore m = β, and m ∈ X.
We finally get that m is the smallest element in X.Any subset of C has a smallest element, so (C, ≤) is well-founded.

A.3.2 Proof of Lemma 8
Lemma 8.In P (w), all labellings are correct and all sequents are label-sound.
We proceed by well-founded induction on the maximal branches.The property we want to prove is the following one: "Given a maximal branch β of P (w), any labelling on β is correct.Moreover, any sequent above the last left cut of β is label-sound." Assume that, for some maximal branch β, every other one on its left verifies the property.We prove by induction that the labellings of β are correct.By definition of P (w), this is preserved when we go upwards at any rule other than cut.This is also the case when we go on the left of a cut rule.We need to prove that it still works when we go on the right, in a rule such as: In this instance, u ∈ L(e) if and only if the sequent Λ → e is label-sound (because u is the word in Λ by definition of P (w)).To prove that it is the case, we use the induction hypothesis for the maximal branch going to that sequent, then always on the right at cut rules.This branch is on the left of the current one, so according to the second part of the induction hypothesis for this branch, the sequent Λ → e is label-sound.This completes the proof of the first part of the induction.
In order to prove the second part, we call v the node just above the last left cut of β.We are only interested in the proof rooted in v.
The branch β is the rightmost branch in that subtree.This means that if we take any sequent S of that tree that is not in β, the branch going only right from S guarantees the label-soundness of S by induction hypothesis.An illustration of this situation is provided in Figure 5. Consequently, the label-soundness of a sequent in β above v implies that of the sequent below.
If β is finite, we can get the label-soundness of any sequent above v by induction.
Figure 5 Illustration of the proof of Lemma 8. We only show the branchings from cut rules is this drawing of P (w).The thick branch is the induction step we just completed.Green nodes correspond to sequents that have been proven both correctly labelled and label-sound, orange ones those we only proved to be correctly labelled at that point, and red ones are the remaining ones.
Suppose now that β is infinite, and therefore validated by an ω-r thread (Lemma 5).In other words, the corresponding expression f ω on the right is unfolded infinitely many times.Figure 6 presents what happens between two consecutive ω-r rules applied to that thread.We get the finite proof on the right by removing left rules and changing the context.A segment of the word on the left has been matched to f by finite soundness (Lemma 4), because we already proved that u i ∈ L(e i ) if the couple appears on that branch.
In the end, we found a match for every iteration of f , which proves that all sequents of β above the first ω-r rule in the proof rooted in v are label-sound.We get the label-soundness of the remaining interval (between v and the first ω-r rule) by straightforward induction using the local label-soundness of the rules in this branch.
This completes the last part of the induction hypothesis.By well-founded induction, this is true for every maximal branch.In particular, this is true for the very last one: the one that always goes on the right at a cut rule.The induction hypothesis for this branch implies that the whole proof tree P (w) is label-sound, and that w ∈ L(B 0 ) (recall that the root of the initial proof is Γ 0 → B 0 , with w ∈ Γ 0 ).

A.4 Fischer-Ladner Closure
Definition 28 (Fischer-Ladner closure).The Fischer-Ladner closure C of an expression is defined by induction as follows: This is not exactly the original definition of the Fischer-Ladner closure.We adapted it to better fit the unfolding from the left of our system, yet the main idea remains the same.If the branch β does not have a * -l thread, then each expression • + is unfolded finitely many times, meaning that there are necessarily infinitely many ω-l rules (to avoid depletion of the list).These rules apply to the same expression e ω , because the syntax of the rule ω-l does not allow another expression • ω on the left of the sequent.This corresponds to unfolding infinitely many times this expression.
If we call w the word read between two consecutive instances of ω-l rules, then we want to prove that w ∈ L(e).We can do that with a simple transformation of that segment of a branch, which gets rid of e ω and transfers the expression e from the left of the sequent to its right.The transformation changes each left rule into its right counterpart (with possibly a wkn rule), according to the following table.It keeps the match rules and ignores any other rules.This process is described in Figure 7.We obtain a proof of w ∈ L(e), for any word w read between two unfoldings of e ω .We can prove the exact same way that the word read before the first ω-l is in the language of the list Γ 0 without the expression e ω , which completes the proof.

A.6 Example for the proof of Theorem 13
This example shows why we need some kind of look-ahead to build a validating thread, in the completeness proof.
Example 30.Let us consider the preproof from Figure 8, which only contains a single branch.We want to produce a validating thread for that branch.If we proceed greedily at * -r rules and +-r rules, with only the heuristic "choose the first disjunct containing the left-hand side word", then we will end up with the blue thread, that never gets rid of the expression e + and therefore never is principal for an ω-r rule.
This is why we need the following construction to create a validating thread, like the red one on the example, which gets rid of the e + expressions by being able to look ahead.We decide at the first * -r rule that e + will be read as e 2 in that branch, which means that we no longer have a choice for the red thread at the +-r rule above.Indeed, virtually replacing e + by e 2 at the beginning leads to forbidding the blue thread, since the list it chooses is replaced by abc, e 1 , f ω , which does not contain (abc) ω .bc, (abc) ω → bc, e + , f ω ; bca, e + , f ω ; e, f ω ; e, e + , f ω * -r bc, (abc) ω → bc, e + , f ω ; bca, e + , f ω ; e + , f ω

A.7 Transfinite words
Definition 31 (Word).A word over an alphabet Σ is given by a function α → Σ, where α is an ordinal called the length of the word.This is a finite word if α < ω, an ω-word if α = ω, and a transfinite word in the general case.In this paper we will only consider transfinite words of length smaller than ω ω , and the alphabet Σ will always be finite.
Recall that an ordinal is called limit ordinal if it is neither zero nor the successor of any ordinal.For instance ω is the smallest limit ordinal.
where n is the smallest integer such that Notice that we could more generally define the concatenation of a sequence of words indexed by an ordinal greater than ω, but we will not need it here.
If A e = (Q, q 0 , Σ, ∆, F ), then {E i } 1≤i≤k is the set of all subsets of P n (Q) that contain an element of F .

Figure 9 Inductive construction of the automaton associated to an expression
We use to denote a block containing the states and transitions from the automaton A e recognising L(e), with a renaming of the states if needed, and with •f added to each label (we extend this notation lo lists).
Such a block has to have either a double outline, in which case the accepting states of the global automaton are the ones of A e , or an outgoing edge to a block A f , in which case each final states takes the same transitions as the initial state of A f .We can also add a start transition to such a block to indicate that we take its initial state as the one of the global automaton.
As said in the lemma, we proceed by induction, each case being described in Figure 9.We can easily check that each step preserves the fact that the automaton recognises the same language.The only difficulty might be in the understanding of the e ω step.The only way to reach an accepting state for this automaton is to see infinitely many accepting states of A e without going out of A e (at least after some point).Since these state have no outgoing transitions except for those we added to go back to the beginning of A e , this is equivalent to reading e ω .We however want to add a slight complication here.The only point of that part is to make sure that the automaton resulting from an unfolding or e + or e ω is actually a sub-automaton of the one for the initial expression (e + or e ω ).
Let us look at the case of the concatenation of two expression f and e + (with possibly more concatenated at the end) where the automaton for f can be embedded in the one for e by simply changing the initial state (and possibly removing unattainable states).Then instead of creating the automaton from Figure 9, we can take the following one: where "start f " designates the initial state for f instead of e.With that we ensure that the automaton associated to an unfolding of e + is actually embedded into the automaton for e + .We proceed similarly when e + is replaced by e ω , creating the following automaton.
This completes the proof, as it gives the last case for the unfolding of an expression.
Note that we can generalise this construction to lists of expression by using the concatenation step several time.This will give us an automaton associated to the list.
Another remark we can make at that point is that, in the inductive construction, some state may become unattainable.For instance when building the automaton for a + b, we first build the ones for a and b, then we add an initial state that bypasses the ones of the previous automata, which therefore become useless (see Example 38).
Example 38.Here are the automata for a and b (on the left), and the one for a + b (right).In that case, q 0 and q 0 become unreachable, and we will not draw such states from now on, as shown on the right.
Notice that it is also shown in [8] that expressions can be computed from automata, so the two models are expressively equivalent.This could be adapted to our variant as well, but as we will note use this direction here, we omit it.

A.8 Example of a transfinite proof
We give in Figure 10 an example of a non trivial transfinite proof of the following sequent We use the notations e = ba ω + b + and f = (a + b) ω .
In order to avoid adding another tree, we directly start with the sequent Following the blue thread leads back to that tree.
Following green thread: Following orange thread: id → Figure 10 Example of a proof in St.The dotted line is used to continue building the tree further up, so that it can fit in the page width.
Only the main thread are represented: some detours are allowed to them but not represented to keep the proof readable.For instance, the green threads can follow the red ones for a finite number of times before returning to their branch.
Let us now consider what the validity checking algorithm would look like when applied to this proof.This nondeterministic algorithm explores branches to check their validity.Let us look at its run on the leftmost maximal branch of the proof.
We begin at the root sequent,which we chose as a starting point for the transition T 2 of length ω 2 : We then go up in the leftmost branch, while updating T 2 at each step.When we reach the following sequent, we choose it as a starting point for the transition T 1 of length ω: We then keep going for 4 steps, at which point we are back to that same sequent, and T 1 , T 2 hold the following transitions: Note that T 1 is idempotent, and we can now take its limit, corresponding to the limit of a branch of length ω.The associated transition is the following one.
And we can update T 2 by composing its current value with that transition, to get this one: It is also idempotent, with limit transition: The only list on the right corresponds to the part of f ω that is right of f ω , i.e. the empty list.The algorithm reached the end of the branch, since this sequent is proved by the id rule, and has not found any invalid branch.Doing so for every branch ensures the validity of the tree.
A.9 Proof of Theorem 24: Completeness Definition 39 (Covering a state).Given two states p and q in an automaton, we say that p covers q if for any transition from q a → r, there is a transition p a → r.
We can note that the covering relation is transitive, and also that a language inclusion follows from it: if p covers q, then the language recognised from q is included in the one recognised from p.
We now have the required tools to prove the completeness of the system.

C S L 2 0 2 2
For each limit branch, we want to make sure that the corresponding limit sequent does exist, so we create it if was not already the root of a tree in the forest.The lists of such a limit sequent are determined by the definition of a transfinite branch, but we also need to label those with states.This is done by taking the set of states seen cofinally along the ω-l or ω-r thread generating each list.
Once we have created all possible new root sequents, we can generate the corresponding trees the same way as before, then repeat the process with any new limit branch.We only create finitely many trees because of Lemma 23 together with the fact that there are finitely many states.
This construction is shown in Example 41.We now have a proof forest using the rules of our system (without cut), and we know that the state associated to a list covers one recognising the language of this list.Notice that this proof forest can have several trees with same root.However, since the way we build trees depends only on expressions not on their state labelling, these trees having the same root sequent will be isomorphic up to their labelling by states.We can therefore consider that they correspond to a unique tree in the actual proof.
We now want to verify the validity condition in this proof forest, in order to finish the completeness proof.
Let us consider a limit branch.We prove by induction on its length that it satisfies the validity condition, and that its limit sequent is sound if there is one.
The branch gives a transfinite run in A e , and there has to be an outermost loop (considering the inductive construction of the automaton) that is used cofinally.
After some point, the run never goes out of this loop (because coming back would mean using a more external loop).This loops corresponds to an unfolding in the left list, of either a • + expression or a • ω one .
In the first case, we get a validating * -l thread by simply following this expression in the proof forest.
In the second case, we are unfolding an expression e ω , so we see some sequent e ω , Γ → B at some point in the branch.The word u ∈ L(e ω ) unfolded by the branch from this sequent on (we concatenate the letters from the m rules to form u) is of limit length (non successor ordinal).
Since each node of the proof describes a sound inclusion by induction, we know that L(e ω , Γ) ⊆ L(B).If we take a word v ∈ L(Γ), we have u • v ∈ L(B).We therefore know that u • v ∈ Λ for some list Λ ∈ B. But we also know that u is of limit length, and the only way to match such a word in Λ is using a • ω expression, so there has to be one last such expression cofinally unfolded during the matching of u (last because no other expression operator can create a word of limit length).We follow this expression to get an ω-r thread for our branch, which completes the proof of the validity condition.Moreover, the remaining list it kept in the limit sequent and contains v, which proves the soundness of that limit sequent (since this is true for any v ∈ L(Γ)).
Lemma 40.The proof forest can be effectively built from the expressions e and f .Proof.First note that the construction of each tree (given its root sequent) can be done in a finite number of steps by following the proof of Theorem 24, since we can only create finitely many sequents (and we simply have to loop back to a previous copy when we see a sequent we have seen before).The difficulty resides in the computation of the limit sequents.This is very similar to the proof of Theorem 14.We do the same construction to get limit sequents, then we add those sequents as said in the proof of Theorem 24.We then build the C S L 2 0 2 2 15:32 Cyclic proofs for transfinite expressions corresponding trees and go on with the new transitions (without forgetting the transitions created by the new tree).The iteration on this process will stop at some point, when there is no new root sequent added.
Example 41.To prove a ω • a → (a + b) ω • a , we create the two following automata.Note that some states from the construction are inaccessible, represented in gray.a a a q 0 start q 1 q 2 {q 2 } {q 0 , q 2 } {q 1 , q 2 } {q 0 , q 1 , q 2 } {q 0 , q 1 } {q 1 } The proof forest we will obtain from this is the following one.

A.10 Polynomial size of sequents in compact notation
We start by some auxiliary definition, incorporating our new notation e? in the notion of Fischer-Ladner closure, that we will now call ?-closure:Definition 42 (?-closure).The ?-closure C ? of an expression is defined by induction as follows: C ?

Figure 1
Figure1The rules of the system Sω for ω-regular expressions.Γ, Λ, Θ are lists of expressions; B, C are sets of such lists; e, f are ω-regular expressions.Rules wkn, match, cut will sometimes be abbreviated w,m,c.

Definition 3 (
2 for a cyclic proof showing that L((a + b) ω ) ⊆ L((b * a) ω + (a + b) * b ω ), i.e. any infinite word on alphabet {a, b} has either infinitely or finitely many a's.Soundness and completeness).A proof system is sound if the conclusions of all of its valid proofs are sound.It is complete if for any sound sequent Γ → B, there is a proof with conclusion Γ → B.

Figure 4
Figure 4 Example of a limit branch of length ω 2

Lemma 7 .
The maximal branches of P (w) are well-ordered by ≤.

Lemma 29 .
The Fischer-Ladner closure satisfies the following properties.The Fischer-Ladner closure of an expression is finite.If f ∈ C(e), then C(f ) ⊆ C(e).Proof.Each point is done by straightforward induction.

e 2 ,Figure 6 A. 5 Proof of Lemma 12 Lemma 12 .
Figure 6Using finite soundness between two consecutive ω-r rules in P (w)
where δ is the only ordinal such that α + δ = γ Lemma 33.The concatenation is associative.Now suppose we are given a sequence of words U = (u i : α i → Σ) i∈ω .Let us call β the smallest ordinal such that β ≥ n i=0 α i for any n < ω.Then the concatenation of the words in U is a word U of length β defined as follows: