Systems for Conﬂuence—Formalized

. Toyama’s theorem states that the union of two conﬂuent term rewrite systems with disjoint signatures is again conﬂuent. This is a fundamental result in term rewriting, and several proofs appear in the literature. The underlying proof technique has been adapted to prove further results like persistence of conﬂuence (if a many-sorted term rewrite system is conﬂuent, then the underlying unsorted system is conﬂuent) or the preservation of conﬂuence by currying. In this paper we present a formalization of modularity and related results in Isabelle/HOL. The formalization is based on layer systems, which cover modularity, persistence, currying (and more) in a single framework. The persistence result has been integrated into the certiﬁer CeTA and the conﬂuence tool CSI , allowing us to check conﬂuence proofs based on persistent decomposition, of which modularity is a special case.


Introduction
Toyama's theorem [13,17,19] states that confluence is modular, i.e., that the union of two confluent term rewrite systems (TRSs) over disjoint signatures is confluent if and only if the two TRSs themselves are confluent. For example, Combinatory Logic extended with an equality test @(@(K, x), y) → x @(@(@(S, x), y), z) → @(@(x, z), @(y, z)) e(x, x) → is confluent because the first two rules are orthogonal, the last rule is terminating and has no critical pairs, and the signatures of these two sets of rules are disjoint. As the example shows, modularity opens up a decomposition approach to proving confluence, which is attractive, because different confluence criteria may apply to the constituent TRSs that do not apply to their union. By adapting the modularity proof, several other results have been proved in the literature.
-Confluence is persistent [1], i.e., a TRS is confluent if and only if it is confluent as a many-sorted TRS. This gives rise to a decomposition technique, and fully subsumes modularity. -Confluence is preserved by currying [11]. Currying is useful, for example, as a preprocessing step for deciding ground confluence. -The notion of modularity has been generalized as well, by weakening the assumption that the signatures of the two TRSs are disjoint; for example, confluence is modular for layer-preserving composable TRSs [16], and for quasi-ground systems [12].
The list goes on. All of these proofs are based on decomposing terms into a maximal top and remaining aliens, but with different sets of admissible tops. In each case, confluence is established by induction on the number of nested tops in that decomposition (the rank of a term). Layer systems [7] were introduced as an abstraction from these proofs. A layer system L is simply the set of admissible tops; for modularity, those are homogeneous multi-hole contexts, i.e., multihole contexts whose function symbols all belong to the signature of only one of the two given TRSs. At the heart of layer systems lies an adaptation of the modularity proof in [17]. When establishing confluence by layer systems, as remaining proof obligations, one has to check that a layer system satisfies so called layer conditions, which is easier than doing a full adaptation of the modularity proof. Isabelle/HOL [15] is an interactive proof assistant based on higher-order logic with a Hindley-Milner type system, extended with type classes. It follows the LCF tradition [9] in having a trusted kernel, which ensures that theorems follow from the axioms by construction. Isabelle features a structured proof language [20]. Another useful feature are locales, which allow bundling of functions and assumptions that are shared by several definitions and theorems. (For example, locales are used to model groups in Isabelle/HOL). The locale mechanism in Isabelle is quite powerful; in particular, locales can be instantiated (so Z with addition, 0 as unit, and negation is a group) and extended (for example, the group locale is an extension of a semigroup locale, with additional operations (unit and inverse) and assumptions). Our main reason for using Isabelle/HOL is the existing Isabelle Formalization of Rewriting, IsaFoR [18]. In addition to fundamental notions of term rewriting like terms, substitutions, contexts, multihole contexts, and so on, IsaFoR is also the foundation of CeTA (Certified Tool Assertions), which can certify termination and confluence proofs, among other things.
In this paper we describe a formalization of layer systems in Isabelle/HOL as part of IsaFoR. In fact, the prospect of formalization was one of the selling points of layer systems, with the idea of making large parts of the proof reusable. Note that whereas adapting existing proofs is convenient on paper, it becomes a burden when done in a formalization. The resulting duplication of code (that is, theorem statements and proofs) would decrease maintainability and is therefore best avoided. Our effort covers modularity of confluence, persistence of confluence, and preservation of confluence by currying for first order term rewrite systems. To the best of our knowledge, this is the first time that any of these results has been fully formalized in a proof assistant.
From a practical perspective, our interest in formalization is motivated by our work on an automated confluence prover, CSI [14]. As with all software, CSI potentially contains bugs. In order to increase the trust in CSI, proof output in a machine readable format is supported, which can be checked using CeTA [18]. As part of our formalization effort, we have extended CeTA with support for a decomposition technique based on persistence of confluence, allowing CSI and potentially other confluence tools to produce certifiable proofs using this technique. We have prepared a website with examples and information about the used software at http://cl-informatik.uibk.ac.at/software/lisa/ictac2018/.
For most theorems and many definitions, we provide the corresponding identifiers in the formalization; in the PDF version of this paper, they link to the HTML version of the formalization itself. Furthermore, links to selected defined symbols can be found on our website.
The remainder of this paper is structured as follows. We recall notations and basic definitions in Sect. 2. Then we present the layer conditions, which are central to our formalization, in Sect. 3. The next two sections are about persistence. Section 4 uses persistence as an example to illustrate how layer systems can be applied to obtain a confluence result, while Sect. 5 focuses on the persistent decomposition. In Sect. 6, we present details of the currying application. Finally, we conclude in Sect. 7.

