Termination Analysis of Logic Programs: Extended Abstract

Termination is well-known to be one of the most intriguing aspects of program verification. Since logic programs are Turing-complete, it follows by the undecidability of the halting problem that there exists no algorithm which, given an arbitrary logic program, decides whether the program terminates. However, one can propose both conditions that are equivalent to termination and their approximations that imply termination and can be verified automatically. This paper briefly discusses these kinds of conditions that were studied in [2].

[1]  Seng Wai Loke,et al.  Adding Logic Programming Behaviour to the World Wide Web , 1998 .

[2]  Danny De Schreye,et al.  Automatic Inference of Norms: A Missing Link in Automatic Termination Analysis , 1993, ILPS.

[3]  Saumya K. Debray,et al.  Towards Banishing the Cut from Prolog , 1990, IEEE Trans. Software Eng..

[4]  Patrick Cousot,et al.  Methods and Logics for Proving Programs , 1990, Handbook of Theoretical Computer Science, Volume B: Formal Models and Sematics.

[5]  Christian Holzbaur.  OFAI clp(Q,R) Manual , 1995 .

[6]  James Cussens,et al.  Stochastic Logic Programs: Sampling, Inference and Applications , 2000, UAI.

[7]  Mario Tokoro,et al.  ALEX: The Logic Programming Language with Explicit Control and without Cut-Operators , 1988, LP.

[8]  Robert A. Kowalski,et al.  Algorithm = logic + control , 1979, CACM.

[9]  Deepak Kapur,et al.  Transformational Methodology for Proving Termination of Logic Programs , 1998, J. Log. Program..

[10]  Elena Marchiori,et al.  On Termination of Constraint Logic Programs , 1995, CP.

[11]  Wim Vanhoof,et al.  Pos(T): Analyzing Dependencies in Typed Logic Programs , 2001, Ershov Memorial Conference.

[12]  Dino Pedreschi,et al.  Proving Termination of General Prolog Programs , 1991, TACS.

[13]  Jürgen Giesl,et al.  Approximating the Domains of Functional and Imperative Programs , 1999, Sci. Comput. Program..

[14]  Danny De Schreye,et al.  Why Untyped Nonground Metaprogramming Is Not (Much Of) A Problem , 1995, J. Log. Program..

[15]  Étienne Payet,et al.  cTI: un outil pour l'inférence de conditions optimales de terminasion pour Prolog , 2001, JFPLC.

[16]  Hans Zantema,et al.  Termination of Term Rewriting: Interpretation and Type Elimination , 1994, J. Symb. Comput..

[17]  Nachum Dershowitz,et al.  Trees, Ordinals and Termination , 1993, TAPSOFT.

[18]  Marianne Baudinet,et al.  Proving termination properties of Prolog programs: a semantic approach , 1988, [1988] Proceedings. Third Annual Information Symposium on Logic in Computer Science.

[19]  F. vanRaamsdonk.  Translating logic programs into conditional rewriting systems , 1997 .

[20]  Samir Genaim,et al.  Inferring termination conditions for logic programs using backwards analysis , 2001, Theory and Practice of Logic Programming.

[21]  Zohar Manna,et al.  Proving termination with multiset orderings , 1979, CACM.

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

[23]  Chin Soon Lee.  Program Termination Analysis in Polynomial Time , 2002, GPCE.

[24]  Lutz Plümer.  Termination Proofs for Logic Programs , 1990, Lecture Notes in Computer Science.

[25]  Michael Hanus,et al.  A unified computation model for functional and logic programming , 1997, POPL '97.

[26]  Giorgio Levi,et al.  A Reconstruction of Veriication Techniques by Abstract Interpretation , 1997 .

[27]  Li-Yan Yuan,et al.  Loop checks for logic programs with functions , 2001, Theor. Comput. Sci..

[28]  Manuel V. Hermenegildo,et al.  Effectiveness of Global Analysis in Strict Independence-Based Automatic Parallelization , 1994, ILPS.

[29]  Yehoshua Sagiv,et al.  Inference of Monotonicity Constraints in Datalog Programs , 1989, PODS.

[30]  Jean Vuillemin,et al.  Exact real computer arithmetic with continued fractions , 1988, IEEE Trans. Computers.

