Results 1  10
of
14
Logic program specialisation through partial deduction: Control issues
 THEORY AND PRACTICE OF LOGIC PROGRAMMING
, 2002
"... Program specialisation aims at improving the overall performance of programs by performing source to source transformations. A common approach within functional and logic programming, known respectively as partial evaluation and partial deduction, is to exploit partial knowledge about the input. It ..."
Abstract

Cited by 66 (13 self)
 Add to MetaCart
Program specialisation aims at improving the overall performance of programs by performing source to source transformations. A common approach within functional and logic programming, known respectively as partial evaluation and partial deduction, is to exploit partial knowledge about the input. It is achieved through a wellautomated application of parts of the BurstallDarlington unfold/fold transformation framework. The main challenge in developing systems is to design automatic control that ensures correctness, efficiency, and termination. This survey and tutorial presents the main developments in controlling partial deduction over the past 10 years and analyses their respective merits and shortcomings. It ends with an assessment of current achievements and sketches some remaining research challenges.
Homeomorphic embedding for online termination of symbolic methods
 In The essence of computation, volume 2566 of LNCS
, 2002
"... Abstract. Wellquasi orders in general, and homeomorphic embedding in particular, have gained popularity to ensure the termination of techniques for program analysis, specialisation, transformation, and verification. In this paper we survey and discuss this use of homeomorphic embedding and clarify ..."
Abstract

Cited by 43 (7 self)
 Add to MetaCart
(Show Context)
Abstract. Wellquasi orders in general, and homeomorphic embedding in particular, have gained popularity to ensure the termination of techniques for program analysis, specialisation, transformation, and verification. In this paper we survey and discuss this use of homeomorphic embedding and clarify the advantages of such an approach over one using wellfounded orders. We also discuss various extensions of the homeomorphic embedding relation. We conclude with a study of homeomorphic embedding in the context of metaprogramming, presenting some new (positive and negative) results and open problems.
Verifying CTL Properties of Infinite State Systems by Specializing Constraint Logic Programs
, 2001
"... this paper we assume that a system makes transitions from states to states and its evolution can be formalized using a computation tree which is dened as follows. Given a system S and its initial state s 0 , the root of the computation tree for S is s 0 , and every node s i of the computation tree f ..."
Abstract

Cited by 28 (19 self)
 Add to MetaCart
this paper we assume that a system makes transitions from states to states and its evolution can be formalized using a computation tree which is dened as follows. Given a system S and its initial state s 0 , the root of the computation tree for S is s 0 , and every node s i of the computation tree for S has a child node s j i there exists in S a transition from state s i to state s j , called a successor state of s i . The set of all states of a system may be nite or innite. We assume that in every system for every state s i there exists at least one successor state
Verifying programs via iterated specialization
 Proc. PEPM ’13
, 2013
"... We present a method for verifying properties of imperative programs by using techniques based on the specialization of constraint logic programs (CLP). We consider a class of C programs with integer variables and we focus our attention on safety properties, stating that no error configuration can be ..."
Abstract

Cited by 12 (10 self)
 Add to MetaCart
(Show Context)
We present a method for verifying properties of imperative programs by using techniques based on the specialization of constraint logic programs (CLP). We consider a class of C programs with integer variables and we focus our attention on safety properties, stating that no error configuration can be reached from the initial configurations. We encode the interpreter of the language as a CLP program I, and we also encode the safety property to be verified as the negation of a predicate unsafe defined in I. Then, we specialize the CLP program I with respect to the given C program and the given initial and error configurations, with the objective of deriving a new CLP program Isp which either contains the fact unsafe (and in this case the C program is proved unsafe) or contains no clauses with head unsafe (and in this case the C program is proved safe). If Isp does not enjoy this property we iterate the specialization process with the objective of deriving a CLP program where we can prove unsafety or safety. During the various specializations we may apply different strategies for propagating information
Specialization with Clause Splitting for Deriving Deterministic Constraint Logic Programs
 In Proc. IEEE Conference on Systems, Man and Cybernetics, Hammamet
, 2002
"... The reduction of nondeterminism can increase efficiency when specializing programs. We consider constraint logic programs and we propose a technique which by making use of a new transformation rule, called clause splitting, allows us to generate efficient, specialized programs which are deterministi ..."
Abstract

Cited by 7 (5 self)
 Add to MetaCart
(Show Context)
The reduction of nondeterminism can increase efficiency when specializing programs. We consider constraint logic programs and we propose a technique which by making use of a new transformation rule, called clause splitting, allows us to generate efficient, specialized programs which are deterministic. We have applied our technique to the specialization of pattern matching programs.
Specialization with Constrained Generalization for Software Model Checking
"... Abstract. We present a method for verifying properties of imperative programs by using techniques based on constraint logic programming (CLP). We consider a simple imperative language, called SIMP, extended with a nondeterministic choice operator and we address the problem of checking whether or not ..."
Abstract

Cited by 4 (2 self)
 Add to MetaCart
