Results 11  20
of
26
Program Derivation = Rules + Strategies
 Computational Logic: Logic Programming and Beyond (Essays in honour of Bob Kowalski, Part I), Lecture Notes in Computer Science 2407
, 2001
"... In a seminal paper [38] Prof. Robert Kowalski advocated the paradigm Algorithm = Logic + Control which was intended to characterize program executions. Here we want to illustrate the corresponding paradigm Program Derivation = Rules + Strategies which is intended to characterize program derivations, ..."
Abstract

Cited by 4 (2 self)
 Add to MetaCart
(Show Context)
In a seminal paper [38] Prof. Robert Kowalski advocated the paradigm Algorithm = Logic + Control which was intended to characterize program executions. Here we want to illustrate the corresponding paradigm Program Derivation = Rules + Strategies which is intended to characterize program derivations, rather than executions. During program execution, the Logic component guarantees that the computed results are correct, that is, they are true facts in the intended model of the given program, while the Control component ensures that those facts are derived in an efficient way. Likewise, during program derivation, the Rules component guarantees that the derived programs are correct and the Strategies component ensures that the derived programs are efficient.
A Transformation System for Modular CLP Programs
 Proceedings of the 12th International Conference on Logic Programming
, 1995
"... We propose a transformation system for CLP programs and modules. The framework is inspired by the one of Tamaki and Sato for pure logic programs [19]. Here, the use of CLP allows us to introduce some new operations such as splitting and constraint replacement. We provide two sets of applicability co ..."
Abstract

Cited by 4 (1 self)
 Add to MetaCart
(Show Context)
We propose a transformation system for CLP programs and modules. The framework is inspired by the one of Tamaki and Sato for pure logic programs [19]. Here, the use of CLP allows us to introduce some new operations such as splitting and constraint replacement. We provide two sets of applicability conditions. The first one guarantees that the original and the transformed programs have the same computational behavior, in terms of answer constraints. The second set contains more restrictive conditions that ensure compositionality: we prove that under these conditions the original and the transformed modules have the same answer constraints also when they are composed with other modules. As corollaries we obtain the correctness of both the modular and the nonmodular system w.r.t. the least model semantics. 1 Introduction As shown by a number of applications, programs transformation is a powerful methodology for the development and optimization of large programs. In this field, the unfold...
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
Automatic Derivation of Logic Programs by Transformation
 Course notes for ESSLLI
, 2000
"... We present the program transformation methodology for the automatic development of logic programs based on the rules + strategies approach. We consider both definite programs and normal programs and we present the basic transformation rules and strategies which are described in the literature. To il ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
We present the program transformation methodology for the automatic development of logic programs based on the rules + strategies approach. We consider both definite programs and normal programs and we present the basic transformation rules and strategies which are described in the literature. To illustrate the power of the program transformation approach we also give some examples of program development. Finally, we show how to use program transformations for proving properties of predicates and synthesizing programs from logical specifications.
A Folding Algorithm for Eliminating Existential Variables from Constraint Logic Programs
 IN: PROCEEDINGS OF THE 24TH INTERNATIONAL CONFERENCE ON LOGIC PROGRAMMING, ICLP’08 (M. GARCIA DE LA BANDA, E. PONTELLI, EDS.), LECTURE
"... The existential variables of a clause in a constraint logic program are the variables which occur in the body of the clause and not in its head. The elimination of these variables is a transformation technique which is often used for improving program efficiency and verifying program properties. We ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
(Show Context)
The existential variables of a clause in a constraint logic program are the variables which occur in the body of the clause and not in its head. The elimination of these variables is a transformation technique which is often used for improving program efficiency and verifying program properties. We consider a folding transformation rule which ensures the elimination of existential variables and we propose an algorithm for applying this rule in the case where the constraints are linear inequations over rational or real numbers. The algorithm combines techniques for matching terms modulo equational theories and techniques for solving systems of linear inequations. We show that an implementation of our folding algorithm performs well in practice.
Contextual Specialization of Constraint Logic Programs
 AGP99 Joint Conference on Declarative Programming