[31]  Richard A. O'Keefe,et al.  The Craft of Prolog , 1990 .

[32]  Peter J. Stuckey,et al.  An Overview of HAL , 1999, CP.

[33]  Yehoshua Sagiv,et al.  Inference of Inequality Constraints in Logic Programs. , 1991, PODS 1991.

[34]  James Cussens,et al.  Parameter Estimation in Stochastic Logic Programs , 2001, Machine Learning.

[35]  Peter Van Roy.  Logic Programming in Oz with Mozart , 1999, ICLP.

[36]  Nachum Dershowitz,et al.  A General Framework for Automatic Termination Analysis of Logic Programs , 2000, Applicable Algebra in Engineering, Communication and Computing.

[37]  Wim Vanhoof,et al.  Reuse of Results in Termination Analysis of Typed Logic Programs , 2002, SAS.

[38]  John P. Gallagher,et al.  Combining Norms to Prove Termination , 2002, VMCAI.

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

[40]  Sandro Etalle,et al.  On modular termination proofs of general logic programs , 2002, Theory Pract. Log. Program..

[41]  Zohar Manna,et al.  Automatic Generation of Invariants and Intermediate Assertions , 1997, Theor. Comput. Sci..

[42]  Dino Pedreschi,et al.  Verification of Meta-Interpreters , 1997, J. Log. Comput..

[43]  Marc Bezem,et al.  Strong Termination of Logic Programs , 1991, J. Log. Program..

[44]  Giorgio Levi,et al.  Contributions to a Theory of Existential Termination for Definite Logic Programs , 1995, GULP-PRODE.

[45]  Deepak Kapur,et al.  Rewriting Concepts in the Study of Termination of Logic Programs , 1992, ALPUK.

[46]  Frédéric Mesnard,et al.  Inferring Left-terminating Classes of Queries for Constraint Logic Programs , 1996 .

[47]  Konstantinos Sagonas,et al.  XSB as an efficient deductive database engine , 1994, SIGMOD '94.

[48]  Roland N. Bol.  Loop Checking and Negation , 1993, J. Log. Program..

[49]  Yehoshua Sagiv,et al.  Inference of inequality constraints in logic programs (extended abstracts) , 1991, PODS '91.

[50]  Lutz Plüer.  Termination proofs for logic programs based on predicate inequalities , 1990 .

[51]  Danny De Schreye,et al.  Termination analysis: some practical properties of the norm space , 1998, ICLP 1998.

[52]  Alexander Serebrenik,et al.  Inference of termination conditions for numerical loops in Prolog , 2004, Theory Pract. Log. Program..

[53]  Hilary Putnam,et al.  A Computing Procedure for Quantification Theory , 1960, JACM.

[54]  Robert A. Kowalski,et al.  Logic for problem solving , 1982, The computer science library : Artificial intelligence series.

[55]  KRZYSZTOF R. APT,et al.  A New Definition of SNDNF-Resolution , 1994, J. Log. Program..

[56]  Christoph Walther.  Criteria for Termination , 2000, Intellectics and Computational Logic.

[57]  Danny De Schreye,et al.  Termination proofs for logic programs with tabling , 2001, TOCL.

[58]  Henny B. Sipma,et al.  Synthesis of Linear Ranking Functions , 2001, TACAS.

[59]  Zoltan Somogyi,et al.  The Execution Algorithm of Mercury, an Efficient Purely Declarative Logic Programming Language , 1996, J. Log. Program..

[60]  Abbas Edalat,et al.  Semantics of exact real arithmetic , 1997, Proceedings of Twelfth Annual IEEE Symposium on Logic in Computer Science.

[61]  Jan-Georg Smaus.  Modes and types in logic programming , 1999 .

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

[63]  Ivan Bratko,et al.  Prolog Programming for Artificial Intelligence , 1986 .

[64]  Elena Marchiori,et al.  UvA-DARE ( Digital Academic Repository ) Reasoning about Prolog Programs : from Modes through Types to Assertions , 2005 .

[65]  David Scott Warren,et al.  Analysis of SLG-WAM Evaluation of Definite Programs , 1994, ILPS.

[66]  Dino Pedreschi,et al.  Studies in Pure Prolog: Termination , 1990 .

