Proving and Disproving Termination of Higher-Order Functions

The dependency pair technique is a powerful modular method for automated termination proofs of term rewrite systems (TRSs). We present two important extensions of this technique: First, we show how to prove termination of higher-order functions using dependency pairs. To this end, the dependency pair technique is extended to handle (untyped) applicative TRSs. Second, we introduce a method to prove non-termination with dependency pairs, while up to now dependency pairs were only used to verify termination. Our results lead to a framework for combining termination and non-termination techniques for first- and higher-order functions in a very flexible way. We implemented and evaluated our results in the automated termination prover AProVE.

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

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

[3]  Klaus Drosten.  Termersetzungssysteme : Grundlagen der Prototyp-Generierung algebraischer Spezifikationen , 1989, Informatik-Fachberichte.

[4]  Matthias Jarke,et al.  ConceptBase - A Deductive Object Base Manager , 1994 .

[5]  Bernhard Steffen,et al.  Compositional Minimization of Finite State Systems , 1990, CAV.

[6]  Manfred Nagl,et al.  On Integration Mechanisms within a Graph-based Software Development Environment , 1987, WG.

[7]  Stefan Gruner.  Einige Anmerkungen zur graphgrammatischen Spezifikation von Integrationswerkzeugen nach Westfechtel, Janning, Lefering und Schürr , 1998 .

[8]  Jacques D. Fleuriot,et al.  IsaPlanner: A Prototype Proof Planner in Isabelle , 2003, CADE.

[9]  Albert Rubio,et al.  The higher-order recursive path ordering , 1999, Proceedings. 14th Symposium on Logic in Computer Science (Cat. No. PR00158).

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

[11]  Matthias Jarke,et al.  Intelligent Networks as a Data Intensive Application (INDIA) , 1994, ADB.

[12]  Alberto Oliart,et al.  A Fast Algorithm for Uniform Semi-Unification , 1998, CADE.

[13]  Patrick Shicheng Chen,et al.  On Inference Rules of Logic-Based Information Retrieval Systems , 1994, Inf. Process. Manag..

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

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

[16]  Philip Wadler.  Call-by-Value Is Dual to Call-by-Name - Reloaded , 2005, RTA.

[17]  Markus Mohnen.  Efficient Compile-Time Garbage Collection for Arbitrary Data Structures , 1995, PLILP.

[18]  Guido Moerkotte,et al.  Efficient Evaluation of Aggregates on Bulk Types , 1995, DBPL.

[19]  Frank Wolter,et al.  Monodic fragments of first-order temporal logics: 2000-2001 A.D , 2001, LPAR.

[20]  Martin Grohe,et al.  An existential locality theorem , 2004, Ann. Pure Appl. Log..

[21]  Yoshihito Toyama,et al.  4th International Workshop on Reduction Strategies in Rewriting and Programming , 2004 .

[22]  RWTHAachen,LehrstuhlfurInformatikII Ahornstrae55,W-5100Aachen,Germany , .

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

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

[25]  Matthias Jarke,et al.  Business process oriented information management: conceptual models at work , 1995, COCS '95.

[26]  Werner Damm,et al.  Specifying distributed computer architectures in AADL , 1989, Parallel Comput..

[27]  Guido Moerkotte,et al.  Nested Queries in Object Bases , 1993, DBPL.

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

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

[30]  Richard S. Bird,et al.  Introduction to functional programming , 1988, Prentice Hall International series in computer science.

[31]  J. Klop,et al.  WST ’ 04 7 th International Workshop on Termination , 2004 .

[32]  Andy Schürr,et al.  Computing with Graphs and Graph Rewriting , 1999 .

[33]  Matthias Jarke,et al.  Simulating the Impact of Information Flows in Networked Organizations , 1996, ICIS.

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

[35]  Thierry Cachat.  The Power of One-Letter Rational Languages , 2001, Developments in Language Theory.

[36]  Rudolf Mathar,et al.  Analyzing routing strategy NFP in multihop packet radio networks on a line , 1995, IEEE Trans. Commun..

[37]  Philip Wadler,et al.  Projections for strictness analysis , 1987, FPCA.

[38]  Christian Prehofer,et al.  Higher-order narrowing with definitional trees , 1999, Journal of Functional Programming.

[39]  J. J. Ruzz,et al.  A VHDL Speci cation of a Shared Memory Parallel Machine for Babel , 1998 .

[40]  K. Jacobs.  OSI-an appropriate basis for group communication? , 1989, IEEE International Conference on Communications, World Prosperity Through Communications,.

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

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

[43]  Bernhard Steffen,et al.  Characteristic Formulae for Processes with Divergence , 1994, Inf. Comput..

[44]  Alan Mycroft,et al.  The Theory and Practice of Transforming Call-by-need into Call-by-value , 1980, Symposium on Programming.

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

[46]  Wolfgang Thomas,et al.  AMORE: A System for Computing Automata, MOnoids, and Regular Expressions , 1989, STACS.

[47]  Manfred Nagl,et al.  A universal component for the administration in distributed and integrated development environments , 1994 .

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

