Results 1  10
of
17
Linear Objects: logical processes with builtin inheritance
, 1990
"... We present a new framework for amalgamating two successful programming paradigms: logic programming and objectoriented programming. From the former, we keep the declarative reading of programs. From the latter, we select two crucial notions: (i) the ability for objects to dynamically change their ..."
Abstract

Cited by 211 (6 self)
 Add to MetaCart
We present a new framework for amalgamating two successful programming paradigms: logic programming and objectoriented programming. From the former, we keep the declarative reading of programs. From the latter, we select two crucial notions: (i) the ability for objects to dynamically change their internal state during the computation; (ii) the structured representation of knowledge, generally obtained via inheritance graphs among classes of objects. We start with the approach, introduced in concurrent logic programming languages, which identifies objects with proof processes and object states with arguments occurring in the goals of a given process. This provides a clean, sideeffect free account of the dynamic behavior of objects in terms of the search tree  the only dynamic entity in logic programming languages. We integrate this view of objects with an extension of logic programming, which we call Linear Objects, based on the possibility of having multiple literals in the head of a program clause. This contains within itself the basis for a flexible form of inheritance, and maintains the constructive property of Prolog of returning definite answer substitutions as output of the proof of nonground goals. The theoretical background for Linear Objects is Linear Logic, a logic recently introduced to provide a theoretical basis for the study of concurrency. We also show that Linear Objects can be considered a constructive restriction of full Classical Logic. We illustrate the expressive power of Linear Objects compared to Prolog by several examples from the objectoriented domain, but we also show that it can be used to provide elegant solutions for problems arising in the standard style of logic programming.
Constraint Simplification Rules
, 1992
"... In current constraint logic programming systems, constraint solving is hardwired in a "black box". We are investigating the use of logic programs to define and implement constraint solvers 1 . The representation of constraint evaluation in the same formalism as the rest of the program g ..."
Abstract

Cited by 22 (4 self)
 Add to MetaCart
In current constraint logic programming systems, constraint solving is hardwired in a "black box". We are investigating the use of logic programs to define and implement constraint solvers 1 . The representation of constraint evaluation in the same formalism as the rest of the program greatly facilitates the prototyping, extension, specialization and combination of constraint solvers. In our approach, constraints are specified by definite clauses provided by a host language, while constraint evaluation is specified using multiheaded guarded clauses called constraint simplification rules (SiRs) 2 . SiRs define determinate conditional rewrite systems that express how conjunctions of constraints simplify. They have been used to encode a range of constraint solvers in our prototype implementation. Additionally, the definite clauses specifying a constraint can be evaluated in the host language, if the constraint is "callable" and no SiR can simplify it further. In this way our appr...
A Process Algebra for Synchronous Concurrent Constraint Programming
, 1996
"... Concurrent constraint programming is classically based on asynchronous communication via a shared store. Synchrony can be achieved by forcing concurrently running ask and tell primitives to synchronise on "new common information". This paper outlines this framework, called Scc, and develo ..."
Abstract

Cited by 14 (6 self)
 Add to MetaCart
Concurrent constraint programming is classically based on asynchronous communication via a shared store. Synchrony can be achieved by forcing concurrently running ask and tell primitives to synchronise on "new common information". This paper outlines this framework, called Scc, and develops an algebraic semantics for it. The Scc framework is shown to share similarities with both the traditional concurrent constraint setting and algebraic languages like CCS but also to have major differences which requires the use of new techniques in formulating the algebraic semantics. Among these are the introduction of an auxiliary communication operator to handle the treatment of synchrony and the extension of the concept of cylindric algebras by allowing the hiding of the empty set of variables in order to permit local computations. More importantly, new axioms have been introduced to describe our variants of the tell and ask primitives. The algebraic semantics is proved to be sound and complete ...
Concurrency and Plan Generation in a Logic Programming Language With a Sequential Operator
"... In this paper we define a logic programming language, called SMR, whose main computational mechanism is multiset rewriting. It features a guarded choice capability and, above all, a sequential andlike operator. The language is defined starting from a core language, LM, a subset of Andreoli and Pares ..."
Abstract

Cited by 11 (2 self)
 Add to MetaCart
In this paper we define a logic programming language, called SMR, whose main computational mechanism is multiset rewriting. It features a guarded choice capability and, above all, a sequential andlike operator. The language is defined starting from a core language, LM, a subset of Andreoli and Pareschi's LO, which is directly derived from linear logic. LM is minimal in a certain sense we will specify. The language SMR admits a translation into LM through a uniform "continuation" mechanism. We show how SMR could be interesting in two diverse areas, viz. concurrency and plan generation. Keywords Logic programming, linear logic, concurrency, planning. 1 Introduction Linear logic [13, 10] is widely recognized as a logic of concurrency, meaning that the proof theory underlying it faithfully represents some aspects of concurrent computations. Recently it has been pointed out that the same logic is suited for carefully modeling concepts of action and change in planning problems [19, 16]. In...
Concurrent Logic Programming as Uniform Linear Proofs
 Algebraic and Logic Programming
, 1994
"... We describe a formalism based on the proof theory of linear logic, whose aim is to specify concurrent computations and whose language restriction (as compared to other linear logic languages) provides a simpler operational model that can lead to a more practical language core. The fragment is proved ..."
Abstract

