Feature Structures and Path Congruences. The discussion of abstract feature structures raises a historical difficulty. While I do not dispute that the full theoretical investigation of feature structures modulo renaming is correctly attributed to Moshier, the idea of representing renaming classes by equivalence relations over paths seems an obvious variant of the representation of such classes as deductively closed sets of path equations in Pereira and Shieber's account (1984) of the semantics of PATR-II, which is further explored in Shieber's dissertation (1989).

Concurrent constraint programming [Sar89,SR90] is a sim-ple and powerful model of concurrent computation based on the notions of store-as-constraint and process as information transducer. The store-as-valuation conception of von Neu-mann computing is replaced by the notion that the store is a constraint (a finite representation of a possibly infinite 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) nonde-terminate data-flow and the (concurrent) (constraint) logic programming languages. This paper develops the basic ideas involved in giving a coherent semantic account of these languages. Our first con-tribution is to give a simple and general formulation of the notion that a constraint system is a system of partial infor-mation (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 “cylindrification ” operations (which mimic the projection of information induced by existential quantifiers). The se;ond contribution is to introduce the notion of determinate concurrent constraint programming languages. The combinators treated are ask, tell, parallel composition, hiding and recursion. We present a simple model for this language based on the specification-oriented methodology of [OH86]. The crucial insight is to focus on observing the resting points of a process—those stores in which the pro-cess quiesces without producing more information. It turns out that for the determinate language, the set of resting points of a process completely characterizes its behavior on all inputs, since each process can be identified with a closure operator over the underlying constraint system. Very nat-ural definitions of parallel composition, communication and hiding are given. For example, the parallel composition of two agents can be characterized by just the intersection of the sets of constraints associated with them. We also give a complete axiomatization of equality in this model, present

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...

The standard mathematical approaches to topology, point-set topology and algebraic topology, treat points as the fundamental, undefined entities, and construct extended spaces as sets of points with additional structure imposed on them. Point-set topology in particular generalises the concept of a `space' far beyond its intuitive meaning. Even algebraic topology, which concentrates on spaces built out of `cells' topologically equivalent to n-dimensional discs, concerns itself chiefly with rather abstract reasoning concerning the association of algebraic structures with particular spaces, rather than the kind of topological reasoning which is required in everyday life, or which might illuminate the metaphorical use of topological concepts such as `connection' and `boundary'. This paper explores an alternative to these approaches, RCC theory, which takes extended spaces (`regions') rather than points as fundamental. A single relation, C (x; y) (read `Region x connects with reg...

The introduction of concurrency complicates the already difficult task of large-scale programming. Concurrent object-oriented languages provide a mechanism, encapsulation, for managing the increased complexity of large-scale concurrent programs, thereby reducing the difficulty of large scale concurrent programming. In particular, fine-grained object-oriented approaches provide modularity through encapsulation while exposing large degrees of concurrency. Though fine-grained concurrent object-oriented languages are attractive from a programming perspective, they have historically suffered from poor efficiency. The goal of the Concert project is to develop portable, efficient implementations of finegrained concurrent object-oriented languages. Our approach incorporates careful program analysis and information management at every stage from the compiler to the runtime system. In this document, we outline the basic elements of the Concert approach. In particular, we discuss progr...

Machines Jean-Marc Andreoli, Paolo Ciancarini and Remo Pareschi European Computer Industry Research Centre Abstract In this paper, we introduce the metaphor of Interaction Abstract Machines (IAMs), in the same vein of such metaphors as the Chemical Abstract Machine. The main point about IAMs is in allowing interactions among independent, locally defined subsystems --- a crucial requirement for capturing the global behavior of open systems. IAMs amalgamate dual concepts in distributed problem solving, such as blackboards and broadcast communication, which are exploited to account for, respectively, the tight integration and the loose integration of system components. The formal counterpart for the IAM metaphor can be found in the computational model of Linear Objects (LO), whose aim is the abstract modeling of concurrent agent-oriented computations and whose operational semantics is given in terms of the proof theory of Linear Logic, a framework recently introduced to provide a theoretical account for the notion of (inter)action.

Abstract not found

We present a very simple and powerful framework for indeterminate, asynchronous, higher-order computation based on the formula-as-agent and proof-ascomputation interpretation of (higher-order) linear logic [Gir87]. The framework significantly refines and extends the scope of the concurrent constraint programming paradigm [Sar89] in two fundamental ways: (1) by allowing for the consumption of information by agents it permits a direct modelling of (indeterminate) state change in a logical framework, and (2) by admitting simply-typed -terms as dataobjects, it permits the construction, transmission and application of (abstractions of) programs at run-time. Much more dramatically, however, the framework can be seen as presenting higher-order (and if desired, constraint-enriched) versions of a variety of other asynchronous concurrent systems, including the asynchronous ("input guarded") fragment of the (first-order) ß-calculus, Hewitt's actors formalism, (abstract forms of) Gelernter's Lin...

Concurrent processes can be used both for programming computation and for programming storage. Previous implementations of Flat GHC, however, have been tuned for computation-intensive programs, and perform poorly for storage-intensive programs (such as programs implementing reconfigurable data structures using processes and streams) and demand-driven programs. This paper proposes an optimization technique for programs in which processes are almost always suspended. The technique compiles unification for data transfer into message passing. Instead of reducing the number of process switching operations, the technique optimizes the cost of each process switching operation and reduces the number of cons operations for data buffering.

. An appropriate combination of symbolic and numeric solvers often makes it possible to solve problems that none of these solvers can tackle alone. In this paper, we specify a cooperative architecture which allows using concurrently heterogeneous solvers when handling constraints over the reals. This architecture is based upon agents that communicate via asynchronous message passing. Agents are synchronized when a failure or a success occurs. Disjunctive constraints are handled by backtracking. Operational semantics and terminating conditions of such systems are discussed. Implementation issues are addressed. We end the presentation by several examples and give some computational results from a first prototype. 1 Introduction 1.1 Motivation Many industrial applications can be modeled by a set of constraints defined over the reals (e.g., financial applications, thermal flow problems, electro-mechanical engineering problems) . These systems of constraints are usually non-linear or even...