10,362 research outputs found
A foundation for higher-order concurrent constraint programming
We present the gamma-calculus, a computational calculus for higher-order concurrent programming. The calculus can elegantly express higher-order functions (both eager and lazy) and concurrent objects with encapsulated state and multiple inheritance. The primitives of the gamma-calculus are logic variables, names, procedural abstraction, and cells. Cells provide a notion of state that is fully compatible with concurrency and constraints. Although it does not have a dedicated communication primitive, the gamma-calculus can elegantly express one-to-many and many-to-one communication. There is an interesting relationship between the gamma-calculus and the pi-calculus: The gamma-calculus is subsumed by a calculus obtained by extending the asynchronous and polyadic pi-calculus with logic variables. The gamma-calculus can be extended with primitives providing for constraint-based problem solving in the style of logic programming. A such extended gamma-calculus has the remarkable property that it combines first-order constraints with higher-order programming
Observational equivalences for linear logic CC languages
Linear logic Concurrent Constraint programming (LCC) is an extension of
concurrent constraint programming (CC) where the constraint system is based on
Girard's linear logic instead of the classical logic. In this paper we address
the problem of program equivalence for this programming framework. For this
purpose, we present a structural operational semantics for LCC based on a label
transition system and investigate different notions of observational
equivalences inspired by the state of art of process algebras. Then, we
demonstrate that the asynchronous \pi-calculus can be viewed as simple
syntactical restrictions of LCC. Finally we show LCC observational equivalences
can be transposed straightforwardly to classical Concurrent Constraint
languages and Constraint Handling Rules, and investigate the resulting
equivalences.Comment: 17 page
Universal Concurrent Constraint Programing: Symbolic Semantics and Applications to Security
International audienceWe introduce the Universal Timed Concurrent Constraint Programming (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 pi-calculus: Generation and communication of private channels or 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
Towards Races in Linear Logic
Process calculi based in logic, such as DILL and CP, provide a
foundation for deadlock-free concurrent programming, but exclude
non-determinism and races. HCP is a reformulation of CP which addresses a
fundamental shortcoming: the fundamental operator for parallel composition from
the -calculus does not correspond to any rule of linear logic, and
therefore not to any term construct in CP.
We introduce non-deterministic HCP, which extends HCP with a novel account of
non-determinism. Our approach draws on bounded linear logic to provide a
strongly-typed account of standard process calculus expressions of
non-determinism. We show that our extension is expressive enough to capture
many uses of non-determinism in untyped calculi, such as non-deterministic
choice, while preserving HCP's meta-theoretic properties, including deadlock
freedom
Towards Races in Linear Logic
Process calculi based in logic, such as DILL and CP, provide a
foundation for deadlock-free concurrent programming, but exclude
non-determinism and races. HCP is a reformulation of CP which addresses a
fundamental shortcoming: the fundamental operator for parallel composition from
the -calculus does not correspond to any rule of linear logic, and
therefore not to any term construct in CP.
We introduce non-deterministic HCP, which extends HCP with a novel account of
non-determinism. Our approach draws on bounded linear logic to provide a
strongly-typed account of standard process calculus expressions of
non-determinism. We show that our extension is expressive enough to capture
many uses of non-determinism in untyped calculi, such as non-deterministic
choice, while preserving HCP's meta-theoretic properties, including deadlock
freedom
Towards Races in Linear Logic
Part 1: Computational ModelsInternational audienceProcess calculi based in logic, such as DILL and CP, provide a foundation for deadlock-free concurrent programming, but exclude non-determinism and races. HCP is a reformulation of CP which addresses a fundamental shortcoming: the fundamental operator for parallel composition from the -calculus does not correspond to any rule of linear logic, and therefore not to any term construct in CP. We introduce HCP, which extends HCP with a novel account of non-determinism. Our approach draws on bounded linear logic to provide a strongly-typed account of standard process calculus expressions of non-determinism. We show that our extension is expressive enough to capture many uses of non-determinism in untyped calculi, such as non-deterministic choice, while preserving HCP ’s meta-theoretic properties, including deadlock freedom
Focusing in Asynchronous Games
Game semantics provides an interactive point of view on proofs, which enables
one to describe precisely their dynamical behavior during cut elimination, by
considering formulas as games on which proofs induce strategies. We are
specifically interested here in relating two such semantics of linear logic, of
very different flavor, which both take in account concurrent features of the
proofs: asynchronous games and concurrent games. Interestingly, we show that
associating a concurrent strategy to an asynchronous strategy can be seen as a
semantical counterpart of the focusing property of linear logic
Sequentiality vs. Concurrency in Games and Logic
Connections between the sequentiality/concurrency distinction and the
semantics of proofs are investigated, with particular reference to games and
Linear Logic.Comment: 35 pages, appeared in Mathematical Structures in Computer Scienc
- …