[49]  Nao Hirokawa,et al.  Tyrolean Termination Tool , 2005, RTA.

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

[51]  Stackbased ReductionGuido Hogen,et al.  Parallel Functional Implementations: Graphbased vs. Stackbased Reduction , 1995 .

[52]  M. O. Berger,et al.  k-coloring vertices using a neural network with convergence to valid solutions , 1994, Proceedings of 1994 IEEE International Conference on Neural Networks (ICNN'94).

[53]  Gottfried Vossen,et al.  SUXESS: Towards a Sound Unification of Extensions of the Relational Data Model , 1991, Data Knowl. Eng..

[54]  Jean-Pierre Jouannaud,et al.  Higher-order recursive path orderings , 1998 .

[55]  Ian Green,et al.  System Description: Proof Planning in Higher-Order Logic with Lambda-Clam , 1998, CADE.

[56]  Ugo Montanari,et al.  International Symposium on Programming , 1982, Lecture Notes in Computer Science.

[57]  Nao Hirokawa,et al.  Automating the Dependency Pair Method , 2003, CADE.

[58]  Stefan Gruner.  Schemakorrespondenzaxiome unterstützen die paargrammatische Spezifikation inkrementeller Integrationswerkzeuge , 1997 .

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

[60]  Takahito Aoto,et al.  Termination of Simply Typed Term Rewriting by Translation and Labelling , 2003, RTA.

[61]  Jörg H. Siekmann,et al.  8th International Conference on Automated Deduction , 1986, Lecture Notes in Computer Science.

[62]  Matthias Jarke,et al.  Exploring the Semantic Structure of Technical Document Collections: A Cooperative Systems Approach , 2000, CoopIS.

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

[64]  George Horatiu Botorog.  High level parallel programming and the efficient implementation of numerical algorithms , 1998 .

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

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

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

[68]  Richard S. Bird,et al.  Introduction to functional programming using haskeu , 1998 .

[69]  Matthias Jarke,et al.  From Relational to Object-Oriented Integrity Simplification , 1991, DOOD.

[70]  Andreas J. Winter,et al.  Modules and Updatable Graph Views for PROgrammed Graph REwriting Systems , 1997 .

[71]  U. Quernheim.  Satellite communication protocols-a performance comparison considering on-board processing , 1988, 8th European Conference on Electrotechnics, Conference Proceedings on Area Communication.

[72]  Jürgen Giesl.  Automated Termination Proofs with Measure Functions , 1995, KI.

[73]  Matthias Jarke,et al.  Three Aspects of Intelligent Cooperation in the Quality Cycle , 1993, Int. J. Cooperative Inf. Syst..

[74]  Markus Mohnen,et al.  Optimising the memory management of higher order functional programs , 1997 .

[75]  Kai Jakobs,et al.  Timer Handling in High-Performance Transport Systems , 1993, Integrated Broadband Communications.

[76]  R. Bird.  Introduction to functional programming using Haskell, Second Edition , 1998 .

[77]  Roland Baumann.  Client / Server Distribution in a Structure-Oriented Database Management System , 1997 .

[78]  Paliath Narendran,et al.  Semi-Unification , 1991, Theor. Comput. Sci..

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

[80]  Rance Cleaveland,et al.  The concurrency workbench: a semantics-based tool for the verification of concurrent systems , 1993, TOPL.

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

[82]  Marcin Jurdzinski,et al.  A Discrete Strategy Improvement Algorithm for Solving Parity Games , 2000, CAV.

[83]  Rudolf Mathar,et al.  Analyzing a distributed slot assignment protocol by Markov chains , 1992, [1992 Proceedings] Vehicular Technology Society 42nd VTS Conference - Frontiers of Technology.

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

[85]  Matthias Jarke,et al.  Incremental Maintenance of Externally Materialized Views , 1996, VLDB.

[86]  Larry Wos,et al.  What Is Automated Reasoning? , 1987, J. Autom. Reason..

[87]  Nachum Dershowitz,et al.  Termination of Rewriting , 1987, J. Symb. Comput..

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

[89]  C. Lewerentz,et al.  Integrated Project Team Management in a Software Development Environment , 1988 .

[90]  Manfred A. Jeusfeld,et al.  An Executable Meta Model for Re-Engineering of Database Schemas , 1994, Int. J. Cooperative Inf. Syst..

[91]  David Aspinall,et al.  Formalising Java's Data Race Free Guarantee , 2007, TPHOLs.

[92]  Werner Hans,et al.  Full Indexing for Lazy Narrowing , 1993 .

[93]  Janis A. Bubenko,et al.  Requirements Engineering: An Integrated View of Representation, Process, and Domain , 1993, ESEC.

[94]  Benedikt Bollig,et al.  Message-passing automata are expressively equivalent to EMSO logic , 2006, Theor. Comput. Sci..

[95]  Otto Spaniol,et al.  File transfer in high-speed token ring networks: performance evaluation by approximate analysis and simulation , 1988, IEEE J. Sel. Areas Commun..

[96]  Werner Hans,et al.  A Complete Indexing Scheme for WAM-based Abstract Machines , 1992, PLILP.