Synchronous programming (Berry (1989)) is a powerful approach to programming reactive systems. Following the idea that "processes are relations extended over time" (Abramsky (1993)), we propose a simple but powerful model for timed, determinate computation, extending the closure-operator model for untimed concurrent constraint programming (CCP). In (Saraswat et al. 1994a) we had proposed a model for this called tcc--- here we extend the model of tcc to express strong time-outs: if an event A does not happen through time t, cause event B to happen at time t. Such constructs arise naturally in practice (e.g. in modeling transistors) and are supported in synchronous programming languages. The fundamental conceptual difficulty posed by these operations is that they are nonmonotonic. We provide a compositional semantics to the non-monotonic version of concurrent constraint programming (Default cc) obtained by changing the underlying logic from intuitionistic logic to Reiter's default logic...

) Vineet Gupta Radha Jagadeesan Prakash Panangaden y vgupta@mail.arc.nasa.gov radha@cs.luc.edu prakash@cs.mcgill.ca Caelum Research Corporation Dept. of Math. and Computer Sciences School of Computer Science NASA Ames Research Center Loyola University--Lake Shore Campus McGill University Moffett Field CA 94035, USA Chicago IL 60626, USA Montreal, Quebec, Canada Abstract This paper describes a stochastic concurrent constraint language for the description and programming of concurrent probabilistic systems. The language can be viewed both as a calculus for describing and reasoning about stochastic processes and as an executable language for simulating stochastic processes. In this language programs encode probability distributions over (potentially infinite) sets of objects. We illustrate the subtleties that arise from the interaction of constraints, random choice and recursion. We describe operational semantics of these programs (programs are run by sampling random choices), deno...

. We extend cc to allow the specification of a discrete probability distribution for random variables. We demonstrate the expressiveness of pcc by synthesizing combinators for default reasoning. We extend pcc uniformly over time, to get a synchronous reactive probabilistic programming language, Timed pcc. We describe operational and denotational models for pcc (and Timed pcc). The key feature of the denotational model(s) is that parallel composition is essentially set intersection. We show that the denotational model of pcc (resp. Timed pcc) is conservative over cc (resp. tcc). We also show that the denotational models are fully abstract for an operational semantics that records probability information. 1 Introduction Concurrent constraint programming(CCP, [Sar93]) is an approach to computation which uses constraints for the compositional specification of concurrent systems. It replaces the traditional notion of a store as a valuation of variables with the notion of a store as a cons...

A central problem in extending the von Neumann architecture to petaflop computers with millions of hardware threads and with a shared memory is defining the memory model [Lam79,AG95,APP99]. Such a model must specify the behavior of concurrent (conditional) reads and writes to the same memory locations. We present a simple, general framework for the specification of memory models based on an abstract machine that uses sets of (interdependent) order and value constraints to communicate between threads and main memory. The separation of order constraints allows a parametric treatment of different order consistency models such as sequential consistency, location consistency, happens-before consistency (HB-consistency), etc. The use of value constraints allows a simple formulation of the semantics of concurrent dependent reads and writes in the presence of look-ahead and speculative computation. Memory is permitted to specify exactly those linkings (mappings from read

Abstract. We present the natural confluence of higher-order hereditary Harrop formulas (HH formulas) as developed concretely in λProlog, Constraint Logic Programming (CLP, [JL87]), and Concurrent Constraint Programming (CCP, [Sar93]) as a fragment of (intuitionistic, higher-order) logic. The combination is motivated by the need for a simple executable, logical presentation for static and dynamic semantics of modern programming languages. The power of HH formulas is needed for higher-order abstract syntax, and the power of constraints is needed to naturally abstract the underlying domain of computation. Underpinning this combination is a sound and complete operational interpretation of a two-sided sequent presentation of (a large fragment of) intuitionistic logic in terms of behavioral testing of concurrent systems. Formulas on the left hand side of a sequent style presentation are viewed as a system of concurrent agents, and formulas on the right hand side as tests against this evolving system. The language permits recursive definitions of agents and tests, allows tests to augment the system being tested and allows agents to be contingent on the success of a test. We present a condition on proofs, operational derivability (OD), and show that the operational semantics generates only operationally derivable proofs. We show that a sequent in this logic has a proof iff it has an operationally derivable proof. 1

. Concurrent Constraint Programming (CCP) is a powerful computation model for concurrencyobtained by internalizing the notion of computation via deduction over (first-order) systems of partial information (constraints). In [SRP91] a semantics for indeterminate CCP was given via sets of bounded trace operators; this was shown to be fully abstract with respect to observing all possible quiescent stores (= final states) of the computation. Bounded trace operators constitute a certain class of (finitary) "invertible" closure operators over a downward closed sublattice. Theycanbe thought of as generated via the grammar: t ::= c j c ! t j ct where c ranges over primitive constraints, is conjunction and ! intuitionistic implication. We motivate why it is interesting to consider as observable a "causality" relation on the store: what is observed is not just the conjunction of constraints deposited in the store, but also the causal dependencies between these constraints --- what constraints w...

This paper describes jcc, an integration of the timed default concurrent constraint programming framework [16] (Timed Default cc) into JAVA [7].

This paper presents a model for the Sprint AERCam, a beachball sized robotic camera that floats around in the cargo bay of the Space Shuttle, allowing the astronauts and ground mission control to have an additional view of the task they are trying to accomplish. It has a self contained propulsion system, giving it the capability to maneuver with six degrees of freedom. We present a model for the AERCam written in Hybrid cc, an extension of cc programming for modeling continuous/discrete systems. We modeled both the dynamics and control of the AERCam in Hybrid cc, and interfaced this model with an animation interface which allows a user to interact with the model in real-time. 1 Introduction This paper presents a model for the Sprint AERCam, an Autonomous EVA Robotic Camera[Phi97]. The AERCam is a beachball sized camera (see Figure 1), that floats around in the shuttle bay, allowing the astronauts inside and outside the shuttle and ground mission control to have an additional view of ...

Hybrid cc is a constraint programming language suited for modeling, controlling and simulating hybrid systems, i.e. systems with continuous and discrete state changes. The language extends the concurrent constraint programming framework with default reasoning and combinators for programming continuous behavior. The most important constraint systems used in Hybrid cc are nonlinear equations and ordinary differential equations over intervals. The interval constraints are crucial in that many modeling problems are only partially specified. We describe the implementation of the Hybrid cc interpreter and constraint solvers, and evaluate the performance using some example programs.

ions j mm --- Applications j j --- Constants j x --- Lambda variables j X --- Variables (Resources) q ::= r ; m ---Primitive Resource (1.7) The only "constraint" related to semantic projections is the primitive resource r ; m. Unlike constraints discussed above, such an atom is not allowed to be replicated freely; it is a "linear" atom, discussed below. Such an atom entails only itself; that is r ; m ` a iff a j r ; m. 3 Because of the use of universal quantification (discussed below), unification problems of the form m = m 0 may arise, requiring higher-order unification to be performed. Higher-order unification is undecidable (?). However, as in all 3 Two lambda terms are considered equivalent if they are inter-convertible using ff\Gamma; fi \Gamma and j-conversion. Concurrent constraint programming 15 the previous examples, the use of higher-order unification in LFG is extremely limited. In essence, it is used only for "pattern-matching" against linear terms (terms with...