We consider the termination/non-termination property of a class of loops. Such loops are commonly... more We consider the termination/non-termination property of a class of loops. Such loops are commonly used abstractions of real program pieces. Second-order logic is a convenient language to express non-termination. Of course, such property is generally undecidable. However, by restricting the language to known decidable cases, we exhibit new classes of loops, the non-termination of which is decidable. We present a bunch of examples.
A new operation on languages, called the full quotient, is defined. The closure property for regu... more A new operation on languages, called the full quotient, is defined. The closure property for regular languages under this operation is established. An algorithm is given that constructs a finite automaton recognizing the full quotient of two regular languages. The time complexity of the algorithm is proportional to the product of the number of states of the input automata. Several additional properties of the full quotient are investigated. @ 1998 Elsevier Science B.V.
In this paper, we present an approach to non-termination of term rewriting systems inspired by a ... more In this paper, we present an approach to non-termination of term rewriting systems inspired by a technique that was designed in the context of logic programming. Our method is based on a classical unfolding operation together with semi-unification and is independent of a particular reduction strategy. We also describe a technique to reduce the explosion of rules caused by the unfolding process. The analyser that we have implemented is able to solve most of the non-terminating examples in the Termination Problem Data Base.
We define an operational semantics for a large part of the Android platform, encompassing the Dal... more We define an operational semantics for a large part of the Android platform, encompassing the Dalvik bytecode but also, and more importantly, the inter-component communication mechanism used inside Android applications. This semantics is intended to provide a formal basis for the development of static analyses that consider the complex flow of information exposed by the cooperating components of Android applications.
In this paper, we present a fully automatizable approach to detecting loops in standard term rewr... more In this paper, we present a fully automatizable approach to detecting loops in standard term rewriting. Our method is based on semi-unification and an unfolding operation which processes both forwards and backwards and considers variable subterms. We also describe a technique to reduce the explosion of rules caused by the unfolding process. The idea is to eliminate from the set of unfoldings some rules that are estimated as useless for detecting loops. This is done by an approximation which consists in pruning the left-hand or right-hand side of the rules used to unfold. The analyser that we have implemented is able to solve most of the examples from the Termination Competition'07 that do not terminate due to a loop.
We present a new syntactic criterion for the automatic detection of non-termination in an abstrac... more We present a new syntactic criterion for the automatic detection of non-termination in an abstract setting that encompasses a simplified form of term rewriting and logic programming.
This paper introduces a class of graphs associated to linear bounded machines. It is shown that t... more This paper introduces a class of graphs associated to linear bounded machines. It is shown that this class is closed, up to observational equivalence, under synchronized product. The first-order theory of these graphs is investegated and shown to be undecidable. The latter result extends to any logic in which the existence of sinks may be stated.
Concolic testing is a popular dynamic validation technique that can be used for both model checki... more Concolic testing is a popular dynamic validation technique that can be used for both model checking and automatic test case generation. We have recently introduced concolic testing in the context of logic programming. In contrast to previous approaches, the key ingredient in this setting is a technique to generate appropriate run-time goals by considering all possible ways an atom can unify with the heads of some program clauses. This is called "selective" unification. In this paper, we show that the existing algorithm is not complete and explore different alternatives in order to have a sound and complete algorithm for selective unification.
HAL (Le Centre pour la Communication Scientifique Directe), 2004
We present a static analysis technique for non-termination inference of logic programs. Our frame... more We present a static analysis technique for non-termination inference of logic programs. Our framework relies on an extension of the subsumption test, where some specific argument positions can be instantiated while others are generalized. We give syntactic criteria to statically identify such argument positions from the text of a program. Atomic left looping queries are generated bottom-up from selected subsets of the binary unfoldings of the program of interest. We propose a set of correct algorithms for automating the approach. Then, non-termination inference is tailored to attempt proofs of optimality of left termination conditions computed by a termination inference tool. An experimental evaluation is reported and the analysers can be tried online at http://www.univ-reunion.fr/~gcc. When termination and non-termination analysis produce complementary results for a logic procedure, then with respect to the leftmost selection rule and the language used to describe sets of atomic queries, each analysis is optimal and together, they induce a characterization of the operational behavior of the logic procedure.
HAL (Le Centre pour la Communication Scientifique Directe), Nov 5, 2018
In this paper, we reconsider the unfolding-based technique that we have introduced previously for... more In this paper, we reconsider the unfolding-based technique that we have introduced previously for detecting loops in standard term rewriting. We improve it by guiding the unfolding process, using distinguished positions in the rewrite rules. This results in a depth-first computation of the unfoldings, whereas the original technique was breadth-first. We have implemented this new approach in our tool NTI and compared it to the previous one on a bunch of rewrite systems. The results we get are promising (better times, more successful proofs).
On the one hand, termination analysis of logic programs is now a fairly established research topi... more On the one hand, termination analysis of logic programs is now a fairly established research topic within the logic programming community. On the other hand, non-termination analysis seems to remain a much less attractive subject. If we divide this line of research into two kinds of approaches: dynamic versus static analysis, this paper belongs to the latter. It proposes a criterion for detecting non-terminating atomic queries with respect to binary CLP rules, which strictly generalizes our previous works on this subject. We give a generic operational definition and an implemented logical form of this criterion. Then we show that the logical form is correct and complete with respect to the operational definition.
HAL (Le Centre pour la Communication Scientifique Directe), May 27, 2002
In this paper, we present an approach to non-termination inference of logic programs. Our framewo... more In this paper, we present an approach to non-termination inference of logic programs. Our framework relies on an extension of the Lifting Theorem, where some specific argument positions can be instantiated while others are generalized. Atomic left looping queries are then generated bottom-up from selected subsets of the binary unfoldings of the program of interest. Then non-termination inference is tailored to attempt proofs of optimality of left termination conditions computed by a termination inference tool. For each class of atomic queries not covered by a termination condition, the aim is to ensure the existence of one query from this class which leads to an infinite search tree. When termination and non-termination analysis produce complementary results for a logic procedure, they induce a characterization of the operational behavior of the logic procedure with respect to the left most selection rule and the language used to describe sets of atomic queries. RÉSUMÉ. Dans cet article, nous présentons une technique d'inférence de conditions de nontermination de programmes logiques. Notre travail repose sur une extension du "Lifting Theorem", où des positions d'argument spécifiques peuvent être instanciées alors que les autres sont généralisées. Des requêtes atomiques qui bouclent à gauche sont alors générées de façon ascendante à partir de sous-ensembles des dépliages binaires du programme traité. L'inférence de non-terminaison est alors utilisée pour tester l'optimalité de conditions de terminaison gauche générées par un outil d'inférence de terminaison. Pour chaque classe de requêtes atomiques non couverte par une condition de terminaison, nous tentons d'assurer l'existence d'une requête de cette classe qui mène à un arbre de recherche infini. Quand les analyses de terminaison et de non-terminaison produisent des résultats complémentaires pour une procédure logique, on obtient une caractérisation du comportement opérationnel de la procédure par rapport à la règle de sélélection gauche et au langage utilisé pour décrire les ensembles de requêtes atomiques.
HAL (Le Centre pour la Communication Scientifique Directe), Mar 1, 2010
It is important to prove that supposedly terminating programs actually terminate, particularly if... more It is important to prove that supposedly terminating programs actually terminate, particularly if those programs must be run on critical systems or downloaded into a client such as a mobile phone. Although termination of computer programs is generally undecidable, it is possible and useful to prove termination of a large, nontrivial subset of the terminating programs. In this paper we present our termination analyser for sequential Java bytecode, based on a program property called path-length. We describe the analyses which are needed before the path-length can be computed, such as sharing, cyclicity and aliasing. Then we formally define the path-length analysis and prove it correct w.r.t. a reference denotational semantics of the bytecode. We show that a constraint logic program P CLP can be built from the result of the path-length analysis of a Java bytecode program P and formally prove that if P CLP terminates then also P terminates. Hence a termination prover for constraint logic programs can be applied to prove the termination of P. We conclude with some discussion of the possibilities and limitations of our approach. Ours is the first existing termination analyser for Java bytecode dealing with any kind of data structures dynamically allocated on the heap and which does not require any help or annotation on the part of the user.
ACM Transactions on Programming Languages and Systems, Mar 1, 2010
It is important to prove that supposedly terminating programs actually terminate, particularly if... more It is important to prove that supposedly terminating programs actually terminate, particularly if those programs must be run on critical systems or downloaded into a client such as a mobile phone. Although termination of computer programs is generally undecidable, it is possible and useful to prove termination of a large, nontrivial subset of the terminating programs. In this article, we present our termination analyzer for sequential Java bytecode, based on a program property called path-length. We describe the analyses which are needed before the path-length can be computed such as sharing, cyclicity, and aliasing. Then we formally define the path-length analysis and prove it correct with respect to a reference denotational semantics of the bytecode. We show that a constraint logic program P CLP can be built from the result of the path-length analysis of a Java bytecode program P and formally prove that if P CLP terminates, then P also terminates. Hence a termination prover for constraint logic programs can be applied to prove the termination of P. We conclude with some discussion of the possibilities and limitations of our approach. Ours is the first existing termination analyzer for Java bytecode dealing with any kind of data structures dynamically allocated on the heap and which does not require any help or annotation on the part of the user.
Denotational static analysis of Java bytecode has a nice and clean compositional definition and a... more Denotational static analysis of Java bytecode has a nice and clean compositional definition and an efficient implementation with binary decision diagrams. But it models only the functional i.e., input/output behaviour of a program P , not enough if one needs P 's internal behaviours i.e., from the input to some internal program points. We overcome this limitation with a technique used up to now for logic programs only. It adds new magic blocks of code to P , whose functional behaviours are the internal behaviours of P. We prove this transformation correct with an operational semantics. We define an equivalent denotational semantics, whose denotations for the magic blocks are hence the internal behaviours of P. We implement our transformation and instantiate it with abstract domains modelling sharing of two variables and non-cyclicity of variables. We get a static analyser for full Java bytecode that is faster and scales better than another operational pair-sharing analyser and a constraint-based pointer analyser.
We consider the termination/non-termination property of a class of loops. Such loops are commonly... more We consider the termination/non-termination property of a class of loops. Such loops are commonly used abstractions of real program pieces. Second-order logic is a convenient language to express non-termination. Of course, such property is generally undecidable. However, by restricting the language to known decidable cases, we exhibit new classes of loops, the non-termination of which is decidable. We present a bunch of examples.
A new operation on languages, called the full quotient, is defined. The closure property for regu... more A new operation on languages, called the full quotient, is defined. The closure property for regular languages under this operation is established. An algorithm is given that constructs a finite automaton recognizing the full quotient of two regular languages. The time complexity of the algorithm is proportional to the product of the number of states of the input automata. Several additional properties of the full quotient are investigated. @ 1998 Elsevier Science B.V.
In this paper, we present an approach to non-termination of term rewriting systems inspired by a ... more In this paper, we present an approach to non-termination of term rewriting systems inspired by a technique that was designed in the context of logic programming. Our method is based on a classical unfolding operation together with semi-unification and is independent of a particular reduction strategy. We also describe a technique to reduce the explosion of rules caused by the unfolding process. The analyser that we have implemented is able to solve most of the non-terminating examples in the Termination Problem Data Base.
We define an operational semantics for a large part of the Android platform, encompassing the Dal... more We define an operational semantics for a large part of the Android platform, encompassing the Dalvik bytecode but also, and more importantly, the inter-component communication mechanism used inside Android applications. This semantics is intended to provide a formal basis for the development of static analyses that consider the complex flow of information exposed by the cooperating components of Android applications.
In this paper, we present a fully automatizable approach to detecting loops in standard term rewr... more In this paper, we present a fully automatizable approach to detecting loops in standard term rewriting. Our method is based on semi-unification and an unfolding operation which processes both forwards and backwards and considers variable subterms. We also describe a technique to reduce the explosion of rules caused by the unfolding process. The idea is to eliminate from the set of unfoldings some rules that are estimated as useless for detecting loops. This is done by an approximation which consists in pruning the left-hand or right-hand side of the rules used to unfold. The analyser that we have implemented is able to solve most of the examples from the Termination Competition'07 that do not terminate due to a loop.
We present a new syntactic criterion for the automatic detection of non-termination in an abstrac... more We present a new syntactic criterion for the automatic detection of non-termination in an abstract setting that encompasses a simplified form of term rewriting and logic programming.
This paper introduces a class of graphs associated to linear bounded machines. It is shown that t... more This paper introduces a class of graphs associated to linear bounded machines. It is shown that this class is closed, up to observational equivalence, under synchronized product. The first-order theory of these graphs is investegated and shown to be undecidable. The latter result extends to any logic in which the existence of sinks may be stated.
Concolic testing is a popular dynamic validation technique that can be used for both model checki... more Concolic testing is a popular dynamic validation technique that can be used for both model checking and automatic test case generation. We have recently introduced concolic testing in the context of logic programming. In contrast to previous approaches, the key ingredient in this setting is a technique to generate appropriate run-time goals by considering all possible ways an atom can unify with the heads of some program clauses. This is called "selective" unification. In this paper, we show that the existing algorithm is not complete and explore different alternatives in order to have a sound and complete algorithm for selective unification.
HAL (Le Centre pour la Communication Scientifique Directe), 2004
We present a static analysis technique for non-termination inference of logic programs. Our frame... more We present a static analysis technique for non-termination inference of logic programs. Our framework relies on an extension of the subsumption test, where some specific argument positions can be instantiated while others are generalized. We give syntactic criteria to statically identify such argument positions from the text of a program. Atomic left looping queries are generated bottom-up from selected subsets of the binary unfoldings of the program of interest. We propose a set of correct algorithms for automating the approach. Then, non-termination inference is tailored to attempt proofs of optimality of left termination conditions computed by a termination inference tool. An experimental evaluation is reported and the analysers can be tried online at http://www.univ-reunion.fr/~gcc. When termination and non-termination analysis produce complementary results for a logic procedure, then with respect to the leftmost selection rule and the language used to describe sets of atomic queries, each analysis is optimal and together, they induce a characterization of the operational behavior of the logic procedure.
HAL (Le Centre pour la Communication Scientifique Directe), Nov 5, 2018
In this paper, we reconsider the unfolding-based technique that we have introduced previously for... more In this paper, we reconsider the unfolding-based technique that we have introduced previously for detecting loops in standard term rewriting. We improve it by guiding the unfolding process, using distinguished positions in the rewrite rules. This results in a depth-first computation of the unfoldings, whereas the original technique was breadth-first. We have implemented this new approach in our tool NTI and compared it to the previous one on a bunch of rewrite systems. The results we get are promising (better times, more successful proofs).
On the one hand, termination analysis of logic programs is now a fairly established research topi... more On the one hand, termination analysis of logic programs is now a fairly established research topic within the logic programming community. On the other hand, non-termination analysis seems to remain a much less attractive subject. If we divide this line of research into two kinds of approaches: dynamic versus static analysis, this paper belongs to the latter. It proposes a criterion for detecting non-terminating atomic queries with respect to binary CLP rules, which strictly generalizes our previous works on this subject. We give a generic operational definition and an implemented logical form of this criterion. Then we show that the logical form is correct and complete with respect to the operational definition.
HAL (Le Centre pour la Communication Scientifique Directe), May 27, 2002
In this paper, we present an approach to non-termination inference of logic programs. Our framewo... more In this paper, we present an approach to non-termination inference of logic programs. Our framework relies on an extension of the Lifting Theorem, where some specific argument positions can be instantiated while others are generalized. Atomic left looping queries are then generated bottom-up from selected subsets of the binary unfoldings of the program of interest. Then non-termination inference is tailored to attempt proofs of optimality of left termination conditions computed by a termination inference tool. For each class of atomic queries not covered by a termination condition, the aim is to ensure the existence of one query from this class which leads to an infinite search tree. When termination and non-termination analysis produce complementary results for a logic procedure, they induce a characterization of the operational behavior of the logic procedure with respect to the left most selection rule and the language used to describe sets of atomic queries. RÉSUMÉ. Dans cet article, nous présentons une technique d'inférence de conditions de nontermination de programmes logiques. Notre travail repose sur une extension du "Lifting Theorem", où des positions d'argument spécifiques peuvent être instanciées alors que les autres sont généralisées. Des requêtes atomiques qui bouclent à gauche sont alors générées de façon ascendante à partir de sous-ensembles des dépliages binaires du programme traité. L'inférence de non-terminaison est alors utilisée pour tester l'optimalité de conditions de terminaison gauche générées par un outil d'inférence de terminaison. Pour chaque classe de requêtes atomiques non couverte par une condition de terminaison, nous tentons d'assurer l'existence d'une requête de cette classe qui mène à un arbre de recherche infini. Quand les analyses de terminaison et de non-terminaison produisent des résultats complémentaires pour une procédure logique, on obtient une caractérisation du comportement opérationnel de la procédure par rapport à la règle de sélélection gauche et au langage utilisé pour décrire les ensembles de requêtes atomiques.
HAL (Le Centre pour la Communication Scientifique Directe), Mar 1, 2010
It is important to prove that supposedly terminating programs actually terminate, particularly if... more It is important to prove that supposedly terminating programs actually terminate, particularly if those programs must be run on critical systems or downloaded into a client such as a mobile phone. Although termination of computer programs is generally undecidable, it is possible and useful to prove termination of a large, nontrivial subset of the terminating programs. In this paper we present our termination analyser for sequential Java bytecode, based on a program property called path-length. We describe the analyses which are needed before the path-length can be computed, such as sharing, cyclicity and aliasing. Then we formally define the path-length analysis and prove it correct w.r.t. a reference denotational semantics of the bytecode. We show that a constraint logic program P CLP can be built from the result of the path-length analysis of a Java bytecode program P and formally prove that if P CLP terminates then also P terminates. Hence a termination prover for constraint logic programs can be applied to prove the termination of P. We conclude with some discussion of the possibilities and limitations of our approach. Ours is the first existing termination analyser for Java bytecode dealing with any kind of data structures dynamically allocated on the heap and which does not require any help or annotation on the part of the user.
ACM Transactions on Programming Languages and Systems, Mar 1, 2010
It is important to prove that supposedly terminating programs actually terminate, particularly if... more It is important to prove that supposedly terminating programs actually terminate, particularly if those programs must be run on critical systems or downloaded into a client such as a mobile phone. Although termination of computer programs is generally undecidable, it is possible and useful to prove termination of a large, nontrivial subset of the terminating programs. In this article, we present our termination analyzer for sequential Java bytecode, based on a program property called path-length. We describe the analyses which are needed before the path-length can be computed such as sharing, cyclicity, and aliasing. Then we formally define the path-length analysis and prove it correct with respect to a reference denotational semantics of the bytecode. We show that a constraint logic program P CLP can be built from the result of the path-length analysis of a Java bytecode program P and formally prove that if P CLP terminates, then P also terminates. Hence a termination prover for constraint logic programs can be applied to prove the termination of P. We conclude with some discussion of the possibilities and limitations of our approach. Ours is the first existing termination analyzer for Java bytecode dealing with any kind of data structures dynamically allocated on the heap and which does not require any help or annotation on the part of the user.
Denotational static analysis of Java bytecode has a nice and clean compositional definition and a... more Denotational static analysis of Java bytecode has a nice and clean compositional definition and an efficient implementation with binary decision diagrams. But it models only the functional i.e., input/output behaviour of a program P , not enough if one needs P 's internal behaviours i.e., from the input to some internal program points. We overcome this limitation with a technique used up to now for logic programs only. It adds new magic blocks of code to P , whose functional behaviours are the internal behaviours of P. We prove this transformation correct with an operational semantics. We define an equivalent denotational semantics, whose denotations for the magic blocks are hence the internal behaviours of P. We implement our transformation and instantiate it with abstract domains modelling sharing of two variables and non-cyclicity of variables. We get a static analyser for full Java bytecode that is faster and scales better than another operational pair-sharing analyser and a constraint-based pointer analyser.
Uploads
Papers by Étienne Payet