Resource-Passing Concurrent Programming

Theoretical Computer Science, 1993

Foundations of Artificial Intelligence, 2006

This chapter addresses the integration of constraints and search into programming languages from three different points of views. It first focuses on the use of constraints to model combinatorial optimization problem and to easily implement search procedures, then it considers the use of constraints for supporting concurrent computations and finally turns to the use of constraints to enable open implementations of constraints solvers.

Research Report Series of Iasi Cnr Rome Italy, 2012

We address the problem of the automatic synthesis of concurrent programs within a framework based on Answer Set Programming (ASP). Every concurrent program to be synthesized is specified by providing both the behavioural and the structural properties it should satisfy. Behavioural properties, such as safety and liveness properties, are specified by using formulas of the Computation Tree Logic, which are encoded as a logic program. Structural properties, such as the symmetry of processes, are also encoded as a logic program. Then, the program which is the union of these two encoding programs, is given as input to an ASP system which returns as output a set of answer sets. Finally, each answer set is decoded into a synthesized program that, by construction, satisfies the desired behavioural and structural properties. 4. proofs of the results presented in the paper, and the ASP source code of our synthesis procedure. 2. Preliminaries Let us recall some basic notions and terminology we will use. We will present: (i) the syntax of (a variant of) the guarded commands [10], which we use for defining concurrent programs, (ii) some basic notions of group theory, which are required for defining symmetric concurrent programs, and (iii) some fundamental concepts of Computation Tree Logic and of Answer Set Programming, which we use for our synthesis method. 2.1. Guarded commands The guarded commands we consider are defined from the following two basic sets: (i) variables, v in Var , each ranging over a finite domain D v , and (ii) guards, g in Guard , of the form: g ::= true | false | v = d | ¬ g | g 1 ∧ ∧ g 2 , with v ∈ Var and d ∈ D v. We also have the following derived sets whose definitions are mutually recursive: (iii) commands, c in Command , of the form: c ::= skip | v := d | c 1 ; c 2 | if gc fi | do gc od , where ';' denotes the sequential composition of commands which is associative, and (iv) guarded commands, gc in GCommand , of the form: gc ::= g → c | gc 1 gc 2 , where ' ' denotes the parallel composition of guarded commands which is associative and commutative. The operational semantics of commands can be described in an informal way as follows. skip does nothing. v := d stores the value d in the location of the variable v. In order to execute c 1 ; c 2 the command c 1 is executed first, and then the command c 2 is executed. In order to execute if gc 1. .. gc n fi, with n ≥ 1, one of the guarded commands g → c in {gc 1 ,. .. , gc n } whose guard g evaluates to true, is chosen, and then c is executed; otherwise, if no guard of a guarded command in {gc 1 ,. .. , gc n } evaluates to true, then the whole command if. .. fi terminates with failure. In order to execute do gc 1. .. gc n od, with n ≥ 1, one of the guarded commands g → c in {gc 1 ,. .. , gc n } whose guard g evaluates to true, is chosen, then c is executed and the whole command do. .. od is executed again; otherwise, if no guard of a guarded command in {gc 1 ,. .. , gc n } evaluates to true, then the execution proceeds with the next command. The formal semantics of commands will be given in the next section. 2.2. Groups A group G is a pair S , • , where S is a set and • is a binary operation on S satisfying the following axioms: (i) ∀x, y ∈ S. x•y ∈ S, (ii) ∀x , y, z ∈ S. (x •y)•z = x •(y •z), (iii) ∃e ∈ S. ∀x ∈ S. e•x = x•e = x, and (iv) ∀x ∈ S. ∃y ∈ S. x•y = y•x = e. The element e is the identity of the group G and the cardinality of S is the order of the group G. For any x ∈ S, for any n ≥ 0, we write x n to denote the term x•.. .•x with n occurrences of x. We stipulate that x 0 is e. A group G = S , • is said to be cyclic iff there exists an element x ∈ S, called a generator, such that S = {x n | n ≥ 0}. We denote by Perm(S) the set of all permutations on the set S, that is, the set of all bijections from S to S. Perm(S) is a group whose operation • is function composition and the identity e is the identity permutation, denoted id. Given a finite set S, the order of a permutation p in Perm(S) is the smallest natural number n such that p n = id. 5. 2.3. Computation Tree Logic Computation Tree Logic (CTL) is a propositional branching time temporal logic [8]. The underling time structure is a tree of states. Every state denotes an instant in time and may have many successor states. There are quantifiers over paths of the tree: A (for all paths) and E (for some path), which are used for specifying properties that hold for all paths or for some path, respectively. Together with these quantifiers, there are temporal operators such as: X (next state), F (eventually), G (globally), and U (until), which are used for specifying properties that hold in the states along paths of the tree. Their formal semantics will be given below. Given a finite nonempty set Elem of elementary propositions ranged over by p, the syntax of CTL formulas ϕ is as follows: ϕ ::= p | ϕ 1 ∧ ∧ ϕ 2 | ¬ϕ | EX ϕ | EG ϕ | E[ϕ 1 U ϕ 2 ] We introduce the following abbreviations: (i) true for ϕ ∨ ∨ ¬ϕ, where ϕ is any CTL formula, (ii) false for ¬true, (iii) ϕ 1 ∨ ∨ ϕ 2 for ¬(¬ϕ 1 ∧ ∧ ¬ϕ 2), (iv) EFϕ for E[true U ϕ] (v) AG ϕ for ¬EF ¬ϕ, (vi) AF ϕ for ¬EG ¬ϕ, (vii) A[ ϕ 1 Uϕ 2 ] for ¬E[¬ϕ 2 U (¬ϕ 1 ∧ ∧ ¬ϕ 2)] ∧ ∧ AF ϕ 2 , and (viii) AX ϕ for ¬EX ¬ ϕ. The semantics of CTL is provided by a Kripke structure K = S, S 0 , R, λ , where: (i) S is a finite set of states, (ii) S 0 ⊆ S is a set of initial states, (iii) R ⊆ S × S is a total transition relation (thus, ∀u ∈ S. ∃v ∈ S. u, v ∈ R), and (iv) λ : S → P(Elem) is a total labelling function that assigns to every state s ∈ S a subset λ(s) of the set Elem. A path π in K from a state s 0 is an infinite sequence s 0 , s 1 ,. .. of states such that, for all i ≥ 0, s i , s i+1 ∈ R. The fact that a CTL formula ϕ holds in a state s of a Kripke structure K will be denoted by K, s ϕ. For any CTL formula ϕ and state s, we define the relation K, s ϕ as follows: K,s p iff p ∈ λ(s) K,s ¬ ϕ iff K,s ϕ does not hold K,s ϕ 1 ∧ ∧ ϕ 2 iff K,s ϕ 1 and K,s ϕ 2 K,s EX ϕ iff there exists s, t ∈ R such that K,t ϕ K,s E[ϕ 1 U ϕ 2 ] iff there exists a path s 0 ,s 1 ,s 2 ,.. . in K with s 0 = s such that for some i ≥ 0, K,s i ϕ 2 and for all 0 ≤ j < i, K,s j ϕ 1 K,s EG ϕ iff there exists a path s 0 ,s 1 ,s 2 ,.. . in K with s 0 = s such that for all i ≥ 0, K,s i ϕ.