[67]  Mats Carlsson,et al.  An Open-Ended Finite Domain Constraint Solver , 1997, PLILP.

[68]  John Wylie Lloyd,et al.  Foundations of Logic Programming , 1987, Symbolic Computation.

[69]  Krzysztof R. Apt,et al.  Meta-Variables in Logic Programming, or in Praise of Ambivalent Syntax , 1996, Fundam. Informaticae.

[70]  Jean Vuillemin.  Exact Real Computer Arithmetic with Continued Fractions , 1990, IEEE Trans. Computers.

[71]  F. Pfenning.  Logic programming in the LF logical framework , 1991 .

[72]  Philippe Devienne,et al.  Halting Problem of One Binary Horn Clause is Undecidable , 1993, STACS.

[73]  W. Older,et al.  Extending Prolog with Constraint Arithmetic on Real Intervals , 1990 .

[74]  Lee Naish,et al.  Coroutining and the construction of terminating logic programs , 1992 .

[75]  Lutz Plümer.  Automatic Termination Proofs for Prolog Programs Operating on Nonground Terms , 1991, ISLP.

[76]  Drew McDermott,et al.  Nonmonotonic Logic and Temporal Projection , 1987, Artif. Intell..

[77]  Sandro Etalle,et al.  On the Unification Free Prolog Programs , 1993, MFCS.

[78]  Helder Coelho,et al.  Prolog by Example , 1988, Symbolic Computation.

[79]  Maurizio Gabbrielli,et al.  The s-Semantics Approach: Theory and Applications , 1994, J. Log. Program..

[80]  Matthieu Martel,et al.  Static Analysis of the Numerical Stability of Loops , 2002, SAS.

[81]  Zohar Manna,et al.  Proving termination with multiset orderings , 1979, CACM.

[82]  Alexander Serebrenik,et al.  Unfolding the Mystery of Mergesort , 1997, LOPSTR.

[83]  Danny De Schreye,et al.  Termination Analysis: Some Practical Properties of the Norm and Level Mapping Space , 1998, IJCSLP.

[84]  David Monniaux.  An Abstract Analysis of the Probabilistic Termination of Programs , 2001, SAS.

[85]  Kim Mens,et al.  Building Composable Aspect-Specific Languages with Logic Metaprogramming , 2002, GPCE.

[86]  Antonis C. Kakas,et al.  Computational Logic: Logic Programming and Beyond , 2002, Lecture Notes in Computer Science.

[87]  Masoud Yazdani,et al.  Prolog Programming: A Tutorial Introduction , 1991 .

[88]  John Potter,et al.  Characterisation of Terminating Logic Programs , 1986, SLP.

[89]  Yehoshua Sagiv.  A Termination Test for Logic Programs , 1991, ISLP.

[90]  Gilberto Filé,et al.  Static Analysis of Prolog with Cut , 1993, LPAR.

[91]  Robert W. Floyd,et al.  Assigning Meanings to Programs , 1993 .

[92]  Danny De Schreye,et al.  Deriving Termination Proofs for Logic Programs, Using Abstract Procedures , 1991, International Conference on Logic Programming.

[93]  Robert F. Stärk,et al.  The Theoretical Foundations of LPTP (A Logic Program Theorem Prover) , 1998, J. Log. Program..

[94]  Saumya K. Debray,et al.  Non-Failure Analysis for Logic Programs , 1997, ICLP.

[95]  Taisuke Sato,et al.  PRISM: A Language for Symbolic-Statistical Modeling , 1997, IJCAI.

[96]  Pierre Lescanne,et al.  On the recursive decomposition ordering with lexicographical status and other related orderings , 1990, Journal of Automated Reasoning.

[97]  Maurice Bruynooghe,et al.  On the Existence of Nonterminating Queries for a Restricted Class of PROLOG-Clauses , 1989, Artif. Intell..

[98]  Michael Codish,et al.  A Semantic Basis for the Termination Analysis of Logic Programs , 1999, J. Log. Program..

[99]  Ramarao Kanneganti,et al.  Universal domains for sequential computation , 1996 .

[100]  J. Urgen Giesl.  Generating Polynomial Orderings for Termination Proofs ? , 1995 .

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

