The \pi-calculus is a formalism of computing in which we can compositionally represent dynamics of major programming constructs by decomposing them into a single communication primitive, the name passing. This work reports our experience in using a linear/affine typed \pi-calculus for the analysis and development of type systems of programming languages, focussing on secure information flow analysis. After presenting a basic typed calculus for secrecy, we demonstrate its usage by a sound embedding of the dependency core calculus (DCC) and by the development of a novel type discipline for imperative programs which extends both a secure multi-threaded imperative language by Smith and Volpano and (a call-by-value version of) DCC. In each case, the embedding gives a simple proof of noninterference.

We present a simple type discipline for the π-calculus which precisely captures the notion of sequential functional computation as a specific class of name passing interactive behaviour. The typed calculus allows direct interpretation of both call-by-name and call-by-value sequential functions. The precision of the representation is demonstrated by way of a fully abstract encoding of PCF.

We introduce the Xdπ calculus, a peer-to-peer model for reasoning about dynamic web data. Web data is not just stored statically. Rather it is referenced indirectly, for example using hyperlinks, service calls, or scripts for dynamically accessing data, which require the complex coordination of data and processes between sites. The Xdπ calculus models this coordination, by integrating the XML data structure with process orchestration techniques associated with the distributed pi-calculus. We study behavioural equivalences for Xdπ, to analyze the various possible patterns of data and process interaction.

Bigraphs have been introduced with the aim to provide a topographical meta-model for mobile, distributed agents that can manipulate their own linkages and nested locations, generalising both characteristics of the π-calculus and the Mobile Ambients calculus. We give the first bigraphical presentation of a non-linear, higher-order process calculus with nested locations, non-linear active process mobility, and local names, the calculus of Higher-Order Mobile Embedded Resources (Homer). The presentation is based on Milner’s recent presentation of the λ-calculus in local bigraphs. The combination of non-linear active process mobility and local names requires a new definition of parametric reaction rules and a representation of the location of names. We suggest localised bigraphs as a generalisation of local bigraphs in which links can be further localised. Key words: bigraphs, local names, non-linear process mobility

Abstract. Language-based and process calculi-based information security are well developed fields of computer security. Although these fields have much in common, it is somewhat surprising that the literature lacks a comprehensive account of a formal link between the two disciplines. This paper develops such a link between a language-based specification of security and a process-algebraic framework for security properties. Encoding imperative programs into a CCSlike process calculus, we show that timing-sensitive security for these programs exactly corresponds to the well understood process-algebraic security property of persistent bisimulation-based nondeducibility on compositions ( § ¨�©��� �). This rigorous connection opens up possibilities for cross-fertilization, leading to both flexible policies when specifying the security of heterogeneous systems and to a synergy of techniques for enforcing security specifications. 1

One way of enforcing a mandatory access control policy is to use a static type system capable of guaranteeing a non-interference property. Non-interference requires that two processes with distinct "high"-level components, but common "low"-level structure, cannot be distinguished by "low"-level observers. We state this property in terms of a rather strict notion of process equivalence, namely weak barbed reduction congruence.

The most important thing in the programming language is the name. A language will not succeed without a good name. I have recently invented a very good name and now I am looking for a suitable language. iii Donald Knuth (attr.) iv In recent years concurrency and interaction have emerged as a theme of paramount importance, because they address the needs of distributed systems which have now become pervasive. Perhaps the most studied and acknowledged formalism in that field is the π-calculus [22], from which the concept of session types [16] has evolved. Session types enable us to define and statically typecheck communication protocols, specified as sequences of typed channel actions that constitute a larger interaction, which is called a session. Another important theme is that of structuring software effectively, with the object-oriented paradigm [1, 10] being the most widely accepted nowadays. Indeed, object orientation offers several advantages such as increased encapsulation, and flexibility in adaptation and reuse. In this report, we combine the above into a small calculus for a concurrent object-oriented language with session types. We present examples and patterns that become possible with our language, and then formalise the syntax, operational semantics and typing system. Finally, we prove subject reduction. v vi

Types in processes delineate specific classes of interactive behaviour in a compositional way. Key elements of process theory, in particular behavioural equivalences, are deeply affected by types, leading to applications in the description and analysis of diverse forms of computing. As one of the examples of types for processes, this paper introduces a second-order polymorphic π-calculus based on duality principles, building on type structures coming from typed π-calculi, Linear Logic and game semantics. Of various extensions of first-order typed π-calculi with polymorphism, the present paper focusses on the linear polymorphic π-calculus, extending its first-order counterpart [46]. Fundamental elements of the theory of linear polymorphic processes are studied, including establishment of their strong normalisability using Girard’s “candidates”, introduction of a behavioural theory of polymorphic labelled transitions which strengthens Pierce-embedding of System F in polymorphic processes, establishing a precise connection between the universe of polymorphic functions and the universe of polymorphic processes. The proof combines processtheoretic nature of polymorphic labelled transitions plays an essential role in full abstraction, elucidating subtle aspects of polymorphism in functions and interaction.

This paper proposes two semantics of a probabilistic variant of the π-calculus: an interleaving semantics in terms of Segala automata and a true concurrent semantics, in terms of probabilistic event structures. The key technical point is a use of types to identify a good class of non-deterministic probabilistic behaviours which can preserve a compositionality of the parallel operator in the event structures and the calculus. We show an operational correspondence between the two semantics. This allows us to prove a “probabilistic confluence” result, which generalises the confluence of the linearly typed π-calculus.

Abstract One way of enforcing an information flow control pol-icy is to use a static type system capable of guaranteeing a noninterference property. Noninterference requires thattwo processes with distinct "high"-level components, but common "low"-level structure, cannot be distinguished by"low"-level observers. We state this property in terms of a rather strict notion of process equivalence, namely weakbarbed reduction congruence. Because noninterference is not a safety property, it isoften regarded as more difficult to establish than a conventional type safety result. This paper aims to providean elementary noninterference proof in the setting of the ss-calculus. This is done by reducing the problem to sub-ject reduction- a safety property- for a nonstandard, but fairly natural, extension of the ss-calculus, baptized the hssi-calculus. 1