, 1999
"... We address the problem of specializing a constraint logic program w.r.t. a specific context of use. We consider constraints over a generic domain and we assume that the context of use of a program is specified by a constrained atom. We follow an approach based on transformation rules and strategies. ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
(Show Context)
We address the problem of specializing a constraint logic program w.r.t. a specific context of use. We consider constraints over a generic domain and we assume that the context of use of a program is specified by a constrained atom. We follow an approach based on transformation rules and strategies. We present a novel transformation rule, called contextual constraint replacement, to be combined with the traditional unfolding and folding rules. We show the correctness of the transformation rules w.r.t. least models and we present a general strategy for automating the application of these rules. We show through examples the power of our method and its superiority w.r.t. existing methods for partial deduction of constraint logic programs based on extensions of Lloyd and Shepherdson's approach.
Folding Transformation Rules for Constraint Logic Programs
"... Abstract. We consider the folding transformation rule for constraint logic programs. We propose an algorithm for applying the folding rule in the case where the constraints are linear equations and inequations over the rational or the real numbers. Basically, our algorithm consists in reducing a rul ..."
Abstract
 Add to MetaCart
(Show Context)
Abstract. We consider the folding transformation rule for constraint logic programs. We propose an algorithm for applying the folding rule in the case where the constraints are linear equations and inequations over the rational or the real numbers. Basically, our algorithm consists in reducing a rule application to the solution of one or more systems of linear equations and inequations. We also introduce two variants of the folding transformation rule. The first variant combines the folding rule with the clause splitting rule, and the second variant eliminates the existential variables of a clause, that is, those variables which occur in the body of the clause and not in its head. Finally, we present the algorithms for applying these variants of the folding rule. 1
A FOLDING RULE FOR ELIMINATING EXISTENTIAL VARIABLES FROM CONSTRAINT LOGIC PROGRAMS
, 2010
"... The existential variables of a clause in a constraint logic program are the variables which occur in the body of the clause and not in its head. The elimination of these variables is a transformation technique which is often used for improving program efficiency and verifying program properties. We ..."
Abstract
 Add to MetaCart
The existential variables of a clause in a constraint logic program are the variables which occur in the body of the clause and not in its head. The elimination of these variables is a transformation technique which is often used for improving program efficiency and verifying program properties. We consider a folding transformation rule which ensures the elimination of existential variables and we propose an algorithm for applying this rule in the case where the constraints are linear inequations over rational or real numbers. The algorithm combines techniques for matching terms modulo equational theories and techniques for solving systems of linear inequations. Through some examples we show that an implementation of our folding algorithm has a good performance in practice.
ESPRIT Basic Research project Acclaim  Final Report
, 1996
"... Interpretation Frameworks Partner Responsible. INRIA The work in this task was intented to propose an abstract interpretation framework for the family of Concurrent Constraint (cc) languages proposed by Saraswat. Our framework is based on a denotational semantics of concurrent constraint languages, ..."
Abstract
 Add to MetaCart
Interpretation Frameworks Partner Responsible. INRIA The work in this task was intented to propose an abstract interpretation framework for the family of Concurrent Constraint (cc) languages proposed by Saraswat. Our framework is based on a denotational semantics of concurrent constraint languages, where each agent is seen as a closure operator over the lattice defined by the ACCLAIM Final Report 33 constraint system. In this framework the closure operators are defined directly as functions over stores instead of defining them via the set of their fixpoints. This will make it possible to derive a practical algorithm reusing and only slightly modifying a reexecutionbased framework for Prolog. Deliverables due 2Q93. D3.1/1 D3.1/1 A report describing a framework for the abstract interpretation of cc languages. This deliverable will provide the basis for several applications to program analysis and optimisation. (INRIA, public report). Deliverables due 2Q95. None An extra deliverable o...