[102]  John W. Lloyd,et al.  Combining Functional and Logic Programming Languages , 1994, ILPS.

[103]  Frank Pfenning,et al.  Twelf User''s Guide , 2002 .

[104]  Yamine Ait-Ameur,et al.  Refinement of rational end-points real numbers by means of floating-point numbers , 1999 .

[105]  Peter Van Roy,et al.  Can Logic Programming Execute as Fast as Imperative Programming? , 1990 .

[106]  Frédéric Mesnard,et al.  cTI: Bottom-Up Termination Inference for Logic Programs , 2000, WLP.

[107]  David Goldberg,et al.  What every computer scientist should know about floating-point arithmetic , 1991, CSUR.

[108]  Nachum Dershowitz,et al.  Examples of Termination , 1993, Term Rewriting.

[109]  Salvatore Ruggieri.  Decidability of logic program semantics and applications to testing , 2000, J. Log. Program..

[110]  Alexander Serebrenik,et al.  Non-tranformational termination analysis of logic programs, based on general term-orderings , 2000, LOPSTR.

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

[112]  Jürgen Giesl,et al.  Termination Analysis by Inductive Evaluation , 1998, CADE.

[113]  Krzysztof R. Apt,et al.  From logic programming to Prolog , 1996, Prentice Hall International series in computer science.

[114]  Donald Nute,et al.  Prolog Programming in Depth , 1988 .

[115]  Juliana Freire,et al.  The XSB Programmer’s Manual , 1800 .

[116]  Alexander Serebrenik,et al.  On Termination of Meta-Programs , 2001, LPAR.

[117]  Theo D'Hondt,et al.  Aspect-Orientated Logic Meta Programming , 1999, Reflection.

[118]  Krzysztof R. Apt,et al.  A new definition of SLDNF-resolution , 1992 .

[119]  Frédéric Mesnard,et al.  Applying Static Analysis Techniques for Inferring Termination Conditions of Logic Programs , 2001, SAS.

[120]  P. M. Hill,et al.  Meta-Programming in Logic Progamming , 1998 .

[121]  Danny De Schreye,et al.  Two semantics for definite meta-programs, using the non-ground representation , 1995 .

[122]  Alberto Martelli,et al.  An Efficient Unification Algorithm , 1982, TOPL.

[123]  David A. Rosenblueth.  Chart Parsers as Proof Procedures for Fixed-Mode Logic Programs , 1992, FGCS.

[124]  Dino Pedreschi,et al.  Classes of terminating logic programs , 2001, Theory and Practice of Logic Programming.

[125]  James Demmel,et al.  Faster numerical algorithms via exception handling , 1993, Proceedings of IEEE 11th Symposium on Computer Arithmetic.

[126]  Maurice Bruynooghe,et al.  A Framework for Analyzing the Termination of Definite Logic Programs with respect to Call Patterns , 1992, FGCS.

[127]  Uday S. Reddy,et al.  Transformation of Logic Programs into Functional Programs , 1984, SLP.

[128]  Frank van Harmelen.  A Classification of Meta-level Architectures , 1988, META.

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

[130]  Danny De Schreye,et al.  Termination Analysis of Tabled Logic Programs Using Mode and Type Information , 1999, Fuji International Symposium on Functional and Logic Programming.

[131]  Dino Pedreschi,et al.  Modular termination proofs for logic and pure PROLOG programs , 1993 .

[132]  Giorgio Levi,et al.  A Formalization of Metaprogramming for real , 1993, ICLP.

[133]  Étienne Payet,et al.  Detecting Optimal Termination Conditions of Logic Programs , 2002, SAS.

[134]  Thom W. Frühwirth,et al.  Proving Termination of Constraint Solver Programs , 1999, New Trends in Constraints.

[135]  Robert A. Kowalski,et al.  Predicate Logic as Programming Language , 1974, IFIP Congress.

[136]  John W. Lloyd,et al.  Analysis of Meta-Programs , 1989, META.

[137]  J. A. Robinson,et al.  A Machine-Oriented Logic Based on the Resolution Principle , 1965, JACM.

[138]  Renato Iturriaga.  CONTRIBUTIONS TO MECHANICAL MATHEMATICS. , 1967 .