Preliminaries
We use standard notation from term rewriting [3]. Let F be a signature and V be a set of variables. Then T (F, V) is the set of terms over that signature. We denote by Pos(t) the set of positions of t. The subterm of t at position p is t| p , and t[s] p is the result of replacing the subterm at position p in t by s. We also write Pos X (r) for the set of positions p of t such that the root symbol of t| p is in X. If X = {x} is a singleton set, we may omit the outer curly braces and write Pos x (t). The set of variables of t is Var(t). The set of multi-hole contexts over F and V is denoted by C(F, V). (Multi-hole contexts are terms that may contain occurrences of an extra constant , representing their holes.) If C is a multi-hole context with n holes, then C[t 1 , . . . , t n ] denotes the term obtained by replacing the i-th hole in C by t i for 1 i n. On multi-hole contexts, we have a partial order which is generated by C and closure under contexts ). The corresponding partial supremum operation is denoted by ; intuitively it merges two multi-hole contexts.
A substitution σ, τ, . . . is a map from variables to terms. The result of applying the substitution σ to the term t is denoted by tσ. A term rewrite system (TRS) R is a set of rules → r, where and r are terms, is not a variable, and Var(r) ⊆ Var( ). There is a rewrite step from s to t (s → R t) if s = s[ σ] p and t = s[rσ] p for a position p ∈ Pos(s) and substitution σ.
Given a relation →, we write ← and → * for its inverse and its reflexive transitive closure, respectively. A relation → is confluent if t * ← s → * u implies t → * · * ← u. It is confluent on X if for all s ∈ X, t * ← s → * u implies t → * · * ← u. 3

Layer Conditions
In the layer system approach to confluence, one sets up a layer system for a TRS R that satisfies the so-called layer conditions. These layer conditions constitute the interface between the reusable part of the formalization and the parts that are specific to a particular application of layer systems (e.g., modularity). Since they are central to the formalization, we recall the basic constructions and the layer conditions here. For full details please refer to [7].
Recall that modularity of confluence states that the union of two TRSs over disjoint signatures is confluent if each of the two TRSs is confluent (the converse is also true and fairly easy to prove). Modularity is proved by induction on the rank of a term; to obtain the rank, one decomposes the term into alternating layers of multi-hole contexts over the two signatures; the rank is the maximum nesting depth of the resulting layers.
Layer systems abstract from this situation by considering all possible multihole contexts at the top of such a decomposition. So a layer system is a set of multi-hole contexts, and gives rise to tops and maximal tops as follows. We want to prove that all terms are confluent, provided that terms of rank 1 are confluent. To this end we have to impose certain restrictions on the layer system.
-the rank must be well-defined, which is ensured if any term has a unique max-top that is not empty (i.e., not equal to ); -a rewrite step must span several layers (so it can be mimicked by a suitable rank 1 term); and -the rank must not increase by rewriting.  (a) Here, we have the rewrite step f(c, c) → f(c, g(c)), decomposed by some set of layers L. However, the c subterm becomes two layers after the rewrite step, increasing the rank. So rewriting a layer must again result in a layer. (b) This is the same rewrite step as in (a). In this example, g(c) may be a layer.
However, the resulting term merges with the layer above (a phenomenon we call fusion). In the example, the fusion is partial ; the fused context is broken apart. This is caused by there being a layer f( , g( )) but no layer f( , g(c)). (c) In this example, there is a root step h(c, c) → g(h(c, c)). Note that both c constants in the result originate in the isolated c, but nevertheless, one of them has fused with the top in the result (so the rewrite step takes place above the point where fusion happens, hence fusion from above). In [7, Example 3.4] we show that the TRS has a set of layers such that fusion from above is the sole reason for the system being non-confluent despite being confluent on terms of rank 1. (d) Finally, it may happen that a rewrite step triggers fusion in a position that is parallel to the rewrite step. (aliens are what remains of a term after taking away its max-top; here a rewrite step in one alien causes another alien to fuse, hence conspiring aliens). As far as we know, this is not actually an obstruction to confluence, but nevertheless absence of conspiring aliens is required for our proof.

