DOCSLIB.ORG

Concurrency Theory: a Historical Perspective on Coinduction and Process Calculi

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Concurrency Theory: a Historical Perspective on Coinduction and Process Calculi CONCURRENCY THEORY: A HISTORICAL PERSPECTIVE ON COINDUCTION AND PROCESS CALCULI Jos Baeten, Davide Sangiorgi Readers:Luca Aceto and Robert van Glabbeek 1 INTRODUCTION Computer science is a very young science, that has its origins in the middle of the twentieth century. For this reason, describing its history, or the history of an area of research in computer science, is an activity that receives scant attention. The discipline of computer science does not have a clear demarcation, and even its name is a source of debate. Computer science is sometimes called informatics or information science or information and communication science. A quote widely attributed to Edsger Dijkstra is Computer science is no more about computers than astronomy is about telescopes. If computer science is not about computers, what is it about? We claim it is about behavior. This behavior can be exhibited by a computer executing a program, but equally well by a human being performing a series of actions. In general, behavior can be shown by any agent. Here, an agent is simply an entity that can act. So, computer science is about behavior, about processes, about things happening over time. We are concerned with agents that are executing actions, taking input, emitting output, communicating with other agents. Thus, an agent has behavior, e.g., the execution of a software system, the actions of a machine or even the actions of a human being. Behavior is the total of events or actions that an agent can perform, the order in which they can be executed and maybe other aspects of this execution such as timing, probabilities or evolution. Always, we describe certain aspects of behavior, disregarding other aspects, so we are considering an abstraction or idealization of the ‘real’ behavior. Rather, we can say that we have an observation of behavior, and an action is the chosen unit of observation. 22 Jos Baeten, Davide Sangiorgi But behavior is also the subject of dynamics or mechanics in physics. How does computer science distinguish itself from these fields? Well, the most impor- tant difference is that dynamics or mechanics considers behavior using continuous mathematics (differential equations, analysis), and that computer science considers behavior using discrete mathematics (algebra, logic). So, behavior considered in computer science is discrete, takes place at separate moments in time, and we can observe separate things happening consecutively, different actions are separated in time. This is why a process is sometimes also called a discrete event system. Discrete behavior is important in systems biology, e.g. considering metabolic pathways or behavior of a living cell or components of a cell. We see more and more scientists active in systems biology with a computer science background. Another example of discrete behavior is the working of an organization or part of an organization. This is called workflow. There are two more ingredients involved before we can get to a definition and a demarcation of computer science. These are interaction and information. Com- puter science started off considering a single agent executing actions by itself, but with the birth of concurrency theory, it was realized that interaction is also an essential part of computer science. Agents interact amongst themselves, and inter- act with the outside world. Usually, a computer is not stand-alone, with limited interaction with the user, executing a batch process, but is always connected to other devices and the Internet. Information is the stuff of informatics, the things that are communicated, processed, transformed, sent around. So now we have all ingredients in place and can formulate the following definition of computer science. It may be obvious that we find informatics a better name than computer science. Informatics or computer science is the study of discrete behavior of interacting information processing agents. Given this definition of informatics, we can explain familiar notions in terms of it. A computer program is a prescription of behavior, an interpreter or compiler can turn this into specific behavior. An algorithm is a description of behavior. Computation refers to sequential behavior, not considering interaction. Commu- nication is interaction with information exchange. Data is a manifestation of information. Intelligence has to do with a comparison between different agents, in particular between a human being and a computer. Finally, concurrency theory is that part of the foundations of computer science where interaction is considered explicitly. Acknowledgements The authors are grateful to Luca Aceto and Rob van Glabbeek for comments on an earlier draft of the paper. Sangiorgi’s work has been partially supported by the ANR project 12IS02001 “PACE”. Concurrency Theory 23 2 CONCURRENCY The simplest model of behavior is to see behavior as an input/output function. A value or input is given at the beginning of the process, and at some moment there is a(nother) value as outcome or output. This view is in close agreement with the classic notion of “algorithmic problem”, which is described by giving its legal inputs and, for each legal input, the expected output. The input/output model was used to advantage as the simplest model of the behavior of a computer program in computer science, from the start of the subject in the middle of the twentieth century. It was instrumental in the development of (finite state) automata theory. In automata theory, a process is modeled as an automaton. An automaton has a number of states and a number of transitions, going from one state to a(nother) state. A transition denotes the execution of an (elementary) action, the basic unit of behavior. Besides, there is an initial state (sometimes, more than one) and a number of final states. A behavior is a run, i.e. a path from the initial state to a final state. Important from the beginning is when to consider two automata equal, expressed by a notion of equivalence. On automata, the basic notion of equivalence is language equivalence: a behavior is characterized by the set of executions from the initial state to a final state. Later on, this model was found to be lacking in several situations. Basically, what is missing is the notion of interaction: during the execution from initial state to final state, an agent may interact with another agent. This is needed in order to describe parallel or distributed systems, or so-called reactive systems (see [Harel and Pnueli, 1985]). When dealing with interacting systems, we say we are doing concurrency theory, so concurrency theory is the theory of interacting, parallel and/or distributed systems. The history of concurrency theory can be traced back to the early sixties of the twentieth century with the theory of Petri nets, conceived by Petri starting from his thesis in 1962 [Petri, 1962]. This remained, for some time, a separate strand in the development of the foundations of computer science, with not so many connections to other foundational research. On the other hand, the theory of Petri nets is a strong and continuing contribution to the foundations of computer science, and it has yielded many and beautiful results. The history of Petri nets has been described elsewhere (see e.g. [Brauer and Reisig, 2006]), so we will not consider it any further at this point. In 1970, we can distinguish three main styles of formal reasoning about computer programs, focusing on giving semantics (meaning) to programming languages. 1. Operational semantics. A computer program is modeled as an execution of an abstract machine, an automaton. A state of such a machine is a valuation of variables, a transition between states describes the effect of an elementary program instruction. Pioneer of this field is McCarthy [McCarthy, 1963]. 2. Denotational semantics. This is more abstract than operational semantics; computer programs are usually modeled by a function transforming input 24 Jos Baeten, Davide Sangiorgi into output. Pioneers of this line of research are Scott and Strachey [Scott and Strachey, 1971]. 3. Axiomatic semantics. Here, emphasis is put on proof methods to prove pro- grams correct. Central notions are program assertions, proof triples consist- ing of precondition, program statement and postcondition, and invariants. Pioneers are Floyd [Floyd, 1967] and Hoare [Hoare, 1969]. Then, the question was raised how to give semantics to programs containing a notion of parallelism. It was found that this is difficult using the methods of denotational, operational or axiomatic semantics as they existed at that time, although several attempts were made (later on, it became clear how to extend the different types of semantics to parallel programming, see e.g. [Owicki and Gries, 1976] or [Plotkin, 1976]). There are two paradigm shifts that needed to be made, before a theory of parallel programs could be developed. First of all, the idea of a behavior as an input/output function needed to be abandoned. A program could still be modeled as an automaton, but the notion of language equivalence is no longer appropriate. This is because the interaction a process has between input and output influ- ences the outcome, disrupting functional behavior. Secondly, the notion of global variables needed to be overcome. Using global variables, a state of a modeling automaton is given as a valuation of the program variables, that is, a state is determined by the values of the variables. The independent execution of parallel processes makes it difficult or impossible to determine the values of global vari- ables at a given moment. It turned out to be simpler to let each process have its own local variables, and to denote exchange of information explicitly. For each of these paradigm shifts, we will consider an important notion exem- plifying this development. For the shift away from functional behavior we consider the history of bisimulation, for the shift away from global variables we consider the history of process calculi.
Load more

