Recently, techniques and tools from term rewriting have been successfully applied to prove termination automatically for different programming languages. The advantage of rewrite techniques is that they are very powerful for algorithms on user-defined data structures. But in contrast to techniques for termination analysis of imperative programs, the drawback of rewrite techniques is that they do not support data structures like integer numbers which are pre-defined in almost all programming languages.

To solve this problem, we extend term rewriting by built-in integers and adapt the dependency pair framework to prove termination of integer term
rewriting automatically. Our experiments show that this indeed combines the power of rewrite techniques on user-defined data types with a powerful treatment of pre-defined integers

Falke, Stephan

Fuhs, Carsten

Schneider-Kamp, Peter

Dagstuhl Research Online Publication Server

Termination of Integer Term Rewriting∗C. Fuhs, J. Giesl, M. Plu¨ckerLuFG Informatik 2RWTH Aachen UniversityAachen, GermanyP. Schneider-KampDept. of Mathematics & CSUniversity of Southern DenmarkOdense, DenmarkS. FalkeCS DepartmentUniversity of New MexicoAlbuquerque, NM, USAAbstractWhen using rewrite techniques for termination analysis of programs, a main problem are pre-defined data types like integers. We extend term rewriting by built-in integers and adapt the depen-dency pair framework to prove termination of integer term rewriting automatically.1 IntroductionRewrite techniques and tools have been successfully applied to prove termination automatically for diffe-rent programming languages. The advantage of rewrite techniques is that they are very powerful for algo-rithms on user-defined data structures, since they can generate well-founded orders comparing arbitraryforms of terms. But in contrast to techniques for termination of imperative programs, rewrite techniquesdo not support data structures like integers which are pre-defined in most programming languages.To solve this problem, we extend TRSs by built-in integers and adapt the popular dependency pair(DP) framework for termination of TRSs to integers in Sect. 2. In Sect. 3, we improve the main processorof the adapted DP framework by considering conditions and explain how to generate suitable orders fortermination proofs of integer TRSs (ITRSs). Sect. 4 evaluates our implementation in AProVE [6].2 Integer Dependency Pair FrameworkWe represent each integer by a pre-defined constant of the same name. So the signature is split intotwo disjoint subsets F and Fint . Fint contains Z = {0,1,−1, . . .}, B = {true, false}, and pre-definedoperations ArithOp = {+,−,∗,/,%}, RelOp = {>,>,<,6,==, !=}, and BoolOp = {∧,⇒}. An ITRSR is a (finite) TRS over F ⊎Fint where for all rules ℓ→ r, we have ℓ∈T (F ∪Z∪B,V ) and ℓ 6∈Z∪B.The rewrite relation →֒R of an ITRS R is defined asi→R∪PD, where PD is an infinite set of rules toevaluate the pre-defined operations. For example, PD contains the rules 2∗21→ 42, 42 > 23→ true, andtrue∧ false→ false. So pre-defined operations can only be evaluated if both their arguments are integersresp. Booleans. For example, consider the ITRSs R1 = {(1),(2),(3)} where sum(x,y) computes ∑xi=y i.sum(x,y) → sif(x > y,x,y) (1) sif(true,x,y)→ y+ sum(x,y+1) (2) sif(false,x,y)→ 0 (3)The term sum(1,1) can be rewritten as follows: sum(1,1) →֒R1 sif(1 > 1,1,1) →֒R1 sif(true,1,1) →֒R11+sum(1,1+1) →֒R1 1+sum(1,2) →֒R1 1+sif(1 > 2,1,2) →֒R1 1+sif(false,1,2) →֒R1 1+0 →֒R1 1.We extend the DP framework [1, 5, 7, 8] to ITRSs. The main problem is that proving innermosttermination of R ∪PD automatically is not straightforward, as PD is infinite. Therefore, we will notconsider the rules PD explicitly, but integrate their handling in the processors of the DP framework. Theresulting method should be as powerful as possible for term rewriting on integers, but at the same time itshould have the full power of the original DP framework when dealing with other function symbols.For an ITRS R, the defined symbols D are the root symbols of left-hand sides of rules in R ∪PD,i.e., D also includes ArithOp∪RelOp∪BoolOp. However, we ignore these symbols when building DPs.Definition 1 (DP). For all f ∈ D \Fint , we introduce a fresh tuple symbol F with the same arity. Ift = f (t1, ..., tn), let t♯ = F(t1, ..., tn). If ℓ→ r ∈ R for an ITRS R and t is a subterm of r with root(t) ∈D \Fint , then ℓ♯ → t♯ is a dependency pair of R. DP(R) is the set of all DPs.For example, DP(R1) = {SUM(x,y)→ SIF(x > y,x,y) (4), SIF(true,x,y)→ SUM(x,y+1) (5)}.∗Supported by the DFG grant GI 274/5-2 and by the G.I.F. grant 966-116.6.1Dagstuhl Seminar Proceedings 09411 Interaction versus Automation: The two Faces of Deduction http://drops.dagstuhl.de/opus/volltexte/2010/2423Termination of Integer Term Rewriting Fuhs, Giesl, Plu¨cker, Schneider-Kamp, FalkeFor any TRS P and ITRS R, a P-chain is a sequence of variable renamed pairs s1 → t1,s2 → t2, . . .from P such that there is a substitution σ (with possibly infinite domain) where tiσ →֒∗R si+1σ and siσis in normal form w.r.t. →֒R , for all i. We get the following corollary from the standard results on DPs.Corollary 2. An ITRS R is terminating (w.r.t. →֒R) iff there is no infinite DP(R)-chain.Termination techniques are now called DP processors and they operate on sets of DPs (called DPproblems). A DP processor Proc takes a DP problem as input and returns a set of new DP problemswhich have to be solved instead. Proc is sound if for all DP problems P with an infinite P-chain thereis also a P ′ ∈ Proc(P) with an infinite P ′-chain. Termination proofs start with the initial DP problemDP(R). Then the DP problem is simplified repeatedly by sound DP processors. If all resulting DPproblems have been simplified to ∅, then termination is proved. Many processors (like the (estimated)dependency graph processor [1, 5]) do not rely on the rules of the TRS, but just on the DPs and on thedefined symbols. Therefore, they can also be directly applied for ITRSs.But an adaption is non-trivial for one of the most important processors, the reduction pair processor.For a DP problem P , this processor generates constraints which should be satisfied by a suitable orderon terms. Here, we consider orders based on max-polynomial interpretations [3]. The set of max-poly-nomials is the smallest set containing the integers Z, the variables, and p+q, p∗q, and max(p,q) for allmax-polynomials p and q. A max-polynomial interpretation Pol maps every n-ary function symbol f toa max-polynomial fPol over n variables x1, . . . ,xn. This mapping is extended to terms as usual.Consider the interpretation Pol where SUMPol = x1 − x2, SIFPol = x2 − x3, +Pol = x1 + x2, nPol = nfor all n ∈ Z, and >Pol= truePol = falsePol = 0. For any term t and position pi in t, t is %Pol-dependenton pi iff there exist terms u,v where t[u]pi 6≈Pol t[v]pi . Here, ≈Pol = %Pol ∩ -Pol. So in our example,SIF(b,x,y) is %Pol-dependent on 2 and 3, but not on 1. A term t is %Pol-increasing on pi iff u %Pol vimplies t[u]pi %Pol t[v]pi for all terms u,v. So SIF(b,x,y) is %Pol-increasing on 1 and 2, but not on 3.The reduction pair processor requires that all DPs in P are strictly or weakly decreasing and allusable rules UR∪PD(P) are weakly decreasing. Then one can delete all strictly decreasing DPs. Theusable rules [1, 7] include all rules that can reduce terms in %Pol-dependent positions of P’s right-hand sides when instantiating their variables with normal forms. Moreover, as %Pol is not monotonic ingeneral, we require that defined symbols only occur on %Pol-increasing positions of right-hand sides.When using interpretations into the integers, ≻Pol is not well founded. However, for any bound, thereis no infinite ≻Pol-decreasing sequence that remains greater than the bound. Hence, the reduction pairprocessor transforms a DP problem into two new problems. As before, the first problem results fromremoving all strictly decreasing DPs. The second DP problem results from removing all DPs s→ t fromP that are bounded from below, i.e., DPs which satisfy the inequality s % c for a fresh constant c.However, there are two problems: (i) PD is infinite and thus, there are usually infinitely many usablerules, which is a problem for the automation. (ii) Defined symbols like + often occur on non-%Pol-increasing positions (e.g., in the right-hand side of (5) when using Pol above). To solve these problems,we now restrict ourselves to so-called I-interpretations where nPol = n for all n ∈ Z, +Pol = x1 + x2,−Pol = x1 − x2, ∗Pol = x1 ∗ x2, %Pol = |x1|, and /Pol = |x1| −min(|x2| − 1, |x1|). We say that an I-interpretation is proper for a term t if all defined symbols except +, −, and ∗ only occur on %Pol-increasing positions of t and if symbols from RelOp only occur on %Pol-independent positions of t.The concept of proper I-interpretations ensures that we can disregard the (infinitely many) usablerules for the symbols from RelOp and that the symbols “/” and “%” only have to be estimated “upwards”.Moreover, we may allow +, −, and ∗ on arbitrary positions and we only have to regard the usable rulesw.r.t. R∪BO. Here, BO are the (finitely many) rules for the symbols ∧ and ⇒ in BoolOp.Theorem 3 (Reduction Pair Processor for ITRSs). Let R be an ITRS, Pol be an I-interpretation, andPbound = {s → t ∈P | s %Pol c} for a fresh constant c. Then the following processor Proc is sound.2Termination of Integer Term Rewriting Fuhs, Giesl, Plu¨cker, Schneider-Kamp, FalkeProc(P)={P \≻Pol, P \Pbound }, if P ⊆%Pol∪ ≻Pol, UR∪BO(P)⊆%Pol ,and Pol is proper for all right-hand sides of P ∪UR(P){P }, otherwiseTo solve the DP problem P = {(4),(5)}, we use an I-interpretation Pol where SUMPol = x1−x2 andSIFPol = x2− x3. We have UR∪BO(P) = ∅, as the +- and >-rules are not included in R ∪BO. The DP(5) is strictly decreasing, but no DP is bounded, since SUM(x,y) 6%Pol c and SIF(true,x,y) 6%Pol c for anyvalue of cPol. Thus, the processor returns the problems {(4)} and {(4),(5)}, i.e., it does not simplify P .3 Conditional Constraints and Generation of I-InterpretationsTo solve this problem, we consider conditions for inequalities like s(%)t or s % c. So to include (4) inPbound , we do not demand SUM(x,y) % c for all x and y. It suffices to require the inequality only for thoseinstantiations of x and y which can be used in chains. So we require SUM(x,y) % c only for instantiationsσ where (4)’s instantiated right-hand side SIF(x > y,x,y)σ reduces to an instantiated left-hand side uσfor some DP u → v where uσ is in normal form. Here, u → v should again be variable renamed. Asour DP problem contains two DPs (4) and (5), we get the following two conditional constraints (byconsidering all u→ v ∈ {(4),(5)}). We include (4) in Pbound if both constraints are satisfied.SIF(x > y,x,y) = SUM(x′,y′) ⇒ SUM(x,y) % c (6) SIF(x > y,x,y) = SIF(true,x′,y′) ⇒ SUM(x,y) % c (7)To check whether conditional constraints are valid requires reasoning about reachability w.r.t. TRSswith infinitely many rules. To this end, we developed rules to simplify conditional constraints. Theserules detect that (6)’s premise is unsatisfiable and hence, (6) is valid. Moreover, they transform (7) intox % y ⇒ SUM(x,y) % c (8)To automate the reduction pair processor, one has to generate an I-interpretation satisfying a givenconditional constraint. One starts with an abstract I-interpretation. It maps each function symbol toa max-polynomial with abstract coefficients. So we could use an abstract I-interpretation Pol whereSUMPol = a0 +a1 x1 +a2 x2, SIFPol = b0 +b1 x1 +b2 x2 +b3 x3, and cPol = c0. Of course, the interpretationfor the symbols in Z∪ArithOp is fixed as for any I-interpretation (i.e., +Pol = x1 + x2, etc.).Then we transform the conditional constraint into an inequality constraint by replacing all atomicconstraints “s % t” by “[s]Pol > [t]Pol” and “s ≻ t” by “[s]Pol > [t]Pol + 1”. So “SUM(x,y) % c” is trans-formed into “a0 +a1 x+a2 y > c0”. Here, the abstract coefficients a0,a1,a2,c0 are implicitly existentiallyquantified and the variables x,y ∈ V are universally quantified. So (8) is transformed into∀x ∈ Z,y ∈ Z (x > y ⇒ a0 + a1 x+ a2 y > c0 ) (9)Now we remove universally quantified variables from such constraints. Rule (A) handles conditionsA. Eliminating Conditions∀x ∈ Z, . . . (x > p ∧ ϕ ⇒ ψ)∀z∈N, . . . (ϕ[x/p+z]⇒ψ[x/p+z])∀x ∈ Z, . . . (p > x ∧ ϕ ⇒ ψ)∀z∈N, . . . (ϕ[x/p−z]⇒ψ[x/p−z])“x > p” or “p > x” for a poly-nomial p without x. So (9)is transformed to ∀y∈Z,z∈Na0 +a1 (y+z)+a2 y > c0 (10).B. Split∀y ∈ Z ϕ∀y∈N ϕ ∧ ∀y∈N ϕ[y/−y]To replace all remaining quantifiers over Z by quantifiersover N, Rule (B) splits the inequality constraint ϕ into the caseswhere y is positive resp. negative. Thus, (10) is transformed intothe conjunction of (11) and (12).3Termination of Integer Term Rewriting Fuhs, Giesl, Plu¨cker, Schneider-Kamp, Falke∀y ∈ N,z ∈N a0 + a1 (y+ z)+ a2 y > c0 (11) ∀y ∈ N,z ∈N a0 + a1 (−y+ z)−a2 y > c0 (12)Note that (11) can be reformulated as “∀y ∈N,z ∈N (a1 +a2)y+a1 z+(a0−c0) > 0”. So we nowhave to ensure non-negativeness of “polynomials” over variables like y and z ranging over N, where the“coefficients” are polynomials like “a1 +a2” over the abstract variables. To this end, it suffices to requirethat these “coefficients” are > 0 [9]. In other words, now one can eliminate all universally quantified va-riables like y,z and transform (11) into the Diophantine constraint “a1 +a2 > 0 ∧ a1 > 0 ∧ a0−c0 > 0”.To search for abstract coefficients that satisfy the resulting Diophantine constraints, one fixes upperand lower bounds for their values. Then one can translate such Diophantine constraints into a SATproblem which can be handled by SAT solvers efficiently [2]. The constraints resulting from the initialinequality constraint (9) are for example satisfied by a0 = 0, a1 = 1, a2 = −1, and c0 = 0. With thesevalues, the abstract interpretation a0 + a1 x1 + a2 x2 for SUM is turned into the concrete interpretationx1−x2. With the resulting concrete I-interpretation Pol, we would have P≻ = {(5)} and Pbound = {(4)}.The reduction pair processor of Thm. 3 would therefore transform the initial DP problem P = {(4),(5)}into the two problems P \P≻ = {(4)} and P \Pbound = {(5)}. Both are easy to solve.4 Experiments and ConclusionWe adapted the DP framework to ITRSs. To evaluate our approach, we implemented it in AProVE [6]and tested it on a data base of 117 ITRSs containing also numerous examples from papers on terminationof imperative programs. With a timeout of 1 minute per example, the new version of AProVE provestermination of 104 examples (88.9 %). We also tested the previous version of AProVE (AProVE08) andthe tool TTT2 [10] that do not support built-in integers. Here, we converted integers into terms constructedwith 0, s, pos, and neg (e.g., −1 is represented as “neg(s(0))”) and we added rules for pre-defined opera-tions on integers in this representation. Although AProVE08 won the last Termination Competition 2008for term rewriting and TTT2 was second, AProVE08 resp. TTT2 only proved termination of 24 (20.5 %)resp. 6 examples (5.1 %). This clearly shows the benefits of built-in integers in term rewriting. Fordetails on our experiments and to run the new version of AProVE, we refer to http://aprove.informatik.rwth-aachen.de/eval/Integer/. A longer version of this paper appeared in [4].References[1] T. Arts, J. Giesl. Termination of term rewriting using dependency pairs. Th. Comp. Sc., 236:133-178, 2000.[2] C. Fuhs, J. Giesl, A. Middeldorp, P. Schneider-Kamp, R. Thiemann, and H. Zankl. SAT solving for termina-tion analysis with polynomial interpretations. In Proc. SAT’07, LNCS 4501, pp. 340-354, 2007.[3] C. Fuhs, J. Giesl, A. Middeldorp, P. Schneider-Kamp, R. Thiemann, and H. Zankl. Maximal termination. InProc. RTA’08, LNCS 5117, pp. 110-125, 2008.[4] C. Fuhs, J. Giesl, M. Plu¨cker, P. Schneider-Kamp, and S. Falke. Proving termination of integer term rewriting.In Proc. RTA’09, LNCS 5595, pp. 32-47, 2009.[5] J. Giesl, R. Thiemann, and P. Schneider-Kamp. The dependency pair framework: Combining techniques forautomated termination proofs. In Proc. LPAR’04, LNAI 3452, pp. 301-331, 2005.[6] J. Giesl, P. Schneider-Kamp, and R. Thiemann. AProVE 1.2: Automatic termination proofs in the depen-dency pair framework. In Proc. IJCAR’06, LNAI 4130, pp. 281-286, 2006.[7] J. Giesl, R. Thiemann, P. Schneider-Kamp, and S. Falke. Mechanizing and improving dependency pairs.Journal of Automated Reasoning, 37(3):155-203, 2006.[8] N. Hirokawa and A. Middeldorp. Automating the dependency pair method. I & C, 199(1,2):172-199, 2005.[9] H. Hong and D. Jakusˇ. Testing positiveness of polynomials. J. Aut. Reasoning, 21(1):23-38, 1998.[10] M. Korp, C. Sternagel, H. Zankl, A. Middeldorp. Tyrolean Termination Tool 2. Proc. RTA’09, LNCS, 2009.4

Termination of Integer Term Rewriting

http://drops.dagstuhl.de/opus/volltexte/2010/2423/pdf/09411.GieslJuergen.ExtAbstract.2423.pdf

Termination of Integer Term Rewriting

Abstract

Similar works

Full text

Available Versions

Dagstuhl Research Online Publication Server