Skip to content
Free planNo credit card requiredStart writing
AI for Research home
AI for Research home
Dashboard
Sign inGet started

Search 250 million research papers

Read the abstract, see who wrote it and who cites it, and get the citation in APA, MLA, Chicago or Harvard.

About 159 papers for “Concurrent constraint logic programming”

Testing Concurrent Reactive Systems with Constraint Logic Programming

Heiko Lötzbeyer, Alexander Pretschner, Er Pretschner · 2000

In the domain of reactive systems, work on validation has mainly focused on verifying specifications. A complementary problem consists of validating an implementation w.r.t. its specification (testing). We propose a way to compute test sequences on the basis of system as well as test case specifications that is based on Constraint Logic Programming. Furthermore, we provide a clear terminology for concepts within the testing context.

Cited by 0

Closures and Modules within Linear Logic Concurrent Constraint Programming

Rémy Haemmerlé, François Fages, Sylvain Soliman et al. · 2008

Abstract. There are two somewhat contradictory ways of looking at modules in a given programming language. On the one hand, module systems are largely independent of the particulars of programming languages. On the other hand, the module constructs may interfere with the programming constructs, and may be redundant with the other scope mechanisms of a specific programming language, such as closures for instance. There is therefore a need to unify the programming concepts that are similar, and retain a minimum number of essential constructs to avoid arbitrary programming choices. In this paper, we realize this aim in the framework of linear logic concurrent constraint programming (LCC) languages. We first show how declarations and closures can be internalized as agents in a variant of LCC with the bang operator of Linear Logic for which we provide precise operational and logical semantics. Then we show how a complete module system can be represented within LCC, and prove for it a code protection property. Finally we study the instanciation of this module system to constraint logic programming, and conclude on the generality of this scheme for programming languages with logical variables. 1

Cited by 0

A Concurrent Operational Semantics for Constraint Functional Logic Programming

Rafael del Vado Vírseda, Fernando Pérez Morente, Marcos Miguel García Toledo · DROPS (Schloss Dagstuhl – Leibniz Center for Informatics) · 2012

In this paper we describe a sound and complete concurrent operational semantics for constraint functional logic programming languages which allows to model declarative applications in which the interaction between demand-driven narrowing and constraint solving helps to prune the search space, leading to shorter goal derivations. We encode concurrency into the generic CFLP(D) scheme, a uniform foundation for the operational semantics of constraint functional logic programming systems parameterized by a constraint solver over the given domain D. In this concurrent version of the CFLP(D) scheme, goal solving processes can be executed concurrently and cooperate together to perform their specific tasks via demand-driven narrowing and declarative residuation guided by constrained definitional trees, constraint solving, and communication by synchronization on logical variables.

Cited by 0Open access

Concurrent Constraint Programming and Non-Commutative Linear Logic (Extended Abstract)

Paul Ruet, Francois Fages · 1996

This paper presents a precise connection between a non-commutative version of intuitionistic linear logic (INLL) and concurrent constraint programming (cc). The contribution of this paper is twofold: ffl on the one hand, we refine existing logical characterizations of operational aspects of concurrent constraint programming, by providing a logical interpretation of finer observable properties of cc programs, namely successes and suspensions. ffl on the other ha...

Cited by 0

A Process Calculus for Universal Concurrent Constraint Programming: Semantics, Logic and Application

Carlos Olarte · 2008

(utcc) process calculus; a generalisation of Timed Concurrent Constraint Programming. The utcc calculus allows for the specification of mobile behaviours in the sense of Milner’s π-calculus: Generation and communication of private links. We first endow utcc with an operational semantics and then with a symbolic semantics to deal with problematic operational aspects involving infinitely many substitutions and divergent internal computations. The novelty of the symbolic semantics is to use temporal constraints to represent finitely infinitely-many substitutions. We also show that utcc has a strong connection with Pnueli’s Temporal Logic. This connection can be used to prove reachability properties of utcc processes. As a compelling example, we use utcc to exhibit the secrecy flaw of the Needham-Schroeder security protocol. 1

Cited by 0

IQ: Towards Incremental Query Processing in Non-Deterministic Concurrent Constraint Logic Programming

J. H. M. Lee, H.F. Leung · 1994