Definition 4 ([7, Definition 3.3]). Let F be a signature. A set L ⊆ C(F, V)
of contexts is called a layer system 4 if it satisfies properties (L 1 ), (L 2 ), and (L 3 ). The elements of L are called layers. A TRS R over F is weakly layered (according to a layer system L) if condition (W) is satisfied for each → r ∈ R. It is layered (according to a layer system L) if conditions (W), (C 1 ), and (C 2 ) are satisfied. The conditions are as follows.
In a nutshell, (L 1 ) and (L 3 ) ensure that the rank is well-defined. Property (L 2 ) is a technical property that ensures that aliens can always be represented by suitable variables in the confluence proof. Condition (W) prevents breaking layers, and together with (L 3 ), fusion from above. The final two conditions, (C 1 ) and (C 2 ), prevent fusion from above and conspiring aliens, respectively. Now, let us formally define the rank and aliens of a term.

Theorem 6 ([7, Theorem 4.1]). Let R be a weakly layered TRS that is confluent on terms of rank one. If R is left-linear then R is confluent.
Theorem 7 ([7, Theorem 4.6]). Let R be a layered TRS that is confluent on terms of rank one. Then R is confluent. In Isabelle, we bundle these assumptions in locales [4]. Figure 2 shows how the first three layer conditions have been formalized in Isabelle. (A locale is declared using the locale keyword, followed by the locale name. It may declare constants using fixes, and make assumptions (often about those constants) using assumes. Furthermore, a locale may extend other locales; this is the case for layer system, which extends layer system sig. In order to use a result from a locale, it has to be interpreted, meaning that one provides definitions for the types and constants that the locale depends on and prove that they satisfy the locale assumptions.) Inside the layer system sig locale, we define T and C, the set of terms and multi-hole contexts over F, and the concept of max-tops. In fact, max-tops are defined separately for terms and for multi-hole contexts, because while on paper, multi-hole contexts are just terms which may contain an extra constant , in IsaFoR they have their own type. In total, four locales are defined, capturing the layer conditions, cf. Fig. 3. Note that condition (W) is not part of the layered locale; it would be redundant because (C 1 ) implies (W). In Isabelle we have encoded this fact by proving that layered is a sublocale of weakly layered, as indicated by the dashed arrow. (Basically, a locale A is a sublocale of another locale B if the assumptions of B imply those of A.) Within the formalization, Theorem 6 is established inside the weakly layered locale as theorem weakly layered.CR ll, whereas Theorem 7 is holds in the layered locale as theorem layered.CR. (In fact these statements are declared as locale assumptions; they become theorems by proving suitable sublocale relationships. This is done in LS Left Linear.thy and LS General.thy). The proofs of these main results correspond to Sect. 4 of [7]. The (lengthy) proof works by induction on the rank: assuming that terms of rank r are confluent, several auxiliary results are derived, and finally, confluence of terms of rank r + 1 follows. To this end, we use two more locales weakly layered induct and weakly layered induct dd that capture the induction hypothesis, and an auxiliary assumption (namely that local peaks of so called short steps are joinable in a suitable way), respectively. For this use of locales it is crucial that they can be interpreted inside of a proof, since the induction hypothesis cannot be established for arbitrary r outside of an induction proof. This happens in the proof of the main lemma [7,Lemma 4.27] which we give in Fig. 4. Note that it does induction on the rank (called rk in the proof), and that it uses an interpret command to instantiate the weakly layered induct dd locale based on the induction hypothesis inside the proof.
One major benefit of using locales is separation of concerns; thanks to the abstraction of the layer conditions as locales, we could already work on the applications like modularity and currying before the proofs of the main results were complete, without having to worry about working with different assumptions. Basically, each application is an instantiation of these locales, which we could establish independently of the main results.