[139]  Nachum Dershowitz,et al.  Orderings for term-rewriting systems , 1979, 20th Annual Symposium on Foundations of Computer Science (sfcs 1979).

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

[141]  Jürgen Brauburger.  Automatic termination analysis for functional and imperative programs , 1999, DISKI.

[142]  Eric Goubault,et al.  Static Analyses of the Precision of Floating-Point Operations , 2001, SAS.

[143]  Dino Pedreschi,et al.  Reasoning about Termination of Pure Prolog Programs , 1993, Inf. Comput..

[144]  Keith L. Clark,et al.  Negation as Failure , 1987, Logic and Data Bases.

[145]  C. R. Ramakrishnan,et al.  On the conversion of indirect to direct recursion , 1993, LOPL.

[146]  Pascal Van Hentenryck,et al.  Numerica: A Modeling Language for Global Optimization , 1997, IJCAI.

[147]  John R. Hauser,et al.  Handling floating-point exceptions in numeric programs , 1995, TOPL.

[148]  Maurice Bruynooghe,et al.  A Practical Technique for Detecting Non-terminating Queries for a Restricted Class of Horn Clauses, Using Directed, Weighted Graphs , 1990, ICLP.

[149]  Andrew Bowles,et al.  Tracing Requirements for Multi-Layered Meta-Programming , 1988, META.

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

[151]  Jürgen Giesl,et al.  Generating Polynomial Orderings for Termination Proofs , 1995, RTA.

[152]  Dino Pedreschi,et al.  Modular Verification of Logic Programs , 1996 .

[153]  Jeffrey C. Lagarias,et al.  The 3x + 1 Problem and its Generalizations , 1985 .

[154]  Tobias Müller,et al.  Constraint propagation in Mozart , 2001 .

[155]  Gerda Janssens,et al.  Deriving Descriptions of Possible Values of Program Variables by Means of Abstract Interpretation , 1990, J. Log. Program..

[156]  Yehoshua Sagiv,et al.  Automatic Termination Analysis of Logic Programs , 1997, ICLP.

[157]  Alexander Serebrenik,et al.  Proving Termination with Adornments , 2003, LOPSTR.

[158]  William H. Winsborough,et al.  Multiple Specialization using Minimal-Function Graph Semantics , 1992, J. Log. Program..

[159]  T. Arts.  Automatically proving termination and innermost normalisation of term rewriting systems , 2001 .

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

[161]  Paul A. Strooper,et al.  Complete Sets of Frontiers in Logic-Based Program Transformation , 1988, META.

[162]  Krzysztof R. Apt,et al.  An Analysis of Loop Checking Mechanisms for Logic Programs , 1991, Theor. Comput. Sci..

[163]  Joachim Steinbach.  Generating Polynomial Orderings , 1994, Inf. Process. Lett..

[164]  Jeffrey D. Ullman,et al.  Efficient tests for top-down termination of logical rules , 1988, JACM.

[165]  Andrew B. Baker,et al.  A Simple Solution to the Yale Shooting Problem , 1989, KR.

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

[167]  Peter J. Stuckey,et al.  Constraint-based mode analysis of mercury , 2002, PPDP '02.

[168]  Annalisa Bossi,et al.  Norms on Terms and their use in Proving Universal Termination of a Logic Program , 1994, Theor. Comput. Sci..

[169]  Dimiter Skordev,et al.  An Abstract Approach to Some Loop Detection Problems , 1997, Fundam. Informaticae.

[170]  Salvatore Ruggieri.  Termination of Constraint Logic Programs , 1997, ICALP.

[171]  Evelina Lamma,et al.  Combining Solvers in a Meta Constraint Logic Programming Architecture , 1996, FroCoS.

[172]  Lee Naish,et al.  A three-valued declarative debugging scheme , 2000, Proceedings 23rd Australasian Computer Science Conference. ACSC 2000 (Cat. No.PR00518).

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

[174]  C. A. R. Hoare,et al.  An axiomatic basis for computer programming , 1969, CACM.

[175]  Robert F. Stärk.  Formal Verification of Logic Programs: Foundations and Implementation , 1997, LFCS.

[176]  Paolo Mancarella,et al.  Negation as Failure through Abduction: Reasoning about Termination , 2002, Computational Logic: Logic Programming and Beyond.

