Concurrent constraint logic programming: Difference between revisions

Revision as of 17:43, 22 March 2006

Revision as of 18:02, 22 March 2006

Line 1:

'''Concurrent constraint logic programming''' is a version of [[constraint logic programming]] aimed at programming [[concurrent process]]es rather than solving [[constraint satisfaction problem]]s. Goals in constraint logic programming are evaluated concurrently; a concurrent process is therefore programmed as the evaluation of a goal by the [[Interpreter (computing)|interpreter]].

Syntactically, concurrent constraints logic programs are similar to non-concurrent programs, the only exception being that clauses includes ''guards'', which are constraints that may block the applicability of the clause under some conditions. Semantically, concurrent constraint logic programming differs from its non-concurrent versions because a goal evaluation is intended to realize a concurrent process rather than finding a solution to a problem. Most notably, this difference affects how the interpreter behaves when more than one clause is applicable: non-concurrent constraint logic programming [[Recursion (computing)|recursively]] tries all clauses; concurrent constraint logic programming chooses only one. This is the most evident effect of an intended ''directionality'' of the interpreter, which never revise a choice it has previously taken. Other effects of this are the semantical possibility of having a goal that cannot be proved while the whole evaluation does not fail, and a particular way for equating a goal and a clause head.

[[Constraint handling rules]] can be seen as a form of concurrent constraint logic programming, but are used for programming a constraint simplificator or solver rather than concurrent processes.

==Description==

Line 25 ⟶ 27:

An extension to the syntax and semantics of concurrent logic programming is the ''atomic tell''. When the interpreter uses a clause, its guard is added to the constraint store. However, also added are the constraints of the body. Due to committement to this clause, the interpreter does not backtrack if the constraints of the body are inconsistent with the store. This condition can be avoided by the use of atomic tell, which is a variant in which the clause contain a sort of "second guard" that is only checked for consistency. Such a clause is written <code>H :- G:D|B</code>. This clause is used to rewrite a literal only if <code>G</code> is entailed by the constraint store and <code>D</code> is consistent with it. In this case, both <code>G</code> and <code>D</code> are added to the constraint store.

==History==

Concurrent constraint logic programming initiates at the end of the 1980s, when some principles of concurrent logic programming was integrated into constraint logic programming by [[Michael J. Maher]]. The theoretical properties of concurrent constraint logic programming were later studied by various authors, such as [[Vijay A. Saraswat]].

==References==

Line 55 ⟶ 61:

| doi=10.1016/0743-1066(94)90033-7

}}

[[Category:Constraint satisfaction]]