Recommended publications
  • Concepts of Concurrent Programming Summary of the Course in Spring 2011 by Bertrand Meyer and Sebastian Nanz
    Concepts of Concurrent Programming Summary of the course in spring 2011 by Bertrand Meyer and Sebastian Nanz Stefan Heule 2011-05-28 Licence: Creative Commons Attribution-Share Alike 3.0 Unported (http://creativecommons.org/licenses/by-sa/3.0/) Contents 1 Introduction .......................................................................................................................................... 4 1.1 Ambdahl’s Law .............................................................................................................................. 4 1.2 Basic Notions ................................................................................................................................. 4 1.2.1 Multiprocessing ..................................................................................................................... 4 1.2.2 Multitasking .......................................................................................................................... 4 1.2.3 Definitions ............................................................................................................................. 4 1.2.4 The Interleaving Semantics ................................................................................................... 5 1.3 Transition Systems and LTL ........................................................................................................... 6 1.3.1 Syntax and Semantics of Linear-Time Temporal Logic.......................................................... 7 1.3.2 Safety and Liveness Properties
    [Show full text]
  • Handbook of Formal Languages
    Handbook of Formal Languages von Grzegorz Rozenberg, Arto Salomaa 1. Auflage Handbook of Formal Languages – Rozenberg / Salomaa schnell und portofrei erhältlich bei beck-shop.de DIE FACHBUCHHANDLUNG Springer 1997 Verlag C.H. Beck im Internet: www.beck.de ISBN 978 3 540 60420 4 Contents of Volume 1 Chapter 1. Formal Languages: an Introduction and a Synopsis Alexandru Mateescu and Arto Salomaa ............................ 1 1. Languages, formal and natural ................................. 1 1.1 Historical linguistics ...................................... 3 1.2 Language and evolution ................................... 7 1.3 Language and neural structures ............................ 9 2. Glimpses of mathematical language theory ...................... 9 2.1 Words and languages ..................................... 10 2.2 About commuting ........................................ 12 2.3 About stars ............................................. 15 2.4 Avoiding scattered subwords .............................. 19 2.5 About scattered residuals ................................. 24 3. Formal languages: a telegraphic survey ......................... 27 3.1 Language and grammar. Chomsky hierarchy ................. 27 3.2 Regular and context-free languages ......................... 31 3.3 L Systems............................................... 33 3.4 More powerful grammars and grammar systems .............. 35 3.5 Books on formal languages ................................ 36 References ..................................................... 38 Chapter
    [Show full text]
  • Implementing a Transformation from BPMN to CSP+T with ATL: Lessons Learnt
    Implementing a Transformation from BPMN to CSP+T with ATL: Lessons Learnt Aleksander González1, Luis E. Mendoza1, Manuel I. Capel2 and María A. Pérez1 1 Processes and Systems Department, Simón Bolivar University PO Box 89000, Caracas, 1080-A, Venezuela 2 Software Engineering Department, University of Granada Aynadamar Campus, 18071, Granada, Spain Abstract. Among the challenges to face in order to promote the use of tech- niques of formal verification in organizational environments, there is the possi- bility of offering the integration of features provided by a Model Transforma- tion Language (MTL) as part of a tool very used by business analysts, and from which formal specifications of a model can be generated. This article presents the use of MTL ATLAS Transformation Language (ATL) as a transformation artefact within the domains of Business Process Modelling Notation (BPMN) and Communicating Sequential Processes + Time (CSP+T). It discusses the main difficulties encountered and the lessons learnt when building BTRANSFORMER; a tool developed for the Eclipse platform, which allows us to generate a formal specification in the CSP+T notation from a business process model designed with BPMN. This learning is valid for those who are interested in formalizing a Business Process Modelling Language (BPML) by means of a process calculus or another formal notation. 1 Introduction Business Processes (BP) must be properly and formally specified in order to be able to verify properties, such as scope, structure, performance, capacity, structural consis- tency and concurrency, i.e., those properties of BP which can provide support to the critical success factors of any organization. Formal specification languages and proc- ess algebras, which allow for the exhaustive verification of BP behaviour [17], are used to carry out the formalization of models obtained from Business Process Model- ling (BPM).
    [Show full text]
  • Bisimulations in the Join-Calculus
    Bisimulations in the Join-Calculus C´edricFournet a Cosimo Laneve b,1 aMicrosoft Research, 1 Guildhall Street, Cambridge, U.K. b Dipartimento di Scienze dell’Informazione, Universit`adi Bologna, Mura Anteo Zamboni 7, 40127 Bologna, Italy. Abstract We develop a theory of bisimulations in the join-calculus. We introduce a refined operational model that makes interactions with the environment explicit, and dis- cuss the impact of the lexical scope discipline of the join-calculus on its extensional semantics. We propose several formulations of bisimulation and establish that all formulations yield the same equivalence. We prove that this equivalence is finer than barbed congruence, but that both relations coincide in the presence of name matching. Key words: asynchronous processes; barbed congruence; bisimulation; chemical semantics; concurrency; join-calculus; locality; name matching; pi-calculus. 1 Introduction The join-calculus is a recent formalism for modeling mobile systems [15,17]. Its main motivation is to relate two crucial issues in concurrency: distributed implementation and formal semantics. To this end, the join-calculus enforces a strict lexical scope discipline over the channel names that appear in processes: names can be sent and received, but their input capabilities cannot be affected by the receivers. This is the locality property. 2 Locality yields a realistic distributed model, because the communication prim- itives of the calculus can be directly implemented via standard primitives of 1 This work is partly supported by the ESPRIT CONFER-2 WG-21836 2 The term locality is a bit overloaded in the literature; here, names are locally defined inasmuch as no external definition may interfere; this is the original meaning of locality in the chemical semantics of Banˆatre et al.
    [Show full text]
  • A Complete Bibliography of Publications in the Journal of Computer and System Sciences
    A Complete Bibliography of Publications in the Journal of Computer and System Sciences Nelson H. F. Beebe University of Utah Department of Mathematics, 110 LCB 155 S 1400 E RM 233 Salt Lake City, UT 84112-0090 USA Tel: +1 801 581 5254 FAX: +1 801 581 4148 E-mail: [email protected], [email protected], [email protected] (Internet) WWW URL: http://www.math.utah.edu/~beebe/ 26 May 2021 Version 1.04 Title word cross-reference (s; t) [1475]. 0(n) [1160]. 1 [270]. 1 − L [1371, 924]. 12n2 [450]. 2 [3525, 3184, 2191, 1048, 3402, 1500, 3364, 2034, 2993, 834, 2473, 3101]. f2; 3g [2843]. #09111 [1814]. #AM01053M 2pn 1=3 − 2 O(n ) [1862, 1877, 1904]. #better 5X8 els [1856]. 2 [2353]. 2 [445]. 2 [1977]. 3 #better 5X8 els.pdf [1856]. #BIS [3184]. [1920, 2242, 2827, 2374, 1961, 2825, 3240, · #BIS-hardness #CSP 1071, 1133]. 43 [3620]. 4 Log2N [655]. 5=4 [3184]. ∗ 0 #econdirectM [1612]. 8 [2998]. =? [1433]. [858]. [2696, 2908, 2500, 3508]. 1 ∗ NP [1893]. #HA03022M [1860, 1875]. [1625, 3418, 1085]. [1523]. [3194]. NP[O(log n)] p ⊆ PH #HA05062N [1876]. #HA05062O [2235]. [995]. 2 [2235]. [1849, 1861]. #HA06043M [1501]. 2 [3418]. H [1565]. a [426, 289]. [1892, 1871, 1889]. #HA08111M [1846]. A[P (x); 2x; x + 1] [500]. Ax = λBx [377]. b · #P [1195, 3598, 1261, 1264]. [3253]. β [3444]. [3418]. d #praise 5X8 els.pdf [1832]. [2527, 1362, 3256, 3563]. δ [3553]. `p [2154]. #sciencejobs N [1802]. [1551, 2617, 1864, 1693]. g [3312]. h [1019]. K [1320, 2756, 191, 3494, 1300, 1546, 3286, #P [1373].
    [Show full text]
  • Mobile Processes: a Commented Bibliography
    Mobile Processes: a Commented Bibliography Silvano Dal Zilio Microsoft Research Abstract. We propose a short bibliographic survey of calculi for mobile processes. Contrasting with other similar exercises, we consider two re- lated, but distinct, notions of mobile processes, namely labile processes, which can exhibit dynamic changes in their interaction structure, as mod- elled in the π-calculus of Milner, Parrow and Walker for example, and motile processes, which can exhibit motion, as modelled in the ambient calculus of Cardelli and Gordon. A common characteristic of the alge- braic frameworks presented in this paper is the use of names as first class values and the support for the dynamic generation of new, fresh names. 1 Introduction Process algebras have proved to be valuable mathematical tools to reason about the behaviour of concurrent and communicating systems. For more than ten years now, research has been conducted on semantics of higher-order processes that allow communication channels or even processes to be carried across by communications. Process calculi featuring the ability to dynamically create and exchange channel names are often referred to as mobile, a term popularised by the seminal introduction to the π-calculus [1], a prominent example of calculus with mobile processes. 1. Robin Milner, Joachim Parrow, David Walker: A Calculus of Mobile Pro- cesses, (parts I and II). Information and Computation 100(1) (1992) 1–77 2. Robin Milner: Communicating and Mobile Systems: the Pi-Calculus. Cam- bridge University Press (2000) Unfortunately, the term mobility is overloaded with meaning and the notion of mobility supported by the π-calculus encompasses only part of all the abstrac- tions meaningful to mobility in a distributed system.
    [Show full text]
  • Deadlock Analysis of Wait-Notify Coordination Laneve Cosimo, Luca Padovani
    Deadlock Analysis of Wait-Notify Coordination Laneve Cosimo, Luca Padovani To cite this version: Laneve Cosimo, Luca Padovani. Deadlock Analysis of Wait-Notify Coordination. The Art of Modelling Computational Systems: A Journey from Logic and Concurrency to Security and Privacy - Essays Dedicated to Catuscia Palamidessi on the Occasion of Her 60th Birthday, Nov 2019, Paris, France. hal-02430351 HAL Id: hal-02430351 https://hal.archives-ouvertes.fr/hal-02430351 Submitted on 7 Jan 2020 HAL is a multi-disciplinary open access L’archive ouverte pluridisciplinaire HAL, est archive for the deposit and dissemination of sci- destinée au dépôt et à la diffusion de documents entific research documents, whether they are pub- scientifiques de niveau recherche, publiés ou non, lished or not. The documents may come from émanant des établissements d’enseignement et de teaching and research institutions in France or recherche français ou étrangers, des laboratoires abroad, or from public or private research centers. publics ou privés. Deadlock Analysis of Wait-Notify Coordination Cosimo Laneve1[0000−0002−0052−4061] and Luca Padovani2[0000−0001−9097−1297] 1 Dept. of Computer Science and Engineering, University of Bologna { INRIA Focus 2 Dipartimento di Informatica, Universit`adi Torino Abstract. Deadlock analysis of concurrent programs that contain co- ordination primitives (wait, notify and notifyAll) is notoriously chal- lenging. Not only these primitives affect the scheduling of processes, but also notifications unmatched by a corresponding wait are silently lost. We design a behavioral type system for a core calculus featuring shared objects and Java-like coordination primitives. The type system is based on a simple language of object protocols { called usages { to determine whether objects are used reliably, so as to guarantee deadlock freedom.
    [Show full text]
  • The Beacon Calculus: a Formal Method for the flexible and Concise Modelling of Biological Systems
    bioRxiv preprint doi: https://doi.org/10.1101/579029; this version posted November 26, 2019. The copyright holder for this preprint (which was not certified by peer review) is the author/funder, who has granted bioRxiv a license to display the preprint in perpetuity. It is made available under aCC-BY 4.0 International license. The Beacon Calculus: A formal method for the flexible and concise modelling of biological systems Michael A. Boemo1∗ Luca Cardelli2 Conrad A. Nieduszynski3 1Department of Pathology, University of Cambridge 2Department of Computer Science, University of Oxford 3Genome Damage and Stability Centre, University of Sussex Abstract Biological systems are made up of components that change their actions (and interactions) over time and coordinate with other components nearby. Together with a large state space, the complexity of this behaviour can make it difficult to create concise mathematical models that can be easily extended or modified. This paper introduces the Beacon Calculus, a process algebra designed to simplify the task of modelling interacting biological components. Its breadth is demonstrated by creating models of DNA replication dynamics, the gene expression dynamics in response to DNA methylation damage, and a multisite phosphorylation switch. The flexibility of these models is shown by adapting the DNA replication model to further include two topics of interest from the literature: cooperative origin firing and replication fork barriers. The Beacon Calculus is supported with the open-source simulator bcs (https://github.com/MBoemo/bcs.git) to allow users to develop and simulate their own models. Author summary Simulating a model of a biological system can suggest ideas for future experiments and help ensure that conclusions about a mechanism are consistent with data.
    [Show full text]
  • The EATCS Award 2020 Laudatio for Toniann (Toni)Pitassi
    The EATCS Award 2020 Laudatio for Toniann (Toni)Pitassi The EATCS Award 2021 is awarded to Toniann (Toni) Pitassi University of Toronto, as the recipient of the 2021 EATCS Award for her fun- damental and wide-ranging contributions to computational complexity, which in- cludes proving long-standing open problems, introducing new fundamental mod- els, developing novel techniques and establishing new connections between dif- ferent areas. Her work is very broad and has relevance in computational learning and optimisation, verification and SAT-solving, circuit complexity and communi- cation complexity, and their applications. The first notable contribution by Toni Pitassi was to develop lifting theorems: a way to transfer lower bounds from the (much simpler) decision tree model for any function f, to a lower bound, the much harder communication complexity model, for a simply related (2-party) function f’. This has completely transformed our state of knowledge regarding two fundamental computational models, query algorithms (decision trees) and communication complexity, as well as their rela- tionship and applicability to other areas of theoretical computer science. These powerful and flexible techniques resolved numerous open problems (e.g., the su- per quadratic gap between probabilistic and quantum communication complex- ity), many of which were central challenges for decades. Toni Pitassi has also had a remarkable impact in proof complexity. She in- troduced the fundamental algebraic Nullstellensatz and Ideal proof systems, and the geometric Stabbing Planes system. She gave the first nontrivial lower bounds on such long-standing problems as weak pigeon-hole principle and models like constant-depth Frege proof systems. She has developed new proof techniques for virtually all proof systems, and new SAT algorithms.
    [Show full text]
  • Proof-Relevant Π-Calculus
    Proof-relevant π-calculus Roly Perera James Cheney University of Glasgow University of Edinburgh Glasgow, UK Edinburgh, UK [email protected] [email protected] Formalising the π-calculus is an illuminating test of the expressiveness of logical frameworks and mechanised metatheory systems, because of the presence of name binding, labelled transitions with name extrusion, bisimulation, and structural congruence. Formalisations have been undertaken in a variety of systems, primarily focusing on well-studied (and challenging) properties such as the theory of process bisimulation. We present a formalisation in Agda that instead explores the theory of concurrent transitions, residuation, and causal equivalence of traces, which has not previously been formalised for the π-calculus. Our formalisation employs de Bruijn indices and dependently- typed syntax, and aligns the “proved transitions” proposed by Boudol and Castellani in the context of CCS with the proof terms naturally present in Agda’s representation of the labelled transition relation. Our main contributions are proofs of the “diamond lemma” for residuation of concurrent transitions and a formal deVnition of equivalence of traces up to permutation of transitions. 1 Introduction The π-calculus [18, 19] is an expressive model of concurrent and mobile processes. It has been investigated extensively and many variations, extensions and reVnements have been proposed, including the asynchronous, polyadic, and applied π-calculus (among many others). The π-calculus has also attracted considerable attention from the logical frameworks and meta-languages community, and formalisations of its syntax and semantics have been performed using most of the extant mechanised metatheory techniques, including (among others) Coq [13, 12, 15], Nominal Isabelle [2], Abella [1] (building on Miller and Tiu [26]), CLF [6], and Agda [21].
    [Show full text]
  • A Time Constrained Real-Time Process Calculus
    2008:33 LICENTIATE T H E SIS A Time Constrained Real-Time Process Calculus Viktor Leijon Luleå University of Technology Department of Computer Science and Electrical Engineering EISLAB Universitetstryckeriet, Luleå 2008:33|: 02-757|: -c -- 08 ⁄33 -- A Time Constrained Real-Time Process Calculus Viktor Leijon EISLAB Dept. of Computer Science and Electrical Engineering Lule˚a University of Technology Lule˚a, Sweden Supervisor: Johan Nordlander Jingsen Chen ii The night is darkening round me, The wild winds coldly blow; But a tyrant spell has bound me And I cannot, cannot go. - Emily Bront¨e iv Abstract There are two important questions to ask regarding the correct execution of a real-time program: (i) Is there a platform such that the program executes correctly? (ii) Does the program execute correctly on a particular platform? The execution of a program is correct if all actions are taken within their exe- cution window, i.e. after their release time but before their deadline. A program which executes correctly on a specific platform is said to be feasible on that plat- form and an incorrect program is one which is not feasible on any platform. In this thesis we develop a timed process calculus, based on the π-calculus, which can help answer these questions. We express the time window in which computation is legal by use of two time restrictions, before and after, to express a deadline and a release time offset respectively. We choose to look at correctness through the traces of the program. The trace of a program will always be a sequence of interleaved internal reductions and time steps, because programs have no free names.
    [Show full text]
  • A Survey of Reasoning Methods for Concurrent Systems
    A Survey of Reasoning Methods for Concurrent Systems Chun-Kun Wang Hao Xu Department of Computer Science Data Intensive Cyber Environment Center Univ. of North Carolina at Chapel Hill Univ. of North Carolina at Chapel Hill Chapel Hill, NC 27599, USA Chapel Hill, NC 27599, USA Email: [email protected] Email: [email protected] Abstract—The theory of parallel and distributed systems in tial studies of formal methods for concurrency reasoning. In computer science has been developing for decades. Multiple this paper, we do not compare reasoning methods down to the methods have emerged for the purpose of providing flexibility, last detail (i.e., syntax, inference rules and proof systems). We expressiveness and theories for concurrent processes. This paper provides a comparative introduction to the history of concurrent do, however, discuss concurrency reasoning approaches from systems reasoning and a decision tree to guide the choice of a a high-level and provide a comparative introduction to them. reasoning method accordingly. Our account on these matters is The authors would like to stress that our account on the incomplete. developmental history of concurrent systems reasoning is Index Terms—Concurrent systems, Formal methods, Program incomplete. The guides to select a method accordingly are logic, Process calculi. provided in this paper. Others may well have very different views. I. INTRODUCTION Concurrency theory has been developing for decades, yet II. HISTORY remains an unsolved problem today. Modern software heavily The history of reasoning concurrency dates back to the late relies upon the services provided by distributed systems, twentieth century. The foundations of early concurrency theory ranging from smartphone applications to social media.
    [Show full text]