The DP framework for proving termination of term rewriting

Termination is the fundamental property of a program that for each input, the evaluation will eventually stop and return some output. Although the question whether a given program terminates is undecidable, many techniques have been developed which can be used to answer the question of termination for many programs automatically. Especially, termination of term rewriting is an interesting and widely studied area: Since the basic evaluation mechanism of many programming languages is term rewriting, one can successfully apply the termination techniques for term rewriting to analyze termination of programs automatically. Nevertheless, there still remain many programs that cannot be handled by any current technique that is amenable to automation In this thesis, we extend existing techniques and develop new methods for mechanized termination analysis of term rewrite systems. Currently, one of the most powerful techniques is the dependency pair approach. Up to now, it was regarded as one of several possible methods to prove termination. We show that dependency pairs can instead be used as a general concept to integrate arbitrary techniques for termination analysis. In this way, the benefits of different techniques can be combined and their modularity and power are increased significantly. We refer to this new concept as the “dependency pair framework” to distinguish it from the old “dependency pair approach”. Moreover, this framework facilitates the development of new methods for termination analysis. To demonstrate this, we design several novel techniques within the dependency pair framework. They can successfully be applied to prove termination of previously challenging programs. For example, our work describes new ways how to handle programs using accumulators, programs written in higher-order languages, and programs which only terminate w.r.t. a given evaluation strategy. We additionally show how to disprove termination, even under strategies. All presented techniques are formulated in a uniform setting and are implemented in our fully automated termination prover AProVE. The significance of our results is demonstrated at the annual international Termination Competition, where the leading automated tools try to analyze termination of programs from different areas of computer science: Without the contributions of this thesis, AProVE would not have reached the highest scores both for proving and disproving termination in the years 2004 – 2007.

[1]  U. Naumann,et al.  Toward Low Static Memory Jacobian Accumulation , 2006 .

[2]  Hans Zantema,et al.  Termination of Logic Programs Using Semantic Unification , 1995, LOPSTR.

[3]  Jürgen Giesl,et al.  Proving and Disproving Termination of Higher-Order Functions , 2005, FroCoS.

[4]  Nao Hirokawa,et al.  Automating the Dependency Pair Method , 2005, CADE.

[5]  Jürgen Giesl,et al.  Automated Termination Proofs with AProVE , 2004, RTA.

[6]  Enno Ohlebusch,et al.  Modular Termination Proofs for Rewriting Using Dependency Pairs , 2002, J. Symb. Comput..

[7]  Jean Utke,et al.  OpenAD/F: A Modular Open-Source Tool for Automatic Differentiation of Fortran Codes , 2008, TOMS.

[8]  Zinaida Benenson,et al.  Tampering with Motes: Real-World Physical Attacks on Wireless Sensor Networks , 2006, SPC.

[9]  Christoph Walther,et al.  On Proving the Termination of Algorithms by Machine , 1994, Artif. Intell..

[10]  Hans Zantema,et al.  Termination of Term Rewriting by Semantic Labelling , 1995, Fundam. Informaticae.

[11]  Albert Rubio,et al.  Polymorphic higher-order recursive path orderings , 2007, JACM.

[12]  Claude Marché,et al.  Mechanically Proving Termination Using Polynomial Interpretations , 2005, Journal of Automated Reasoning.

[13]  Felix C. Freiling,et al.  Botnet Tracking: Exploring a Root-Cause Methodology to Prevent Distributed Denial-of-Service Attacks , 2005, ESORICS.

[14]  Henny B. Sipma,et al.  Termination of Polynomial Programs , 2005, VMCAI.

[15]  Felix C. Freiling,et al.  Revisiting Failure Detection and Consensus in Omission Failure Environments , 2005, ICTAC.

[16]  Manfred Schmidt-Schauß,et al.  TEA: Automatically Proving Termination of Programs in a Non-strict Higher-Order Functional Language , 1997, SAS.

[17]  Takahito Aoto,et al.  Dependency Pairs for Simply Typed Term Rewriting , 2005, RTA.

[18]  Hongwei Xi.  Dependent Types for Program Termination Verification , 2002, High. Order Symb. Comput..

[19]  Johannes Waldmann.  Matchbox: A Tool for Match-Bounded String Rewriting , 2004, RTA.

[20]  Xavier Urbain,et al.  Automated Incremental Termination Proofs for Hierarchically Defined Term Rewriting Systems , 2001, IJCAR.

[21]  Jan-Georg Smaus.  Termination of Logic Programs Using Various Dynamic Selection Rules , 2004, ICLP.

[22]  D. Knuth,et al.  Simple Word Problems in Universal Algebras , 1983 .

[23]  Felix C. Freiling,et al.  Efficient Reductions for Wait-Free Termination Detection in Faulty Distributed Systems , 2005 .