Cited by 8 (1 self)
 Add to MetaCart
We describe a formalism based on the proof theory of linear logic, whose aim is to specify concurrent computations and whose language restriction (as compared to other linear logic languages) provides a simpler operational model that can lead to a more practical language core. The fragment is proved to be an abstract logic programming language, that is any sequent can be derived by uniform proofs. The resulting class of computations can be viewed in terms of multiset rewriting and is reminiscent of the computations arising in the Chemical Abstract Machine and in the Gamma model. The fragment makes it possible to give a logic foundation to existing extensions of Horn clause logic, such as Generalized Clauses, whose declarative semantics is based on an ad hoc construction. Programs and goals can declaratively be characterized by a suitable instance of the phase semantics of linear logic. A canonical phase model is associated to every program. Such a model gives a full characterization of...
New Versions of Ask and Tell for Synchronous Communication in Concurrent Constraint Programming
, 1995
"... Concurrent constraint programming is classically based on asynchronous communication via a shared store. This paper presents new versions of the ask and tell primitives which features synchronicity. Our approach is based on the idea of telling new information just in the case that a concurrently run ..."
Abstract

Cited by 8 (6 self)
 Add to MetaCart
Concurrent constraint programming is classically based on asynchronous communication via a shared store. This paper presents new versions of the ask and tell primitives which features synchronicity. Our approach is based on the idea of telling new information just in the case that a concurrently running process is asking for it. The new primitives are shown to be simple yet expressive enough to code significant problems. Two semantics for them are proposed. The first one is of an operational nature and formalises computations by means of a transition system. It is not compositional. This problem is addressed in another semantics which benefits from hypotheses made both on concurrent processes and the state of the store rather than on its successive updates. 1 Introduction Generalising former proposals for concurrent logic programming languages (Concurrent Prolog, Parlog, GHC, . . . ), concurrent constraint programming has naturally inherited two of their main features: the asynchronou...
Communicating Clauses: towards Synchronous Communication in Contextual Logic Programming
 Proceedings of the Joint International Conference and Symposium on Logic Programming
, 1992
"... Communicating clauses are proposed as an extension to contextual logic programming aiming at specifying the synchronous communication between agents, described here as units. The expressiveness of the extended framework is argued through the coding of producer/consumer schemes and several applicatio ..."
Abstract

Cited by 8 (2 self)
 Add to MetaCart
Communicating clauses are proposed as an extension to contextual logic programming aiming at specifying the synchronous communication between agents, described here as units. The expressiveness of the extended framework is argued through the coding of producer/consumer schemes and several applications combining the logic and objectoriented styles of programming. Operational and declarative semantics are designed for the new framework. The operational semantics rests on a derivation relation stating how agents can be evaluated under contextual and synchronization constraints. The declarative semantics extend the classical model and fixed point theory to take these constraints into account. As suggested, an effort has been made to keep these semantics in the main streams of logic programming semantics. However, the contextual and synchronization constraints raise new problems for which fresh solutions are proposed. 1 Introduction Recently, contexts have been introduced in logic program...
Distributed Logic Objects: A Fragment of Rewriting Logic and its Implementation
"... This paper presents a logic language (called Distributed Logic Objects, DLO for short) that supports objects, messages and inheritance. The operational semantics of the language is given in terms of rewriting rules acting upon the (possibly distributed) state of the system. In this sense, the logic ..."
Abstract

Cited by 5 (0 self)
 Add to MetaCart
This paper presents a logic language (called Distributed Logic Objects, DLO for short) that supports objects, messages and inheritance. The operational semantics of the language is given in terms of rewriting rules acting upon the (possibly distributed) state of the system. In this sense, the logic underlying the language is Rewriting Logic. In the paper we discuss the implementation of this language on distributed memory MIMD architectures, and we describe the advantages achieved in terms of flexibility, scalability and load balancing. In more detail, the implementation is obtained by translating logic objects into a concurrent logic language based on multihead clauses, taking advantage from its distributed implementation on a massively parallel architecture. In the underlying implementation, objects are clusters of processes, objects' state is represented by logical variables, messagepassing communication between objects is performed via multihead clauses, and inheritance is mappe...
A Language Framework for Group Based MultiAgent Systems: GroupLog
, 1999
"... We describe a language providing two main program structuring levels: agents and groups. Agents are the execution units of a GroupLog program. Each agent possesses a hidden internal behavior and a welldefined communications interface and its behavior is defined by a set of logical rules. Groups sup ..."
Abstract

Cited by 2 (2 self)
 Add to MetaCart
(Show Context)
We describe a language providing two main program structuring levels: agents and groups. Agents are the execution units of a GroupLog program. Each agent possesses a hidden internal behavior and a welldefined communications interface and its behavior is defined by a set of logical rules. Groups support the organization of the agents space into distinct sets, each set acting like a metaagent with welldefined internal behavior and communications interface. In the paper we give an informal presentation of the GroupLog language and illustrate its use through an example.
Using mobility and blackboards to support a multiparadigm model oriented to distributed processing
 In 13th Symposium on Computer Architecture and High Performance Computing (SBACPAD 2001
, 2001
"... ..."