Persistence
To give an impression of what an application of layer systems entails, let us consider the case of persistence. This section overlaps with [7, Section 5.5], but here we focus on interesting aspects in the context of our formalization. In fact, given that the results presented here are both formalized and previously published, we focus on ideas rather than giving full proofs.
We wish to establish the following theorem using layer systems.
Theorem 9 (many-sorted persistence, CR persist). Let R be a manysorted TRS. We let V = α∈S V α . Then R is confluent on T α for all α ∈ S if and only if R is confluent on T (F, V).
To this end we define a layer system L as follows.
Showing that L layers R is mostly straightforward. However, in order to show (W) (which is a prerequisite for showing (C 1 )), one has to establish that if a rewrite step is applicable to a term at a position that is part of its max-top, then it is also applicable to the max-top itself. In order to obtain the substitution for the second rewrite step, it is helpful to define functions that compute the maxtop: The max-top of a term t equals mt α (t) for some α ∈ S that can be obtained by looking at the root symbol of t.
Lemma 10 (push mt subst, push mt ctxt). The following properties hold for mt α .

Now, given a rewrite step s[ σ] p → s[rσ]
p , with p ∈ Pos F (mt α (s)) (as in (W)), the lemma entails where , r ∈ T β ; this gives the desired rewrite step for (W). For (C 1 ) note that s[r] p can be a variable, in which case it is possible that mt α (s[rσ] p ) = , whereas the max-top is larger.
Remark 11. This idea of defining the max-top as a function is a recurring theme; it features in the formalizations of modularity and currying as well. The main benefit of (recursive) functions is that they come with an induction principle that is not available for the implicit notion of a "maximal top".
After showing that L layers R, Theorem 7 yields the following corollary.

Corollary 12 (CR on union). If R is confluent on
Let us now sketch a proof of Theorem 9. First note that if R is a many-sorted TRS, then the sets T α are closed under rewriting by R; hence confluence of R on T (F, V) implies confluence of R on T α for any α ∈ S. For the converse, we want to use Corollary 12. We need to show that R is confluent on L ∩ T (F, V). To this end, assume that s ∈ L ∩ T (F, V), and we have a peak t * ← s → * t. If s is a variable then s = t = u and we're done. Otherwise, we can read off the sort α of s from its root symbol. Note that s is not necessarily an element of T α , because L disregards the sorts of variables. We modify s in two steps; first we annotate each variable with the type that is induced by its context (i.e., if x is the i-th argument of f : β 1 × · · · × β n → γ, then we replace it by (x, β i )); 6 and secondly we rename the annotated variables in such a way that each (v, β) is replaced by an element of V β . In this fashion, we obtain a peak t * ← s → * u , where s , t , u ∈ T α , and a substitution σ with s = s σ, t = t σ and u = u σ. By confluence of R on T α , there is a valley t → * v * ← u , and hence a corresponding valley t = t σ → * v σ * ← u σ = u in L ∩ T (F, V).

Persistent Decomposition
Aoto and Toyama [1] pointed out that persistence gives rise to a decomposition technique for proving confluence. The basic idea is to attach sorts to a TRS. To obtain a decomposition, for each sort of the many-sorted TRS obtained in that way, the set of rules that are applicable to terms of that sort is computed. By persistence, if all of the resulting systems are confluent, the original TRS is confluent as well. In [2] a refined version of the persistent decomposition is presented, wherein only the maximal systems w.r.t. the subset relation are considered.

Example 13 ([1, Example 1]). Consider the TRS R consisting of the rules
The following sort attachment makes the TRS R many-sorted: Looking at the sorts of possible subterms of terms of sort 0 (namely 0 and 2), 1 (1 and 2) and 2 (only 2), we obtain three induced TRSs, consisting of the first two rules, the last three rules, and only the second rule of R, respectively. The last TRS is contained in the other two, and hence does not have to be considered. Confluence of R follows from confluence of the two systems (which is orthogonal) and (which is terminating and has joinable critical pairs). Non-confluence of R would follow if any of the three TRSs induced by the sorts 0, 1, or 2 was non-confluent.

Definition 14.
Let R be a many-sorted TRS. Based on the signature, we define an order on sorts by the rules in Fig. 5. The TRS R α induced by α ∈ S is given by R α = { → r | → r ∈ R, ∈ T β , α β} Remark 15. The notation is justified by the fact that T α s t ∈ T β implies α β. Note further that α β implies R α ⊇ R β , so the maximal induced TRSs R α w.r.t. subsets are induced by the maximal sorts α w.r.t. .
Since only rules from R α are applicable to terms in T α , we have the following lemma.