[24]  Jürgen Giesl,et al.  The size-change principle and dependency pairs for termination of term rewriting , 2005, Applicable Algebra in Engineering, Communication and Computing.

[25]  Peter W. O'Hearn,et al.  Automatic Termination Proofs for Programs with Shape-Shifting Heaps , 2006, CAV.

[26]  Peter J. Stuckey,et al.  Termination Analysis with Types Is More Accurate , 2003, ICLP.

[27]  Jürgen Giesl,et al.  SAT Solving for Termination Analysis with Polynomial Interpretations , 2007, SAT.

[28]  Étienne Payet,et al.  Detecting Non-termination of Term Rewriting Systems Using an Unfolding Operator , 2006, LOPSTR.

[29]  Supratik Chakraborty.  Termination Of Linear Programs , 2008 .

[30]  Jürgen Giesl,et al.  Verification of Erlang Processes by Dependency Pairs , 2001, Applicable Algebra in Engineering, Communication and Computing.

[31]  Aart Middeldorp,et al.  Approximating Dependency Graphs Using Tree Automata Techniques , 2001, IJCAR.

[32]  Thomas Noll,et al.  Algebraic Correctness Proofs for Compiling Recursive Function Definitions with Strictness Information , 2006, Acta Informatica.

[33]  Harald Ganzinger,et al.  Termination Proofs of Well-Moded Logic Programs via Conditional Rewrite Systems , 1992, CTRS.

[34]  Andreas Podelski,et al.  Transition invariants , 2004, Proceedings of the 19th Annual IEEE Symposium on Logic in Computer Science, 2004..

[35]  Benedikt Bollig,et al.  Replaying Play In and Play Out: Synthesis of Design Models from Scenarios by Learning , 2007, TACAS.

[36]  Dieter Hofbauer,et al.  Termination of String Rewriting with Matrix Interpretations , 2006, RTA.

[37]  Stefan Kowalewski,et al.  Achieving Highly Reliable Embedded Software: An Empirical Evaluation of Different Approaches , 2007, SAFECOMP.

[38]  Danilo Beuche,et al.  Report of the GI Work Group "Requirements Management Tools for Product Line Engineering" , 2006 .

[39]  Hans Zantema,et al.  Non-looping string rewriting , 1999, RAIRO Theor. Informatics Appl..

[40]  Hans Zantema.  Termination of String Rewriting Proved Automatically , 2005, Journal of Automated Reasoning.

[41]  Hans Zantema,et al.  Reducing Right-Hand Sides for Termination , 2005, Processes, Terms and Cycles.

[42]  Dieter Hofbauer,et al.  Match-Bounded String Rewriting Systems , 2003, Applicable Algebra in Engineering, Communication and Computing.

[43]  Yoshihito Toyama,et al.  Counterexamples to Termination for the Direct Sum of Term Rewriting Systems , 1987, Inf. Process. Lett..

[44]  Joost-Pieter Katoen,et al.  Counterexamples in Probabilistic Model Checking , 2007, TACAS.

[45]  Jürgen Giesl,et al.  Size-Change Termination for Term Rewriting , 2003, RTA.

[46]  T. Kraußer,et al.  A Probabilistic Justification of the Combining Calculus under the Uniform Scheduler Assumption , 2007 .

[47]  Luís Pinto,et al.  Type-based termination of recursive definitions , 2004, Mathematical Structures in Computer Science.

[48]  Joost-Pieter Katoen,et al.  Bisimulation and Logical Preservation for Continuous-Time Markov Decision Processes , 2007, CONCUR.

[49]  Tobias Nipkow,et al.  Term rewriting and all that , 1998 .

[50]  Felix C. Freiling,et al.  Optimal Randomized Fair Exchange with Secret Shared Coins , 2005, OPODIS.

[51]  Leo Bachmair,et al.  An LPO-based Termination Ordering for Higher-Order Terms without lambda-abstraction , 1998, TPHOLs.

[52]  Peter J. Stuckey,et al.  Solving Partial Order Constraints for LPO Termination , 2005, J. Satisf. Boolean Model. Comput..

[53]  Hans Zantema,et al.  Recursive path ordering for infinite labelled rewrite systems , 2006 .

[54]  Hans Zantema,et al.  The Termination Competition , 2007, RTA.

[55]  Hans Zantema,et al.  On tree automata that certify termination of left-linear term rewriting systems , 2005, Inf. Comput..

[56]  Volker Stolz,et al.  Temporal assertions for sequential and concurrent programs , 2007 .

[57]  Alexander Serebrenik,et al.  Acceptability with General Orderings , 2002, Computational Logic: Logic Programming and Beyond.

[58]  David Turner,et al.  Ensuring Termination in ESFP , 2000, J. Univers. Comput. Sci..

[59]  Massimo Marchiori.  Proving Existential Termination of Normal Logic Programs , 1996, AMAST.

