7 research outputs found
A Reflective Higher-order Calculus
AbstractThe π-calculus is not a closed theory, but rather a theory dependent upon some theory of names. Taking an operational view, one may think of the π-calculus as a procedure that when handed a theory of names provides a theory of processes that communicate over those names. This openness of the theory has been exploited in π-calculus implementations, where ancillary mechanisms provide a means of interpreting of names, e.g. as tcp/ip ports. But, foundationally, one might ask if there is a closed theory of processes, i.e. one in which the theory of names arises from and is wholly determined by the theory of processes.Here we present such a theory in the form of an asynchronous message-passing calculus built on a notion of quoting. Names are quoted processes, and as such represent the code of a process, a reification of the syntactic structure of the process as an object for process manipulation. Name- passing in this setting becomes a way of passing the code of a process as a message. In the presence of a dequote operation, turning the code of a process into a running instance, this machinery yields higher-order characteristics without the introduction of process variables.As is standard with higher-order calculi, replication and/or recursion is no longer required as a primitive operation. Somewhat more interestingly, the introduction of a process constructor to dynamically convert a process into its code is essential to obtain computational completeness, and simultaneously supplants the function of the ν operator. In fact, one may give a compositional encoding of the ν operator into a calculus featuring dynamic quote as well as dequote
Non-Deterministic Abstract Machines
We present a generic design of abstract machines for non-deterministic programming languages, such as process calculi or concurrent lambda calculi, that provides a simple way to implement them. Such a machine traverses a term in the search for a redex, making non-deterministic choices when several paths are possible and backtracking when it reaches a dead end, i.e., an irreducible subterm. The search is guaranteed to terminate thanks to term annotations the machine introduces along the way.
We show how to automatically derive a non-deterministic abstract machine from a zipper semantics - a form of structural operational semantics in which the decomposition process of a term into a context and a redex is made explicit. The derivation method ensures the soundness and completeness of the machines w.r.t. the zipper semantics
On the Relative Expressive Power of Asynchronous Communication Primitives
In this paper, we study eight asynchronous communication primitives, arising from the combination of three features: arity (monadic vs polyadic data), communication medium (message passing vs shared dataspaces) and pattern-matching. Each primitive has been already used in at least one language appeared in literature; however, to uniformly reason on such primitives, we plugged them in a common framework inspired by the asynchronous-calculus. By means of possibility/impossibility of ‘reasonable ’ encodings, we compare every pair of primitives to obtain a hierarchy of languages based on their relative expressive power.
Machines abstraites non déterministes
We present a generic design of abstract machines for nondeterministic programming languages, such as process calculi or concurrent lambda calculi, that provides a simple way to implement them. Such a machine traverses a term in the search for a redex, making non-deterministic choices when several paths are possible and backtracking when it reaches a dead end, i.e., an irreducible subterm. The search is guaranteed to terminate thanks to term annotations the machine introduces along the way. We show how to automatically derive a non-deterministic abstract machine from a zipper semantics-a form of structural operational semantics in which the decomposition process of a term into a context and a redex is made explicit. The derivation method ensures the soundness and completeness of the machines w.r.t. the zipper semantics.Nous proposons une présentation uniforme des machines abstraites pour les langages non déterministes, tels que les calculs de processus ou les lambda-calculs concurrents, qui permet de les implémenter facilement. Une telle machine traverse le terme à la recherche d’un redex, en faisant des choix arbitraires lorsque plusieurs chemins sont possibles, et en retournant en arrière lorsqu’elle atteint un cul-de-sac, c’est-à -dire un terme irreductible. Nous garantissons la terminaison de la recherche grâce aux annotations que la machine ajoute encours de route. Nous montrons comment dériver automatiquement une machine non déterministe depuis une sémantique zipper—une forme de sémantique opérationnelle structurelle dans laquelle la décomposition d’un terme en un contexte et un redex apparaît explicitement. La méthode dedérivation garantit la correction et la complétude de la machine par rapport à la sémantique zipper
Expressing mobility in process algebras: first-order and higher-order paradigms
We study mobile systems, i.e. systems with a dynamically changing communication
topology, from a process algebras point of view. Mobility can be introduced
in process algebras by allowing names or terms to be transmitted. We distinguish
these two approaches as first-order and higher-order. The major target of the
thesis is the comparison between them.
The prototypical calculus in the first-order paradigm is the π-calculus. By
generalising its sort discipline we derive an w-order extension called Higher-Order
Ï€-calculus (HOÏ€). We show that such an extension does not add expressiveness
to the π-calculus: Higher-order processes can be faithfully compiled down
to first-order, and respecting the behavioural equivalence we adopted in the calculi.
Such an equivalence is based on the notion of bisimulation, a fundamental
concept of process algebras. Unfortunately, the standard definition of bisimulation
is unsatisfactory in a higher-order calculus because it is over-discriminating.
To overcome the problem, we propose barbed bisimulation. Its advantage is that
it can be defined uniformly in different calculi because it only requires that the
calculus possesses an interaction or reduction relation. As a test for barbed bisimulation,
we show that in CCS and π-calculus, it allows us to recover the familiar
bisimulation-based equivalences. We also give simpler characterisations of the
equivalences utilised in HOÏ€. For this we exploit a special kind of agents called
triggers, with which it is possible to reason fairly efficiently in a higher-order calculus
notwithstanding the complexity of its transitions.
Finally, we use the compilation from HOπ to π-calculus to investigate Milner'