The π-Calculus: A theory of mobile processes by Davide Sangiorgi and David Walker Formal methods have formed the foundation of Computer Science since its inception. Although, initially these formal methods dealt with processes and systems on an individual basis, the paradigm has shifted with the dawn of the age of computer networks. When dealing with systems with interconnected, communicating, dependent, cooperative, and competitive components, the older outlook of analyzing and developing singular systems—and the tools that went with it—were hardly suitable. This led to the development of theories and tools that would support the new paradigm. On the tools end, the development has been widespread and satisfactory: programming languages, development frameworks, databases, and even end-user software products such as word processors, have gained network-awareness. However on the theoretical end, the development has been far less satisfactory. The major work was done by Robin Milner, Joachim Parrow, and David Walker who developed the formalism known as π-calculus in 1989. π-calculus is a process calculus that treats communication between its components as the basic form of computation. It has been quite successful as a foundation of several other calculi in the field and as Milner puts it, it has become common to express ideas about interactions and mobility in variants of the calculus. Introduction The current book serves as a comprehensive reference to π-calculus. Besides Milner's own book on the subject, this is the only other book-length publication on the topic. In many ways, it is much more comprehensive than Milner's: a much wider area of topics are dealt with and in more detail as well. Contents The book is split into seven part. The first part presents the basic theory of π-calculus. However, basic does not mean concise: every topic is discussed in great detail. The section on bisimulation is particularly intensive and provides several insights about the motivation for the theory. Part two discusses several variants of the original calculus. By varying several characteristics of the calculus, such as whether a process can communicate with more than processes at a time, we can obtain these variants. A number of interesting properties of the language are studied by the other when discussing these variants. As can be understood from the title, the calculus' contribution to analyzing mobile processes is a major topic, and it is dealt with extensively starting from part three. The basics are introduced by the way of a sophisticated typing system whose application in speciying complex processes is presented in part four. Part five looks at higher-order π-calculus in which composed systems are considered as first-class citizens. Part six is one of the best in the book and discusses the relation between π-calculus and lambda-calculus, which is an older and more basic calculus. Finally part seven shows how π-calculus can be employed in studying practical, modern software engineering concepts such as object-oriented programming. Impressions One of my disappointments with this book is in how often the reader is left perplexed with some of the theoretical developments, specially in part three. π-calculus is a complicated topic, even for the graduate student audience to which this book is directed, and the author would have done much better by reducing the number of topics and instead focusing on more lucid and detailed explanations. There are several experimental digressions throughout the book, which although interesting, take away from some of the momentum of sequential study. For example, topics such as comparison and encoding of one language to another could be easily moved to a separate section in order to make the content more suitable for self-study. Another issue is the little effort towards making the connection from the theoretical to the practical. The main reason why formal methods have not been adopted in mainstream software development pracitces is that often it is unclear to developers how formalisms can contribute towards the software engineering process. The book would have served its purpose much better if it had spent part of eah chapter discussing the practical application of that chapter's content. For example, congruence checking and bisimulation can be incredbily exciting topics for programmers to learn if they can see practical applications of such powerful techniques. Beyond the above criticism, the book is absolutely indispensible to students and researchers in the field of formal methods. Currently it serves as the primary reference for anyone who wishes to learn the various aspects of π-calculus in detail. Raheel Ahmad

The Ï-Calculus: A theory of mobile processes

We present the fusion calculus as a significant step towards a canonical calculus of concurrency. It simplifies and extends the /spl pi/-calculus. The fusion calculus contains the polyadic /spl pi/-calculus as a proper subcalculus and thus inherits all its expressive power. The gain is that fusion contains actions akin to updating a shared state, and a scoping construct for bounding their effects. Therefore it is easier to represent computational models such as concurrent constraints formalisms. It is also easy to represent the so called strong reduction strategies in the /spl lambda/-calculus, involving reduction under abstraction. In the /spl lambda/-calculus these tasks require elaborate encodings. Our results on the fusion calculus in this paper are the following. We give a structured operational semantics in the traditional style. The novelty lies in a new kind of action, fusion actions for emulating updates of a shared state. We prove that the calculus contains the /spl pi/-calculus as a subcalculus. We define and motivate the bisimulation equivalence and prove a simple characterization of its induced congruence, which is given two versions of a complete axiomatization for finite terms. The expressive power of the calculus is demonstrated by giving a straight-forward encoding of the strong lazy /spl lambda/-calculus, which admits reduction under /spl lambda/ abstraction.