2018

Artificial Intelligence, 1999

Proceedings of the 18th …, 1991

Concurrent constraint programming Sar89,SR90] is a simple and powerful model of concurrent computation based on the notions of store-asconstraint and process as information transducer. The store-as-valuation conception of von Neumann computing is replaced by the notion that the store is a constraint (a nite representation of a possibly in nite set of valuations) which provides partial information about the possible values that variables can take. Instead of \reading" and \writing" the values of variables, processes may now ask (check if a constraint is entailed by the store) and tell (augment the store with a new constraint). This is a very general paradigm which subsumes (among others) nondeterminate data-ow and the (concurrent)(constraint) logic programming languages. This paper develops the basic ideas involved in giving a coherent semantic account of these languages. Our rst contribution is to give a simple and general formulation of the notion that a constraint system is a system of partial information (a la the information systems of Scott). Parameter passing and hiding is handled by borrowing ideas from the cylindric algebras of Henkin, Monk and Tarski to introduce diagonal elements and \cylindri cation" operations (which mimic the projection of information induced by existential quanti ers).

Lecture Notes in Computer Science, 2010

The development of powerful techniques for proving termination of rewriting modulo a set of equational axioms is essential when dealing with rewriting logic-based programming languages like CafeOBJ, Maude, ELAN, OBJ, etc. One of the most important techniques for proving termination over a wide range of variants of rewriting (strategies) is the dependency pair approach. Several works have tried to adapt it to rewriting modulo associative and commutative (AC) equational theories, and even to more general theories. However, as we discuss in this paper, no appropriate notion of minimality (and minimal chain of dependency pairs) which is well-suited to develop a dependency pair framework has been proposed to date. In this paper we carefully analyze the structure of infinite rewrite sequences for rewrite theories whose equational part is any combination of associativity and/or commutativity axioms, which we call A∨C-rewrite theories. Our analysis leads to a more accurate and optimized notion of dependency pairs through the new notion of stably minimal term. We then develop a suitable dependency pair framework for proving termination of A∨C-rewrite theories. of variables. The subterm at position p of t is denoted as t| p , and t[s] p is the term t with the subterm at position p replaced by s.

Pdpta, 1996

Artificial Intelligence, 2010