(Show Context)
Abstract. We present a method for verifying properties of imperative programs by using techniques based on constraint logic programming (CLP). We consider a simple imperative language, called SIMP, extended with a nondeterministic choice operator and we address the problem of checking whether or not a safety property ϕ (that specifies that an unsafe configuration cannot be reached) holds for a SIMP program P. The operational semantics of the language SIMP is specified via an interpreter I written as a CLP program. The first phase of our verification method consists in specializing I with respect to P, thereby deriving a specialized interpreter IP. Then, we specialize IP with respect to the property ϕ and the input values of P, with the aim of deriving, if possible, a program whose least model is a finite set of constrained facts. To this purpose we introduce a novel generalization strategy which, during specialization, has the objecting of preserving the so called branching behaviour of the predicate definitions. We have fully automated our method and we have made its experimental evaluation on some examples taken from the literature. The evaluation shows that our method is competitive with respect to stateoftheart software model checkers. 1
Program verification via iterated specialization
 Science of Computer Programming
"... We present a method for verifying properties of imperative programs by using techniques based on the specialization of constraint logic programs (CLP). We consider a class of imperative programs with integer variables and we focus our attention on safety properties, stating that no error configurati ..."
Abstract

Cited by 4 (4 self)
 Add to MetaCart
(Show Context)
We present a method for verifying properties of imperative programs by using techniques based on the specialization of constraint logic programs (CLP). We consider a class of imperative programs with integer variables and we focus our attention on safety properties, stating that no error configuration can be reached from any initial configuration. We introduce a CLP program I that encodes the interpreter of the language, and also defines a predicate unsafe equivalent to the negation of the safety property to be verified. Then, we specialize the CLP program I with respect to the given imperative program and the given initial and error configurations, with the objective of deriving a new CLP program Isp that either contains the fact unsafe (and in this case the imperative program is proved unsafe) or contains no clauses with head unsafe (and in this case the imperative program is proved safe). If Isp does not enjoy this property we iterate the specialization process with the objective of deriving a CLP program where we can prove unsafety or safety. During the various specializations we may apply different strategies for propagating
VERIFYING INFINITE STATE SYSTEMS BY SPECIALIZING CONSTRAINT LOGIC PROGRAMS
"... We propose a method for the specification and the automated verification of temporal properties of infinite state reactive systems. Given a reactive system K and a formula ϕ of the branching time temporal logic CTL, we construct a locally stratified constraint logic program PK[ϕ] such that the syste ..."
Abstract

Cited by 3 (3 self)
 Add to MetaCart
(Show Context)
We propose a method for the specification and the automated verification of temporal properties of infinite state reactive systems. Given a reactive system K and a formula ϕ of the branching time temporal logic CTL, we construct a locally stratified constraint logic program PK[ϕ] such that the system K verifies ϕ if and only if prop ∈ M(PK[ϕ]), where prop is a predicate symbol defined in PK[ϕ] and M(PK[ϕ]) is the perfect model of PK[ϕ]. Then we check whether or not prop ∈ M(PK[ϕ]) by specializing the program PK[ϕ] w.r.t. prop and deriving a new program Psp containing either the fact prop ← (in which case the temporal formula ϕ is verified by the system) or no clause for prop (in which case the temporal formula ϕ is not verified by the system). Our specialization method makes use of: (i) a set of specialization rules that preserve the perfect model of constraint logic programs, and (ii) an automatic strategy that guides the application of these rules for deriving the specialized program Psp. Our strategy always terminates and is sound for verifying CTL formulas. Due to the undecidability of CTL formulas in the case of infinite state systems, our strategy is incomplete, that is, we may derive a specialized program Psp containing a clause for prop different from the fact prop ←. However, as indicated by the
Using Real Relaxations During Program Specialization
"... Abstract. We propose a program specialization technique for locally stratified CLP(Z) programs, that is, logic programs with linear constraints over the set Z of the integer numbers. For reasons of efficiency our technique makes use of a relaxation from integers to reals. We reformulate the familiar ..."
Abstract

Cited by 2 (2 self)
 Add to MetaCart
(Show Context)
Abstract. We propose a program specialization technique for locally stratified CLP(Z) programs, that is, logic programs with linear constraints over the set Z of the integer numbers. For reasons of efficiency our technique makes use of a relaxation from integers to reals. We reformulate the familiar unfold/fold transformation rules for CLP programs so that: (i) the applicability conditions of the rules are based on the satisfiability or entailment of constraints over the set R of the real numbers, and (ii) every application of the rules transforms a given program into a new program with the same perfect model constructed over Z. Then, we introduce a strategy which applies the transformation rules for specializing CLP(Z) programs with respect to a given query. Finally, we show that our specialization strategy can be applied for verifying properties of infinite state reactive systems specified by constraints over Z. 1
Transformational Verification of Parameterized Protocols Using Array Formulas
 In Proc. LOPSTR 2005
, 2005
"... Abstract. We propose a method for the specification and the automated verification of temporal properties of parameterized protocols. Our method is based on logic programming and program transformation. We specify the properties of parameterized protocols by using an extension of stratified logic ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
(Show Context)
Abstract. We propose a method for the specification and the automated verification of temporal properties of parameterized protocols. Our method is based on logic programming and program transformation. We specify the properties of parameterized protocols by using an extension of stratified logic programs. This extension allows premises of clauses to contain first order formulas over arrays of parameterized length. A property of a given protocol is proved by applying suitable unfold/fold transformations to the specification of that protocol. We demonstrate our method by proving that the parameterized Peterson's protocol among N processes, for any N≥2, ensures the mutual exclusion property. 1