Lemma 16 (CR on T α by needed rules). The system R is confluent on T α if and only if R α is confluent on T α .
We formalize the persistent decomposition result as follows.

Theorem 17 (persistent decomposition nm). Let Σ ⊆ S be a set of sorts with the property that for each β ∈ S, either
Since no proof has been given in the literature 7 (as far as we know), we include one here.
Proof. First assume that R α is confluent on T (F, V) for all α ∈ Σ. By Theorem 9, confluence of R on T (F, V) follows if we can show that R is confluent on T β for any β ∈ S. By Lemma 16, this is equivalent to R β being confluent on T β . If R β = ∅, we are done. Otherwise, by assumption, there is a sort α β such that R α is confluent on T (F, V). Because T β is closed under rewriting by R α , R α is confluent on T β , which implies that (R α ) β = R β is confluent on T β by Lemma 16 and the fact that R α is a many-sorted TRS using the same signature as R.
For the other direction, assume that R is confluent on T (F, V). We show that R α is confluent on T (F, V) for all α ∈ S (and in particular those in Σ). Since R α is a many-sorted TRS, it is persistent (Theorem 9), so it suffices to show that R α is confluent on T β for all β ∈ S. So consider a peak t * Rα ← s → * Rα u. We proceed by induction on s ∈ T β .
1. If α β, then since R is confluent on T β , R β is confluent on T β . By Lemma 16 applied to (R α ) β = R β , R α is confluent on T β as well. 2. If α β, then R α contains no rules whose root symbol has result sort β. Consequently there cannot be any root steps in t * Rα ← s * Rα ← u. Hence we obtain t 1 , . . . , t n and u 1 , . . . , u n with t i * . . . , t n ), and u = f (u 1 , . . . , u n ). We conclude by the induction hypothesis (s i is confluent for 1 i n).  We further integrated this result into CeTA. To this end, we implemented a function that computes the maximal sorts (with respect to ) for a given signature, a check function that checks the preconditions of Theorem 17, and extended CeTA's CPF parser with a certificate format for a persistent decomposition (CPF is an XML format. The fragment for persistent decomposition is given in Fig. 6, and may be of interest to tool authors who want to incorporate certifiable persistent decomposition into their confluence tools).

Currying
Currying is the most complicated application of layer systems that we have formalized so far. Currying is a transformation of term rewrite systems in which applications of n-ary functions are replaced by n applications of a single fresh binary function symbol to a constant, thereby applying arguments to the function one by one. More formally, we introduce a fresh function symbol • to denote application, whereas every other function symbol becomes a constant. We adopt the convention of writing f n to denote a function symbol of arity n. Moreover, we denote the arity of a function symbol f with respect to the signature F by a F (f ). We identify f aF (f ) with f .

Definition 18. Given a TRS R over a signature F, its curried version
Currying is useful for deciding properties such as confluence [5] or termination [10]. For analyzing confluence by currying, the following result is important.

Theorem 19 (main result complete). Let R be a TRS. If R is confluent, then Cu(R) is confluent.
This result was proved by Kahrs [11]. Rather than working directly with Cu(R), Kahrs works with the partial parametrization of R, which is given by PP(R) = R ∪ U F , where U F is the set of uncurrying rules for F (see Definition 20). Confluence of PP(R) and Cu(R) are closely related, cf. Lemma 21.
Definition 20. Given a signature F, the uncurrying rules U F are rules for every function symbol f ∈ F and 0 i < a F (f ).

Lemma 21 ([11, Proposition 3.1]). Let R be a TRS. Then Cu(R) is confluent if PP(R) is.
Hence in order to prove Theorem 19 it suffices to prove that PP(R) is confluent. To this end, we make use of Theorem 7. Hence we need to show that PP(R) is layered according to some set of layers L, and confluent on terms of rank one. First of all we have to define a suitable set of layers. We choose L = L 1 ∪ L 2 letting V = V ∪ { } and This definition realizes a separation between well-formed terms (L 1 ), whose U Fnormal form contains no • symbol, and ill-formed terms (L 2 ), whose U F -normal form contains exactly one • symbol at the root. As required for condition (L 1 ), variables and holes are treated interchangeably.
Whereas for Lemma 21 we could follow the lines of the paper proof, the formalization of the fact that PP(R) is layered according to L turned out to be much more tedious. As with the modularity and persistence applications, we found it convenient to define functions that compute the max-top of a term, since the abstract definition of max-tops in the layer framework is not really suitable for proofs in Isabelle.