[60]  Nao Hirokawa,et al.  Constraints for Argument Filterings , 2007, SOFSEM.

[61]  J. C. van dePol.  Termination of higher-order rewrite systems , 1996 .

[62]  Nachum Dershowitz,et al.  Termination by Abstraction , 2004, ICLP.

[63]  Masahiko Sakai,et al.  On Dependency Pair Method for Proving Termination of Higher-Order Rewrite Systems , 2001, IEICE Trans. Inf. Syst..

[64]  Jan Borchers,et al.  Scrolling Through Time: Improving Interfaces for Searching and Navigating Continuous Audio Timelines , 2006 .

[65]  Uwe Naumann,et al.  An L-Attributed Grammar for Adjoint Code , 2007 .

[66]  Albert Rubio,et al.  Complete Monotonic Semantic Path Orderings , 2000, CADE.

[67]  J. Kruskal.  Well-quasi-ordering, the Tree Theorem, and Vazsonyi’s conjecture , 1960 .

[68]  Yoshihito Toyama,et al.  Termination of S-Expression Rewriting Systems: Lexicographic Path Ordering for Higher-Order Terms , 2004, RTA.

[69]  Andreas Podelski,et al.  A Complete Method for the Synthesis of Linear Ranking Functions , 2004, VMCAI.

[70]  Jan Borchers,et al.  coJIVE: A System to Support Collaborative Jazz Improvisation , 2007 .

[71]  Jürgen Giesl,et al.  Termination of term rewriting using dependency pairs , 2000, Theor. Comput. Sci..

[72]  Thomas Noll,et al.  Optimization of Straight-Line Code Revisited , 2006, Softwaretechnik-Trends.

[73]  Berthold Vöcking,et al.  A Counterexample to the Fully Mixed Nash Equilibrium Conjecture , 2005 .

[74]  Christof Löding,et al.  Transforming structures by set interpretations , 2007, Log. Methods Comput. Sci..

[75]  Deepak Kapur,et al.  A Transformational Methodology for Proving Termination of Logic Programs , 1991, CSL.

[76]  Nathan R. Tallent,et al.  ADJOINT CODE BY SOURCE TRANSFORMATION WITH OPENAD/F , 2006 .

[77]  Hans Zantema,et al.  Matrix Interpretations for Proving Termination of Term Rewriting , 2006, Journal of Automated Reasoning.

[78]  Aart Middeldorp,et al.  Approximations for Strategies and Termination , 2002, WRS.

[79]  N. A C H U M D E R S H O W I T Z.  Termination of Rewriting' , 2022 .

[80]  Kusakari Keiichirou.  On Proving Termination of Term Rewriting Systems with Higher - Order Variables , 2001 .

[81]  Neil D. Jones,et al.  The size-change principle for program termination , 2001, POPL '01.

[82]  David A. Plaisted,et al.  A Simple Non-Termination Test for the Knuth-Bendix Method , 1986, CADE.

[83]  Jürgen Giesl,et al.  Proving Termination Using Recursive Path Orders and SAT Solving , 2007, FroCoS.

[84]  Yoshihito Toyama,et al.  Argument Filtering Transformation , 1999, PPDP.

[85]  Jan Borchers,et al.  Selexels: a Conceptual Framework for Pointing Devices with Low Expressiveness , 2006 .

[86]  Femke van Raamsdonk.  Translating Logic Programs into Conditional Rewriting Systems , 1997, ICLP.

[87]  Terese.  Term rewriting systems , 2003, Cambridge tracts in theoretical computer science.

[88]  Nao Hirokawa,et al.  Uncurrying for Termination , 2008, LPAR.

[89]  Bernhard Gramlich,et al.  Abstract Relations between Restricted Termination and Confluence Properties of Rewrite Systems , 1995, Fundam. Informaticae.

[90]  Raúl Gutiérrez,et al.  Proving Termination of Context-Sensitive Rewriting with MU-TERM , 2007, PROLE.

[91]  Jürgen Giesl,et al.  Proving Termination by Bounded Increase , 2007, CADE.

[92]  Torsten Kuhlen,et al.  Utilizing optical sensors from mice for new input devices , 2006 .

[93]  Andreas Podelski,et al.  Termination proofs for systems code , 2006, PLDI '06.

[94]  Jürgen Giesl,et al.  Mechanizing and Improving Dependency Pairs , 2006, Journal of Automated Reasoning.

[95]  Christof Löding,et al.  Unranked Tree Automata with Sibling Equalities and Disequalities , 2007, ICALP.

[96]  Henny B. Sipma,et al.  Practical Methods for Proving Program Termination , 2002, CAV.

[97]  Hans Zantema,et al.  Liveness in Rewriting , 2003, RTA.

[98]  Yuxiao Hu,et al.  Optimal vertex elimination in single-expression-use graphs , 2008, TOMS.

