DOCSLIB.ORG

API-S CALCULUS: FORMAL MODELING for SECURE MOBILE INTELLIGENT AGENT SYSTEMS Jean Francois Gourd University of Southern Mississippi

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text

Load more

The University of Southern Mississippi The Aquila Digital Community Dissertations Summer 8-2007 API-S CALCULUS: FORMAL MODELING FOR SECURE MOBILE INTELLIGENT AGENT SYSTEMS Jean Francois Gourd University of Southern Mississippi Follow this and additional works at: https://aquila.usm.edu/dissertations Part of the Applied Mathematics Commons, and the Computer Sciences Commons Recommended Citation Gourd, Jean Francois, "API-S CALCULUS: FORMAL MODELING FOR SECURE MOBILE INTELLIGENT AGENT SYSTEMS" (2007). Dissertations. 1264. https://aquila.usm.edu/dissertations/1264 This Dissertation is brought to you for free and open access by The Aquila Digital Community. It has been accepted for inclusion in Dissertations by an authorized administrator of The Aquila Digital Community. For more information, please contact [email protected]. The University of Southern Mississippi API-S CALCULUS: FORMAL MODELING FOR SECURE MOBILE INTELLIGENT AGENT SYSTEMS by Jean Gourd A Dissertation Submitted to the Graduate Studies Office of The University of Southern Mississippi in Partial Fulfillment of the Requirements for the Degree of Doctor of Philosophy Approved: August 2007 Reproduced with permission of the copyright owner. Further reproduction prohibited without permission. Copyright by J e a n G o u r d 2007 Reproduced with permission of the copyright owner. Further reproduction prohibited without permission. The University of Southern Mississippi API-S CALCULUS: FORMAL MODELING FOR SECURE MOBILE INTELLIGENT AGENT SYSTEMS by Jean Gourd Abstract of a Dissertation Submitted to the Graduate Studies Office of The University of Southern Mississippi in Partial Fulfillment of the Requirements for the Degree of Doctor of Philosophy August 2007 Reproduced with permission of the copyright owner. Further reproduction prohibited without permission. ABSTRACT API S CALCULUS: FORMAL MODELING FOR SECURE MOBILE INTELLIGENT AGENT SYSTEMS by Jean Gourd August 2007 Mobile code has, for some time, been an intriguing area of research. Unfortunately, it has not propagated much to real-world applications primarily due to serious security con­ cerns associated with processes that possess the capability to move across administrative domains (e.g. mobile intelligent agents). In order to ensure the future success and safety of mobile code, it is imperative that comprehensive mechanisms be developed that permit thorough modeling and analysis of such systems. The use of formal methods to give software meaningful function and performance guarantees is becoming more widespread as the staggering cost of software bugs increases. Using formal methods provides opportunities to experiment with complex systems in order to ultimately prove their functionality, thus offering some sort of validity guarantee. API Calculus stands out in a sea of similar modeling tools as particularly adept at modeling mobile agents and multi-agent systems (MAS). We propose to extend the API Calculus to include the capability to model the security of mobile agents (and agent hosts). We introduce the API-S Calculus as an extension to the API Calculus. In this calcu­ lus, we introduce several new and unique constructs that provide mechanisms to formally model cryptographic protocols and various security techniques unique to the mobile intel­ ligent agent paradigm. We introduce Q-terms and ^-processes which allow the detailed analysis of various cryptographic protocols. Moreover, we provide a way to more accu­ rately model realistic distributed computational systems by introducing the milieu listener, a form of agent broadcast. We extend the concepts of milieu, knowledge unit, and term as defined in the API Calculus in order to impart our calculus with the added flexibility to provide the mechanisms necessary to model and analyze the security of interacting mobile ii Reproduced with permission of the copyright owner. Further reproduction prohibited without permission. iii agents, particularly with respect to MAS. Furthermore, these extensions will support ac­ curate modeling of the security of mobile intelligent agents while distinguishing between groups of cooperating agents, thus providing the tools necessary to model a common secu­ rity model for a group of mobile agents working together to perform some computational task. The need to formally model a MAS initially motivated the development of the API-S Calculus. This multi-agent fuzzy logic framework-termed DDI (Defense Data Integration)- ultimately provides a fused input to an external inclusive decision support system. The framework utilizes mobile intelligent agents to collect, sort, filter, and fuse heterogeneous data for inclusion in the fuzzy logic engine. The unique security requirements of DDI provided the primary motivation for the design of the API-S Calculus. The lack of a for­ mal modeling tool that can capably model MAS and the intrinsic security characteristics of such systems furthermore motivated the development of the API-S Calculus. We ul­ timately show how the calculus can be used to accurately model the DDI framework as well as numerous cryptographic protocols and security techniques relevant to the mobile intelligent agent paradigm. Reproduced with permission of the copyright owner. Further reproduction prohibited without permission. T o M y D a z z l in g W if e iv Reproduced with permission of the copyright owner. Further reproduction prohibited without permission. ACKNOWLEDGMENTS I wish to thank several people who have provided me an innumerable amount of as­ sistance in my endeavor to push through this phase of my life. First, I wish to thank Dr. Dia Ali for his incredible support. Truly, he has helped me in countless ways and I am indebted; Dr. Adel Ali whose keen racquetball skills ultimately led to a graduate educa­ tion; my doctoral committee whose talented members endlessly provided guidance in this exciting process; the 251 crew (you know who you are) whose members have provided me with a wonderful, challenging, and perpetually amusing work environment. Finally, I wish to thank my marvelous wife who, with her unending love and support, is the singular reason I have been able to achieve this. v Reproduced with permission of the copyright owner. Further reproduction prohibited without permission. TABLE OF CONTENTS ABSTRACT............................................................................................................. ii DEDICATION...............................................................................................................iv ACKNOWLEDGEMENTS...........................................................................................v LIST OF ILLUSTRATIONS............................................................................... viii LIST OF T A B L E S................................................................................................ ix 1 INTRODUCTION............................................................................................ 1 1.1 Mobility and the Future 1 1.2 Intelligent Agents 3 1.3 Mobile Agents 4 1.4 Security Issues 6 1.5 Modeling 7 1.6 Motivation 9 1.7 Overview of the Thesis 11 1.8 Contributions of the Thesis 12 1.9 Thesis Structure 14 2 MOBILE AGENT SECURITY.................... 15 2.1 General Security Assumptions 15 2.2 Unique Mobile Agent Characteristics 17 2.3 Multi Agent Systems 18 2.4 Security Issues 19 2.5 Protecting the Host 21 2.6 Protecting the Agent 24 2.7 Summary 30 3 MOBILE AGENT MODELING TO OLS ............................................................ 31 3.1 Petri Nets 31 3.2 7t-Calculus 37 3.3 Ambient Calculus 43 3.4 SPI Calculus 50 3.5 API Calculus 54 3.6 Other Modeling Methods 60 3.7 Summary 60 vi Reproduced with permission of the copyright owner. Further reproduction prohibited without permission. 4 THE API-S CALCULUS ..................................................................................... 63 4.1 Syntax 64 4.2 Broadcasting 74 4.3 Abbreviations 76 4.4 Structural Congruence 78 4.5 Reduction 80 4.6 Discussion 84 5 ILLUSTRATIONS OF THE CAPABILITIES OF A P I-S..................................86 5.1 Simple Examples 86 5.2 Examples with Knowledge Units 88 5.3 Examples with Milieus 90 5.4 Other Examples 94 5.5 Examples Exhibiting Characteristics of Security 97 5.6 Discussion 104 6 THE PRELIMINARY FORMAL MODEL FOR D D I................................... 106 6.1 Preliminary Definition of Formal Components 106 6.2 Preliminary Formal Model 109 7 CONCLUSIONS AND FUTURE W O R K ....................................................... 115 7.1 Conclusive Remarks 115 7.2 Future Directions 116 7.3 Discussion 120 BIBLIOGRAPHY................................................................................................ 122 vii Reproduced with permission of the copyright owner. Further reproduction prohibited without permission. LIST OF ILLUSTRATIONS Figure 1.1 Multi-Agent Fuzzy Logic Framework ................................................................ 10 3.1 Graph representation of a Petri n e t ...................................................................... 32 3.2 A marked Petri n e t ............................................................................................... 32 3.3 The Petri net resulting from the firing of transition t\ ....................................... 33 3.4 The Petri net resulting from the firing of transition ?3 ....................................... 33 3.5 The Petri net modeling a simple producer-consumer scenario .......................... 35 3.6 The Petri net modeling the equation x = (a
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

    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
  • Deadlock: Why Does It Happen? CS 537 Andrea C

    Deadlock: Why Does It Happen? CS 537 Andrea C

    UNIVERSITY of WISCONSIN-MADISON Computer Sciences Department Deadlock: Why does it happen? CS 537 Andrea C. Arpaci-Dusseau Introduction to Operating Systems Remzi H. Arpaci-Dusseau Informal: Every entity is waiting for resource held by another entity; none release until it gets what it is Deadlock waiting for Questions answered in this lecture: What are the four necessary conditions for deadlock? How can deadlock be prevented? How can deadlock be avoided? How can deadlock be detected and recovered from? Deadlock Example Deadlock Example Two threads access two shared variables, A and B int A, B; Variable A is protected by lock x, variable B by lock y lock_t x, y; How to add lock and unlock statements? Thread 1 Thread 2 int A, B; lock(x); lock(y); A += 10; B += 10; lock(y); lock(x); Thread 1 Thread 2 B += 20; A += 20; A += 10; B += 10; A += B; A += B; B += 20; A += 20; unlock(y); unlock(x); A += B; A += B; A += 30; B += 30; A += 30; B += 30; unlock(x); unlock(y); What can go wrong?? 1 Representing Deadlock Conditions for Deadlock Two common ways of representing deadlock Mutual exclusion • Vertices: • Resource can not be shared – Threads (or processes) in system – Resources (anything of value, including locks and semaphores) • Requests are delayed until resource is released • Edges: Indicate thread is waiting for the other Hold-and-wait Wait-For Graph Resource-Allocation Graph • Thread holds one resource while waits for another No preemption “waiting for” wants y held by • Resources are released voluntarily after completion T1 T2 T1 T2 Circular
  • The Dining Philosophers Problem Cache Memory

    The Dining Philosophers Problem Cache Memory

    The Dining Philosophers Problem Cache Memory 254 The dining philosophers problem: definition It is an artificial problem widely used to illustrate the problems linked to resource sharing in concurrent programming. The problem is usually described as follows. • A given number of philosopher are seated at a round table. • Each of the philosophers shares his time between two activities: thinking and eating. • To think, a philosopher does not need any resources; to eat he needs two pieces of silverware. 255 • However, the table is set in a very peculiar way: between every pair of adjacent plates, there is only one fork. • A philosopher being clumsy, he needs two forks to eat: the one on his right and the one on his left. • It is thus impossible for a philosopher to eat at the same time as one of his neighbors: the forks are a shared resource for which the philosophers are competing. • The problem is to organize access to these shared resources in such a way that everything proceeds smoothly. 256 The dining philosophers problem: illustration f4 P4 f0 P3 f3 P0 P2 P1 f1 f2 257 The dining philosophers problem: a first solution • This first solution uses a semaphore to model each fork. • Taking a fork is then done by executing a operation wait on the semaphore, which suspends the process if the fork is not available. • Freeing a fork is naturally done with a signal operation. 258 /* Definitions and global initializations */ #define N = ? /* number of philosophers */ semaphore fork[N]; /* semaphores modeling the forks */ int j; for (j=0, j < N, j++) fork[j]=1; Each philosopher (0 to N-1) corresponds to a process executing the following procedure, where i is the number of the philosopher.
  • CSC 553 Operating Systems Multiple Processes

    CSC 553 Operating Systems Multiple Processes

    CSC 553 Operating Systems Lecture 4 - Concurrency: Mutual Exclusion and Synchronization Multiple Processes • Operating System design is concerned with the management of processes and threads: • Multiprogramming • Multiprocessing • Distributed Processing Concurrency Arises in Three Different Contexts: • Multiple Applications – invented to allow processing time to be shared among active applications • Structured Applications – extension of modular design and structured programming • Operating System Structure – OS themselves implemented as a set of processes or threads Key Terms Related to Concurrency Principles of Concurrency • Interleaving and overlapping • can be viewed as examples of concurrent processing • both present the same problems • Uniprocessor – the relative speed of execution of processes cannot be predicted • depends on activities of other processes • the way the OS handles interrupts • scheduling policies of the OS Difficulties of Concurrency • Sharing of global resources • Difficult for the OS to manage the allocation of resources optimally • Difficult to locate programming errors as results are not deterministic and reproducible Race Condition • Occurs when multiple processes or threads read and write data items • The final result depends on the order of execution – the “loser” of the race is the process that updates last and will determine the final value of the variable Operating System Concerns • Design and management issues raised by the existence of concurrency: • The OS must: – be able to keep track of various processes
  • Supervision 1: Semaphores, Generalised Producer-Consumer, and Priorities

    Supervision 1: Semaphores, Generalised Producer-Consumer, and Priorities

    Concurrent and Distributed Systems - 2015–2016 Supervision 1: Semaphores, generalised producer-consumer, and priorities Q0 Semaphores (a) Counting semaphores are initialised to a value — 0, 1, or some arbitrary n. For each case, list one situation in which that initialisation would make sense. (b) Write down two fragments of pseudo-code, to be run in two different threads, that experience deadlock as a result of poor use of mutual exclusion. (c) Deadlock is not limited to mutual exclusion; it can occur any time its preconditions (especially hold-and-wait, cyclic dependence) occur. Describe a situation in which two threads making use of semaphores for condition synchronisation (e.g., in producer-consumer) can deadlock. int buffer[N]; int in = 0, out = 0; spaces = new Semaphore(N); items = new Semaphore(0); guard = new Semaphore(1); // for mutual exclusion // producer threads while(true) { item = produce(); wait(spaces); wait(guard); buffer[in] = item; in = (in + 1) % N; signal(guard); signal(items); } // consumer threads while(true) { wait(items); wait(guard); item = buffer[out]; out =(out+1) % N; signal(guard); signal(spaces); consume(item); } Figure 1: Pseudo-code for a producer-consumer queue using semaphores. 1 (d) In Figure 1, items and spaces are used for condition synchronisation, and guard is used for mutual exclusion. Why will this implementation become unsafe in the presence of multiple consumer threads or multiple producer threads, if we remove guard? (e) Semaphores are introduced in part to improve efficiency under contention around critical sections by preferring blocking to spinning. Describe a situation in which this might not be the case; more generally, under what circumstances will semaphores hurt, rather than help, performance? (f) The implementation of semaphores themselves depends on two classes of operations: in- crement/decrement of an integer, and blocking/waking up threads.
  • Implementing a Transformation from BPMN to CSP+T with ATL: Lessons Learnt

    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).
  • Bisimulations in the Join-Calculus

    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.
  • Q1. Multiple Producers and Consumers

    Q1. Multiple Producers and Consumers

    CS39002: Operating Systems Lab. Assignment 5 Floating date: 29/2/2016 Due date: 14/3/2016 Q1. Multiple Producers and Consumers Problem Definition: You have to implement a system which ensures synchronisation in a producer-consumer scenario. You also have to demonstrate deadlock condition and provide solutions for avoiding deadlock. In this system a main process creates 5 producer processes and 5 consumer processes who share 2 resources (queues). The producer's job is to generate a piece of data, put it into the queue and repeat. At the same time, the consumer process consumes the data i.e., removes it from the queue. In the implementation, you are asked to ensure synchronization and mutual exclusion. For instance, the producer should be stopped if the buffer is full and that the consumer should be blocked if the buffer is empty. You also have to enforce mutual exclusion while the processes are trying to acquire the resources. Manager (manager.c): It is the main process that creates the producers and consumer processes (5 each). After that it periodically checks whether the system is in deadlock. Deadlock refers to a specific condition when two or more processes are each waiting for another to release a resource, or more than two processes are waiting for resources in a circular chain. Implementation : The manager process (manager.c) does the following : i. It creates a file matrix.txt which holds a matrix with 2 rows (number of resources) and 10 columns (ID of producer and consumer processes). Each entry (i, j) of that matrix can have three values: ● 0 => process i has not requested for queue j or released queue j ● 1 => process i requested for queue j ● 2 => process i acquired lock of queue j.
  • Mobile Processes: a Commented Bibliography

    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.
  • Deadlock-Free Oblivious Routing for Arbitrary Topologies

    Deadlock-Free Oblivious Routing for Arbitrary Topologies

    Deadlock-Free Oblivious Routing for Arbitrary Topologies Jens Domke Torsten Hoefler Wolfgang E. Nagel Center for Information Services and Blue Waters Directorate Center for Information Services and High Performance Computing National Center for Supercomputing Applications High Performance Computing Technische Universitat¨ Dresden University of Illinois at Urbana-Champaign Technische Universitat¨ Dresden Dresden, Germany Urbana, IL 61801, USA Dresden, Germany [email protected] [email protected] [email protected] Abstract—Efficient deadlock-free routing strategies are cru- network performance without inclusion of the routing al- cial to the performance of large-scale computing systems. There gorithm or the application communication pattern. In reg- are many methods but it remains a challenge to achieve lowest ular operation these values can hardly be achieved due latency and highest bandwidth for irregular or unstructured high-performance networks. We investigate a novel routing to network congestion. The largest gap between real and strategy based on the single-source-shortest-path routing al- idealized performance is often in bisection bandwidth which gorithm and extend it to use virtual channels to guarantee by its definition only considers the topology. The effective deadlock-freedom. We show that this algorithm achieves min- bisection bandwidth [2] is the average bandwidth for routing imal latency and high bandwidth with only a low number messages between random perfect matchings of endpoints of virtual channels and can be implemented in practice. We demonstrate that the problem of finding the minimal number (also known as permutation routing) through the network of virtual channels needed to route a general network deadlock- and thus considers the routing algorithm.
  • Deadlock Analysis of Wait-Notify Coordination Laneve Cosimo, Luca Padovani

    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.
  • The Beacon Calculus: a Formal Method for the flexible and Concise Modelling of Biological Systems

    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.