Definition 22. The following function checks whether the number of arguments applied to the first non-• function symbol f is at most the arity a
Here mt 1 (t, m) computes the max-top of t with respect to L 1 , where m is the number of already applied arguments: Note that there is some redundancy, since the check function does the same counting several times. It turns out, however, that this redundancy simplifies later proofs.
Using these two lemmas, we can obtain the desired rewrite step from M by the following computation, where for simplicity we only consider the case M ∈ L 1 and l → r ∈ R: The uses of the previous two lemmas are indicated above the equalities. Note that the number of missing arguments of r and l are equal (namely 0), so we can use Lemma 23 in both directions. For the same reason we must have k = 0, because otherwise mt 1 (l · σ, k) = , contradicting the fact that the rewrite step would take place at a function position of M . Hence Lemma 24 is applicable. Furthermore, we use mt 1 (l, 0) = l and mt 1 (r, 0) = r, using that l and r are wellformed. At this point we have established (W). For (C 1 ), we analyze the term mt 1 (C[r · σ], 0) some more: If C = , r is a variable and check(r · σ) is false, mt 1 (C[r ·σ], 0) = . Otherwise, the max-top of C[r ·σ] is equal to mt 1 (C[r ·σ], 0).

Remark 25.
As an anonymous reviewer suggested, it would most likely have been easier to use a different layer system, where each • symbol starts a new layer: This would have avoided the complications of counting the number of "missing" arguments in the check function. Unfortunately we did not find this idea before starting our formalization. Adapting the existing formalization accordingly would be a substantial effort with no obvious gain-the final result would still be that currying preserves confluence.

Conclusion
We have presented a formalization of modularity, persistence, and currying, in the Isabelle proof assistant. The formalization spans about 12k lines of theory files and took approximately 9 person-months to develop. A breakdown of the effort is given in Fig. 7. (Note that modularity is subsumed by persistence. We formalized modularity first because it is the easiest application. Many proof ideas for modularity carried over to the other, more difficult applications.) The de Bruijn factor (which compares the size of the formalized proof to the paper version) varies wildly. We believe that the main reason for this is that the level of detail for proofs in [7] varies greatly; the core confluence proof (leading up to Theorem 7) is carried out in much more detail than the applications, where large parts of the proofs rely on the reader's intuition. A second contributing factor is that two people worked on different parts of the formalization.
As far as we know, this is the first formalization of modularity of confluence in any proof assistant. We would like to point out that even though the confluence proof for layer systems is based on a constructive proof of modularity of confluence [17], the formalized result is not constructive. This is because Isabelle/HOL is a classical logic. Producing a constructive proof in Isabelle/HOL would have to rely on discipline (including the avoidance of proof automation tools like Metis that are based on Skolemization). In fact, since the proof factors through decreasing diagrams (which were already part of the Archive of Formal Proofs [6]), we would first need a constructive proof for confluence by decreasing diagrams. In the end we would not reap any benefits from having a constructive proof (namely, an executable confluence result).
We integrated the persistence result into our theorem prover CSI (which already supported order-sorted persistence, so the main effort for extending CSI was adding the XML output.) We present experimental results in Fig. 8. The check mark indicates certified strategies; CSI and +pd are the certified strategies with and without persistent decomposition, respectively, while CSI refers to the uncertified, full strategy of CSI. As can be seen from the data, we have achieved a modest improvement in certified proofs over the Cops database of confluence problems. 8 It is worth noting that there is no progress in certified non-confluence proofs; in fact, there is no certification gap for non-confluence at all. For non-confluence, CSI employs tree automata [8], which (in theory, and evidently also in practice) subsume the many-sorted decomposition result, because many-sorted terms are a regular tree language.
There are several parts of [7] that have not yet been formalized. For one, there are two more applications of layer systems, namely modularity of layerpreserving composable TRSs, and a modularity result for quasi-ground systems. The bigger missing part are variable-restricted layer systems, which are the foundation for a generalized persistence result with ordered sorts [7, Theorem 6.3]. Furthermore, while we have formalized preservation of confluence by currying, this is not integrated into CeTA. As far as we know, no confluence tool currently uses currying directly. However, currying is the basis of efficient decision procedures for ground TRSs, which are implemented in CSI, and are a target for future formalization efforts.