[99]  Yi Wang,et al.  On Non-looping Term Rewriting , 2006 .

[100]  G. Aguzzi,et al.  Proving Termination of Logic Programs by Transforming them into Equivalent Term Rewriting Systems , 1993, FSTTCS.

[101]  Mesut Gunes,et al.  From Simulations to Testbeds — Architecture of the Hybrid MCG-Mesh Testbed , 2006 .

[102]  Hélène Kirchner,et al.  System Presentation -- CARIBOO: An induction based proof tool for termination with strategies , 2002, PPDP '02.

[103]  Frédéric Blanqui.  A Type-Based Termination Criterion for Dependently-Typed Higher-Order Rewrite Systems , 2004, RTA.

[104]  Nao Hirokawa,et al.  Tyrolean termination tool: Techniques and features , 2007, Inf. Comput..

[105]  H. Lichter,et al.  MeDUSA-MethoD for UML 2-based Design of Embedded Software Applications , 2007 .

[106]  Jürgen Giesl,et al.  Automatic Termination Proofs in the Dependency Pair Framework , 2006, IJCAR.

[107]  Jürgen Giesl,et al.  SAT Solving for Argument Filterings , 2006, LPAR.

[108]  P. Rossmanith,et al.  A New Satisabilit y Algorithm With Applications To Max-Cut , 2005 .

[109]  Jürgen Giesl,et al.  Improved Modular Termination Proofs Using Dependency Pairs , 2004, IJCAR.

[110]  Jürgen Giesl,et al.  Termination Analysis for Functional Programs , 1998 .

[111]  Jürgen Giesl,et al.  Automated Termination Analysis for Logic Programs by Term Rewriting , 2006, LOPSTR.

[112]  Aart Middeldorp,et al.  Predictive Labeling with Dependency Pairs Using SAT , 2007, CADE.

[113]  Frédéric Mesnard,et al.  On proving left termination of constraint logic programs , 2003, TOCL.

[114]  Jürgen Giesl,et al.  The Dependency Pair Framework: Combining Techniques for Automated Termination Proofs , 2005, LPAR.

[115]  Masahiko Sakai,et al.  An Extension of the Dependency Pair Method for Proving Termination of Higher-Order Rewrite Systems , 2001 .

[116]  Joost-Pieter Katoen,et al.  Verifying Concurrent List-Manipulating Programs by LTL Model Checking , 2007 .

[117]  Bruce Christianson,et al.  Second-order adjoints by source code manipulation of numerical programs , 2007 .

[118]  Jürgen Giesl,et al.  Improving Dependency Pairs , 2003, LPAR.

[119]  Nao Hirokawa,et al.  Predictive Labeling , 2006, RTA.

[120]  Andreas Abel.  Termination checking with types , 2004, RAIRO Theor. Informatics Appl..

[121]  Pierre Courtieu,et al.  Certification of Automated Termination Proofs , 2007, FroCoS.

[122]  Jürgen Giesl,et al.  Termination Analysis for Functional Programs using Term Orderings , 1995, SAS.

[123]  Jan Willem Klop,et al.  Comparing Curried and Uncurried Rewriting , 1993, J. Symb. Comput..

[124]  Salvador Lucas,et al.  Polynomials over the reals in proofs of termination: from theory to practice , 2005, RAIRO Theor. Informatics Appl..

[125]  René Thiemann,et al.  Innermost Termination of Rewrite Systems by Labeling , 2008, WRS@RDP.

[126]  Michael Weber,et al.  Parallel algorithms for verification on large systems , 2006 .

[127]  Massimo Marchiori.  Logic Programs as term Rewriting Systems , 1994, ALP.

[128]  Jürgen Giesl,et al.  Automated Termination Analysis for Haskell: From Term Rewriting to Programming Languages , 2006, RTA.

[129]  Albert Rubio,et al.  A Monotonic Higher-Order Semantic Path Ordering , 2001, LPAR.

[130]  U. Naumann,et al.  Intraprocedural Adjoint Code Generated by the Differentiation-Enabled NAGWare Fortran Compiler , 2006 .

[131]  Adam Koprowski.  TPA: Termination Proved Automatically , 2006, RTA.

[132]  U. Naumann.  Syntax-Directed Derivative Code (Part II: Intraprocedural Adjoint Code) , 2005 .

[133]  Danny De Schreye,et al.  Termination of Logic Programs: The Never-Ending Story , 1994, J. Log. Program..

[134]  Sébastien Hinderer,et al.  CoLoR : a Coq library on rewriting and termination , 2006 .

[135]  Peter J. Stuckey,et al.  Testing for Termination with Monotonicity Constraints , 2005, ICLP.

[136]  Hans Zantema,et al.  Adding constants to string rewriting , 2008, Applicable Algebra in Engineering, Communication and Computing.