[177]  James H. Andrews.  A Paralogical Semantics for the Prolog Cut , 1995, ILPS.

[178]  Danny De Schreye,et al.  Constraint-based termination analysis of logic programs , 1999, TOPL.

[179]  Andy King,et al.  Inferring Argument Size Relationships with CLP(R) , 1996, LOPSTR.

[180]  Frédéric Mesnard,et al.  Inferring and Compiling Termination for Constraint Logic Programs , 1998, LOPSTR.

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

[182]  Frédéric Benhamou,et al.  Programming in CLP(BNR) , 1993, PPCP.

[183]  Wim Vanhoof,et al.  When size does matter: Termination analysis for typed logic programs , 2001 .

[184]  Giorgio Levi,et al.  Declarative Modeling of the Operational Behavior of Logic Languages , 1989, Theor. Comput. Sci..

[185]  Alberto Pettorossi,et al.  Correctness of Logic Program Transformations Based on Existential Termination , 1995, ILPS.

[186]  Keith L. Clark.  Predicate logic as a computational formalism , 1979 .

[187]  Roberta Gori,et al.  An Abstract Interpretation Approach to Termination of Logic Programs , 2000, LPAR.

[188]  Peter J. Stuckey,et al.  Herbrand Constraint Solving in HAL , 1999, ICLP.

[189]  Robert A. Kowalski,et al.  Problems and Promises of Computational Logic , 1990 .

[190]  Martín Hötzel Escardó,et al.  PCF Extended with Real Numbers , 1996, Theor. Comput. Sci..

[191]  Alexander Serebrenik,et al.  Inference of termination conditions for numerical loops , 2001, ArXiv.

[192]  Salvatore Ruggieri.  On computing the semi-sum of two integers , 2003, Inf. Process. Lett..

[193]  Christophe Verschaetse.  Static termination analysis for definite Horn clause programs , 1992 .

[194]  Alexander Serebrenik,et al.  TermiLog: A System for Checking Termination of Queries to Logic Programs , 1997, CAV.

[195]  Yamine Aït Ameur,et al.  An Application of Abstract Interpretation to Floating Point Arithmetic , 1992, WSA.

[196]  Eric Goubault,et al.  Asserting the Precision of Floating-Point Computations: A Simple Abstract Interpreter , 2002, ESOP.

[197]  Gerda Janssens,et al.  Abstracting Numerical Values in CLP(H, N) , 1994, PLILP.

[198]  Egon Börger,et al.  Unsolvable Decision Problems for Prolog Programs , 1987, Computation Theory and Logic.

[199]  Lutz Plümer,et al.  Handling of Mutual Recursion in Automatic Termination Proofs for Logic Programs , 1992, JICSLP.

[200]  Jieh Hsiang.  Rewrite Method for Theorem Proving in First Order Theory with Equality , 1987, J. Symb. Comput..

[201]  Alexander Serebrenik,et al.  Acceptability with general orderings , 2002 .

[202]  Roland N. Bol,et al.  Generalizing Completeness Results for Loop Checks in Logic Programming , 1992, Theor. Comput. Sci..

[203]  Sandro Etalle,et al.  Termination of Well-Moded Programs , 1999, J. Log. Program..

[204]  Krzysztof R. Apt,et al.  Logic Programming , 1990, Handbook of Theoretical Computer Science, Volume B: Formal Models and Sematics.

[205]  Leon Sterling,et al.  The Art of Prolog , 1987, IEEE Expert.

[206]  Zoltan Somogyi,et al.  Termination Analysis for Mercury , 1997, SAS.

[207]  Donald E. Knuth.  Textbook Examples of Recursion , 1991, Artificial and Mathematical Theory of Computation.

[208]  André Mariën.  Improving the compilation of Prolog in the framework of the Warren Abstract Machine , 1993 .

[209]  Annalisa Bossi,et al.  Preserving Universal Termination through Unfold/Fold , 1994, ALP.

[210]  Michel Billaud,et al.  Simple Operational and Denotational Semantics for Prolog with Cut , 1990, Theor. Comput. Sci..

[211]  Sofie Verbaeten.  Termination Analysis for Abductive General Logic Programs , 1999, ICLP.