The fusion calculus: expressiveness and symmetry in mobile processes

/pdf/a-survey-of-the-project-automath-zb6u7s78hv.pdf

A survey of the project Automath

On Parallel Algorithms of some Orthogonal Transforms (S.S. Agaian and D.Z. Gevorkian). An Efficient Algorithm for Finding Peripheral Nodes (I. Arany). Computational Aspects of Assigning Characteristic Semigroup of Asynchronous Automata and Their Extensions (S. Bocian and B. Mikolajczak). Reichenbach's Propositional Logic in Algorithmic Form (P. Borowik). The Complexity of Weighted Multi-Constrained Spanning Tree Problems (P. Camerini, G. Galbiati and F. Maffioli). An Algorithm for Finding SC-Preimages of a Deterministic Finite Automaton (K. Chmiel). On Entropy Decomposition Methods and Algorithm Design (Th. Fischer). An Efficient Algorithm for Dynamic String-Storage Allocation (D. Fox). Covering Intervals with Intervals under Containment Constraints (M.R. Garey and R.Y. Pinter). How to Construct Random Functions (O. Goldreich, S. Goldwasser and S. Micali). Four Pebbles Don't Suffice to Search Planar Infinite Labyrinths (F. Hoffmann). Parallel Algorithms: The Impact of Communication Complexity (F. Hossfeld). Tight Worst-Case Bounds for Bin-Packing Algorithms (A. Ivanyi). Hypergraph Planarity and the Complexity of Drawing Venn Diagrams (D.S. Johnson and H.O. Pollak). Convolutional Charaterization of Computability and Complexity of Computations (S. Jukna). Succinct Data Representations and the Complexity of Computations (S. Jukna). Lattices, Basis Reduction and the Shortest Vector Problem (R. Kannan). The Characterization of Some Complexity Classes by Recursion Schemata (M. Liskiewicz, K. Lorys and M. Piotrow). Some Algorithmic Problems on Lattices (L. Lovasz). Linear Proofs in the Non-Negative Cone (J. Moravek). Characterizing Some Low Arithmetic Classes (J.B. Paris, W.G. Handley and A.J. Wilkie). Constructing a Simplex Form of a Rational Matrix (A. Rycerz and J. Jegier). Computing N with a Few Number of Additions (I. Ruzsa and Zs. Tuza). A Hierarchy of Polynomial Time Basis Reduction Algorithms (C.P. Schnorr). A Topological View of Some Problems in Complexity Theory (M. Sipser). v-Computations on Turing Machines and the Accepted Languages (L. Staiger). On the Greedy Algorithm for an Edge-Partitioning Problem (Gy. Turan). The Complexity of Linear Quadtrees (T.R. Walsh).

Theory of algorithms

Process Algebra: Bibliography

Digital Libraries: International Collaboration and Cross-Fertilization

http://basics.sjtu.edu.cn/~yuxi/papers/TCS-2010.pdf

On the expressiveness of interaction

The paper investigates a concurrent computation model, chi calculus, in which communications resemble cut eliminations for classical proofs. The algebraic properties of the model are studied. Its relationship to sequential computation is illustrated by showing that it incorporates the operational semantics of the call-by-name lambda calculus. Practically the model has pi calculus as a submodel.

/pdf/a-proof-theoretical-approach-to-communication-3nm8bzl0gg.pdf

A Proof Theoretical Approach to Communication

http://basics.sjtu.edu.cn/~yuxi/papers/Theory%20of%20Interaction.pdf

Theory of Interaction

http://basics.sjtu.edu.cn/~yuxi/papers/TCS-1999.pdf

Yuxi Fu

Papers

Digital Libraries: International Collaboration and Cross-Fertilization

On the expressiveness of interaction

A Proof Theoretical Approach to Communication

Theory of Interaction

Variations on mobile processes