Van Emden's incremental queries addresses the inadequacy of current Prolog-style querying mechanism in most logic programming systems for interactive problem-solving. There has been little published work on efficient implementation of incremental queries and all work is on sequential systems. In the context of constraint logic programming, incremental queries involves adding new constraints or deleting old ones from a query after a solution is found. This paper presents an implementation scheme IQ of incremental queries in Constraint Pandora, which defines a class of non-deterministic concurrent constraint logic programming languages. Constraint Pandora is essentially a concurrent version of the CLP scheme. We use Van Hentenryck and Le Provost's scheme (VHLP-scheme hereafter), which is based on oracles and re-execution, as a starting point. Re-execution is costly in concurrent languages, in which process creation and inter-process communications are common operations. The IQ scheme ret...

Cited by 0

Nordic Journal of Computing 9(2002), 145–188. TEMPORAL CONCURRENT CONSTRAINT PROGRAMMING: DENOTATION, LOGIC AND APPLICATIONS

Mogens Nielsen, Frank D. Valencia · 2008

Abstract. The tcc model is a formalism for reactive concurrent constraint programming. We present a model of temporal concurrent constraint programming which adds to tcc the capability of modeling asynchronous and nondeterministic timed behavior. We call this tcc extension the ntcc calculus. We also give a denotational semantics for the strongestpostcondition of ntcc processes and, based on this semantics, we develop a proof system for linear-temporal properties of these processes. The expressiveness of ntcc is illustrated by modeling cells, timed systems such as RCX controllers, multi-agent systems such as the Predator/Prey game, and musical applications such as generation of rhythms patterns and controlled improvisation. CR Classification: F.3.1, F.3.2, D.1.3, D.3.3 Key words: temporal concurrent constraint programming, calculi for concurrency, program

Cited by 0

AKL - A Multiparadigm Programming Language

Sverker Janson · 1994

This thesis reports on an investigation into principles for combining the constraint solving and don't know nondeterministic capabilities of Prolog and the constraint logic programming languages with the process-describing capabilities of concurrent logic languages such as GHC. The result, AKL, is a coherent language supporting multiple programming paradigms, such as concurrent, object-oriented, functional, logic, and constraint programming. In addition, AKL offers a large potential for automatic parallel execution.

Cited by 0

Expressiveness and Complexity of Concurrent Constraint Programming: a Finite Model Theoretic Approach

F. Fages, Sylvain Soliman, Victor Vianu · 1998

We study the expressiveness and complexity of concurrent constraint programming languages over finite domains. We establish strong connections between these languages and query languages in finite model theory. The bridge to finite model theory yields new (and sometimes quite surprising) results on the expressiveness and complexity of concurrent constraint languages, including several powerful normal forms. These results provide new insight into the impact of various semantics and features of concurrent constraint programming languages on their expressiveness and complexity. 1 Introduction Concurrent constraint programming (CC) [Sar87] emerged as a combination of concurrent logic programming and constraint logic programming (CLP) [JL87]. The basic idea is the one of a set of agents communicating through a shared store of constraints, that are logical formulas on the unknowns of the problem. Each agent can either write a constraint to the store (tell operation), or synchronize with oth...

Cited by 0

Design and Implementation of the High-Level Specification Language CSP(LP)

Michaël Leuschel · ePrints Soton (University of Southampton) · 2001

We describe practical experiences of using a logic programming based approach to model and reason about concurrent systems. We argue that logic programming is a good foundation for developing, prototyping, animating new specification languages. In particular, we present the new high-level specification language CSP(LP), unifying CSP with concurrent (constraint) logic programming, and which can be used to formally reason both about logical and concurrent aspects of critical systems.

Cited by 16

High-Level Implementations of Constraint Handling Rules

Thom Frühwirth, Pascal Brisset · 1995

Constraint handling rules (CHRs) are a high level logic concurrent committedchoice language for writing constraint systems. Rapid prototyping of novel applications for constraint techniques is encouraged by the high level of abstraction and declarative nature of CHRs. In this paper we describe basic principles of implementing CHRs in logic programming languages and show how they actually have been implemented in the CHRs library of ECL i PS e , ECRC's constraint logic programming platform. All three types of multi-headed CHRs can be transformed into single-headed simplification rules. These rules correspond to guarded rules used in typical logic concurrent committed-choice languages. We then show how to implement these guarded rules in sequential (constraint) logic programming languages. The report contains three appendices involving a generic example and its translation. 1 Introduction Constraint handling rules (CHRs) [Fru92, Fru94, FrHa95, Fru95] are a high-level language extens...

Cited by 0

Education

2012

Formal verification of sequential and concurrent software, constraint logic programming, invariant generation, constraint solving, decision procedures, and automated theorem proving

Cited by 0