[212]  William F. Clocksin,et al.  Programming in Prolog , 1981, Springer Berlin Heidelberg.

[213]  Krzysztof R. Apt,et al.  Verification of Logic Programs with Delay Declarations , 1995, AMAST.

[214]  Giorgio Levi,et al.  How to transform an analyzer into a verifier , 2001, APPIA-GULP-PRODE.

[215]  Marc Bezem,et al.  Characterizing Termination of Logic Programs with Level Mappings , 1989, NACLP.

[216]  Peter J. Stuckey,et al.  Programming with Constraints: An Introduction , 1998 .

[217]  Dino Pedreschi,et al.  Verification of Logic Programs , 1999, J. Log. Program..

[218]  Giorgio Levi,et al.  Proving Program Properties, Symbolic Evaluation and Logical Procedural Semantics , 1975, MFCS.

[219]  Zohar Manna,et al.  A closer look at termination , 1975, Acta Informatica.

[220]  Alexander Serebrenik,et al.  Hasta-La-Vista: Termination Analyser for Logic Programs , 2003, WLPE.

[221]  Kenneth A. Bowen,et al.  A Meta-Level Extension of Prolog , 1985, SLP.

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

[223]  Nachum Dershowitz,et al.  Topics in Termination , 1993, RTA.

[224]  Xiaoping Jia,et al.  A generic approach of static analysis for detecting runtime errors in Java programs , 1999, Proceedings. Twenty-Third Annual International Computer Software and Applications Conference (Cat. No.99CB37032).

[225]  Stephen Muggleton,et al.  Learning Structure and Parameters of Stochastic Logic Programs , 2002, ILP.

[226]  Fausto Spoto,et al.  Operational and Goal-Independent Denotational Semantics for Prolog with Cut , 2000, J. Log. Program..

[227]  Jan Maluszynski,et al.  AND-Parallelism with Intelligent Backtracking for Annotated Logic Programs , 1985, SLP.

[228]  D. Pedreschi,et al.  Composition Operators for Logic Theories , 1990 .

[229]  R. N. Bol.  Generalizing completeness results for loop checks , 1990 .

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

[231]  Ivan A. Sag,et al.  Book Reviews: Head-driven Phrase Structure Grammar and German in Head-driven Phrase-structure Grammar , 1996, CL.

[232]  Annalisa Bossi,et al.  Termination of well-typed logic programs , 2001, PPDP '01.

[233]  K. Gödel.  Über formal unentscheidbare Sätze der Principia Mathematica und verwandter Systeme I , 1931 .

[234]  James H. Andrews,et al.  The witness properties and the semantics of the Prolog cut , 2002, Theory and Practice of Logic Programming.

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

[236]  Divesh Srivastava,et al.  Explaining Program Execution in Deductive Systems , 1993, DOOD.

[237]  R. Kowalski,et al.  Linear Resolution with Selection Function , 1971 .

[238]  Alexander Serebrenik,et al.  On Termination of Logic Programs with Floating Point Computations , 2002, SAS.

[239]  Wim Vanhoof,et al.  When Size Does Matter , 2001, LOPSTR.

[240]  Paul Tarau,et al.  Inference and Computation Mobility with Jinni , 1999, The Logic Programming Paradigm.

[241]  Kenneth A. Bowen.  New directions in logic programming , 1986, CSC '86.

[242]  Patrick Cousot,et al.  Verification of Embedded Software: Problems and Perspectives , 2001, EMSOFT.

[243]  John W. Lloyd,et al.  The Gödel programming language , 1994 .

[244]  Tim Sheard,et al.  Accomplishments and Research Challenges in Meta-programming , 2001, SAIG.

[245]  Robert A. Kowalski,et al.  The Semantics of Predicate Logic as a Programming Language , 1976, JACM.

[246]  V. S. Subrahmanian,et al.  Probabilistic Logic Programming , 1992, Inf. Comput..

[247]  Allen Van Gelder,et al.  Termination detection in logic programs using argument sizes (extended abstract) , 1991, PODS.

[248]  Sofie Verbaeten.  Static verification of compositionality and termination for logic programming languages , 2000 .

[249]  Salvatore Ruggieri.  exists-Universal termination of logic programs , 2001, Theor. Comput. Sci..

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