Process Algebra Research Papers - Academia.edu (original) (raw)

- by
- •
- Algebra, Computer Science, Software Engineering, Semantics

Constructing parsimonious phylogenetic trees from species data is a central problem in phylogenetics, and has diverse applications, even outside biology. Many variations of the problem, including the cladistic Camin-Sokal (CCS) version, are NP-complete. We present Answer Set Programming (ASP) models for the binary CCS problem, as well as a simpler perfect phylogeny version, along with experimental results of applying the models to biological data. Our contribution is threefold. First, we solve phylogeny problems which have not previously been tackled by ASP. Second, we report on variants of our CCS model which significantly affect run time, including the interesting case of making the program "slightly tighter". This version exhibits some of the best performance, in contrast with a tight version of the model which exhibited poor performance. Third, we are able to find proven-optimal solutions for larger instances of the CCS problem than the widely used branch-and-bound-based PHYLIP package.

- by David Mitchell
- •
- Bioinformatics, Artificial Intelligence, Modeling, Biology

Bergstra, Bethke and Ponse proposed an axiomatization for Basic Process Algebra extended with (binary) iteration. In this paper, we prove that this axiomatization is complete with respect to strong bisimulation equivalence. To obtain this result, we will set up a term rewriting system, based on the axioms, and prove that this term rewriting system is terminating, and that bisimilar normal forms are syntactically equal modulo AC.

- by Hans Zantema
- •
- Process Algebra, Term Rewriting, Normal Form

For systems of sequential agents the fundamental relations between events — causality and conflict — are naturally connected to a global dependency relation on the system's alphabet. Action refinement as a strictly hierarchical approach to system design should preserve this connection. Then it can be guaranteed that also more complex temporal properties of the refined system are inherited from the abstract level. The behaviour of a system of sequential agents is given in terms of synchronisations structures, a location-based subclass of prime event structures. The action refinement operator inherits causality and conflict according to the dependency relation. To express temporal properties of the systems we use vTrPTL, a linear time temporal logic for Mazurkiewicz traces. The logical framework, based on local modalities and fixpoints, allows to define refinement transformation on formulae. Under certain constraints on the refinement function, satisfaction of a formula for the abstract system turns out to be equivalent to satisfaction of the transformed formula for the refined system.

- by Michaela Huhn
- •
- Process Algebra

The Raise Specification Language (RSL) is a modeling language which supports various specification styles. To apply model checking to RSL concurrent descriptions, we translate RSL specifications into the input language CSPM of FDR. FDR is the model checker for the process algebra CSP. First, we define a syntactic and semantic translation from the concurrent applicative subset of RSL to CSPM, and show that this translation is a strong bisimulation which preserves properties such as traces and deadlock. Consequently, results obtained by refinement checks in FDR are sound for the original RSL descriptions. Second, RSL uses Linear Temporal Logic (LTL) to specify desired properties, but FDR does not support LTL. LTL formulas may be translated to CSP test processes in order to check them with FDR. We build a tool which automates the translation of RSL specifications into CSPM and translates LTL formulas to CSP processes, enabling the model checking of LTL formulas over RSL descriptions with FDR.

- by Silvia Lizeth Tapia Tarifa
- •
- Computer Science, Model Checking, Formal methods, Modeling Language

Labeled transition systems are key structures for modeling computation. In this paper, we show how they lend themselves to ordinary logical analysis (without any special new formalisms), by introducing their standard first-order theory. This perspective enables us to raise several basic model-theoretic questions of definability, axiomatization and preservation for various notions of process equivalence found in the computational literature, and answer them using well-known logical techniques (including the Compactness theorem, Saturation and Ehrenfeucht games). Moreover, we consider what happens to this general theory when one restricts attention to special classes of transition systems (in particular, finite ones), as well as extended logical languages (in particular, infinitary firstorder logic). We hope that this puts standard logical formalisms on the map as a serious option for a theory of computational processes. As a side benefit, our approach increases comparability with several other existing formalisms over labeled transition systems (such as Process Algebra or Modal Logic). We provide some pointers to this effect, too.

- by Johan van Benthem
- •
- Cognitive Science, Modal Logic, Model Theory, Philosophy

Safety critical software requires integrating verification techniques in software development methods. Software architectures must guarantee that developed systems will meet safety requirements and safety analyses are frequently used in the assessment. Safety engineers and software architects must reach a common understanding on an optimal architecture from both perspectives. Currently both groups of engineers apply different modelling techniques and languages: safety analysis models and software modelling languages. The solutions proposed seek to integrate both domains coupling the languages of each domain. It constitutes a sound example of the use of language engineering to improve efficiency in a software-related domain. A model-driven development approach and the use of a platform-independent language are used to bridge the gap between safety analyses (failure mode effects and criticality analysis and fault tree analysis) and software development languages (e.g. unified modelling language). Language abstract syntaxes (metamodels), profiles, language mappings (model transformations) and language refinements, support the direct application of safety analysis to software architectures for the verification of safety requirements. Model consistency and the possibility of automation are found among the benefits.

Alvis is a novel modelling language defined especially for the embedded systems design and verification. The language has its origin in CCS and XCCS process algebras, but algebraic equations have been replaced with a Haskell based high level programming language. Moreover, Alvis provides communication diagrams for the visual modelling of an embedded system structure, especially from the control and data-flow point of view. This paper presents an introduction to Alvis based on a model of a controller for the Hexor II mobile robot.

- by Marcin Szpyrka and +2
- •
- Unified Modelling Language, Embedded System Design, Process Algebra, Mobile Robot

We present an axiom system ACP, for communicating processes with silent actions ('z-steps'). The system is an extension of ACP, Algebra of Communicating Processes, with Milner's z-laws and an explicit abstraction operator. By means of a model of finite acyclic process graphs for ACP, syntactic properties such as consistency and conservativity over ACP are proved. Furthermore, the Expansion Theorem for ACP is shown to carry over to ACP~. Finally, termination of rewriting terms according to the ACP~ axioms is proved using the method of recursive path orderings.

The construction of concurrent programs is especially complex due mainly to the inherent non-determinism of their execution, which makes it difficult to repeat test scenarios. Concurrency has proved to be a fascinating subject and there are many subtle distinctions which one can make. This dissertation presents an approach for constructing concurrent programs using a set of process algebra constructs (for CSP) implemented as an object-oriented framework in Java called JACK; it stands for Java Architecture with CSP kernel.

- by Leonardo Freitas
- •
- Process Algebra

Lost circulation is the most common problem encountered while drilling oil wells. This paper describes a distributed fuzzy expert system, called Smart-Drill, aimed in helping petroleum engineers to diagnose and solve lost circulation problems. To represent and manipulate perception-based evaluations of uncertainties of facts and rules, the expert system uses an uncertainty model with qualitative scales of plausibility values and multiset-based fuzzy algebra of strict monotonic operations. Its realization in inference procedures permits taking into account the change of plausibility of premises in expert systems rules. Original tools like CAPNET Expert System Shell, Knowledge Acquisition Tool and WITSML Converter implementing the proposed model were used for the development of the Smart-Drill. Overall, the system architecture is discussed and implementation details are provided. Both desktop and Web-based implementations permit petroleum engineers benefit from the system working out in the field. The system is currently at field testing phase in PEMEX, Mexican Oil Company.

- by Jorge Quintanilla Martinez
- •
- Information Systems, Applied Mathematics, Expert Systems, Fuzzy Logic

It is well understood that populations cannot grow without bound and that it is competition between individuals for resources which restricts growth. Despite centuries of interest, the question of how best to model density dependent population growth still has no definitive answer. We address this question here through a number of individual based models of populations expressed using the process algebra WSCCS. The advantage of these models is that they can be explicitly based on observations of individual interactions. From our probabilistic models we derive equations expressing overall population dynamics, using a formal and rigorous rewriting based method. These equations are easily compared with the traditionally used deterministic Ordinary Differential Equation models and allow evaluation of those ODE models, challenging their assumptions about system dynamics. Further, the approach is applied to epidemiology, combining population growth with disease spread.

- by Rachel Norman
- •
- Mathematics, Computer Science, Systems Biology, Population Dynamics

Component-Based Software Development is an emerging discipline in the field of Software Engineering. When constructing component-based systems, we must be sure that the cooperative behaviour of the components and their interaction will be successful. In this paper, we use Linda to specify the interactive behaviour of software components. To do this, we first introduce a process algebra for Linda, and then we define a compatibility relation providing conditions that ensure safe composition. This relation takes into account the state of a shared tuple space which represents the current execution. Indeed, a Linda-based computation is characterized by the store's evolution, so that the set of tuples included into the store governs each computation step. In this context, the success of the composition of a pair of agents in presence of a suitable store can be useful to condition the acceptance of a given component into an open running system. In order to extend our approach to complex systems, where constructing a system involves more than two components, we propose the use of distributed tuple spaces as the glue to join components.

- by Ana Roldan
- •
- Cognitive Science, Software Engineering, Interaction, Software Architecture

This paper introduces a graphical notation called algebraic state transition diagrams (ASTD), which allows for the combination of state transition diagrams using classical process algebra operators like sequence, iteration, parallel composition, quantified choice and quantified synchronization. It is inspired from automata, statecharts and process algebras. Hence, it combines the strength of all these notations: graphical representation, hierarchy, orthogonality, compositionality, abstraction. Quantification is one of the salient features of ASTDs, because it provides a powerful mechanism for modeling an arbitrary number of instances of an ASTD. A formal operational semantics is given. Our target application domain is the specification of information systems, but ASTDs are presented in a generic manner.

- by Benoît Fraikin
- •
- Process, Statecharts, Process Algebra, Operational Semantics

We propose a process algebra, the Algebra of Behavioural Types, as a language for typing concurrent objects in process calculi. A type is a higher-order labelled transition system that characterises all possible life cycles of a concurrent object. States represent interfaces of objects; state transitions model the dynamic change of object interfaces. Moreover, a type provides an internal view of

- by António Ravara
- •
- Higher Order Thinking, Process Algebra, Life Cycle, Process Calculi
- by Henrik Iskov Christensen
- •
- Algebra, Computer Science, Expert Systems, Control Theory

We investigate criteria to relate specifications and implementations belonging to conceptually different levels of abstraction. For this purpose, we introduce the generic concept of a vertical implementation relation, which is a family of binary relations indexed by a refinement function that maps abstract actions onto concrete processes and thus determines the basic connection between the abstraction levels. If the refinement function is the identity, the vertical implementation relation collapses to a standard (horizontal) implementation relation. As desiderata for vertical implementation relations we formulate a number of congruence-like proof rules (notably a structural rule for recursion) that offer a powerful, compositional proof technique for vertical implementation. As a candidate vertical implementation relation we propose vertical bisimulation. Vertical bisimulation is compatible with the standard interleaving semantics of process algebra; in fact, the corresponding horizontal relation is rooted weak bisimulation. We prove that vertical bisimulation satisfies the proof rules for vertical implementation, thus establishing the consistency of the rules. Moreover, we define a corresponding notion of abstraction that strengthens the intuition behind vertical bisimulation and also provides a decision algorithm for finite-state systems. Finally, we give a number of small examples to demonstrate the advantages of vertical implementation in general and vertical bisimulation in particular. C 2001 Academic Press

- by Arend Rensink
- •
- Process Algebra, Boolean Satisfiability

The "IS A"-relationship and the mechanism of inheritance are powerful concepts that help to reduce complexity of models and redundancy in specifications. However, in the area of conceptual modeling, it seems that current Object Oriented Analysis methods put most emphasis on the structural aspects of the "IS A"-relationship while inheritance and sharing of behaviour are often not or ill-defined. This paper investigates how attribute sharing, behaviour sharing and subset hierarchies can be combined into a sound "IS A"-modelling concept that guarantees universal substitutability. Decision criteria on the use of generalization/specialization are discussed and a formal taxonomy of processes corresponding to the generalization/specialization hierarchy is presented.

- by Guido Dedene
- •
- Information Systems, Modeling, Taxonomy, Generalization

The notion of process equivalence of probabilistic processes is sensitive to the exact probabilities of transitions. Thus, a slight change in the transition probabilities will result in two equivalent processes being deemed no longer equivalent. This instability is due to the quantitative nature of probabilistic processes. In a situation where the process behaviour has a quantitative aspect there should be a more robust approach to process equivalence. This paper studies a metric between labelled Markov processes. This metric has the property that processes are at zero distance if and only if they are bisimilar. The metric is inspired by earlier work on logics for characterizing bisimulation and is related, in spirit, to the Kantorovich metric.

The diversity and availability of information sources on the World Wide Web has set the stage for integration and reuse at an unparalleled scale. There remain signi cant hurdles to exploiting the extent of the Web's resources in a consistent, scalable and maintainable fashion. The autonomy and volatility of Web sources complicates maintaining wrappers consistent with the requirements of the data's target application. Also, the sources' semantic heterogeneity requires practical methods to mediate their contents.

- by Prasenjit Mitra and +1
- •
- Algebra, Semistructured Data, Pharmaceuticals, Semantic Interoperability

We present a compositional method for deciding whether a process satisfies an assertion. Assertions are formulae in a modal u-calculus, and processes are drawn from a very general process algebra inspired by CCS and CSP. Wall-known operators from CCS, CSP, and other process algebras appear as derived operators. The method is compositional in the structure of processes and works purely on the syntax of processes. It consists of applying a sequence of reductions, each of which only take into account the top-level operator of the process. A reduction transforms a satisfaction problem for a composite process into equivalent satisfaction problems for the immediate subcomponents. Using process variables, systems with undefined subcomponents can be defined, and given an overall requirement to the system, necessary and sufficient conditions on these subcomponents can be found. Hence the process variables make it possible to specify and reason about what are often referred to as contexts, environments, and partial implementations. As reductions are algorithms that work on syntax, they can be considered as forming a bridge between traditional non-compositional model checking and compositional proof systems.

- by Henrik Reif Andersen
- •
- Computer Science, Distributed Computing, Model Checking, Computer Software
- by Ella Roubtsova and +3
- •
- Formal Analysis, Reasoning, Liquid State Machine, Behavior Modeling
- by Antoine Meyer
- •
- Computer Science, Game Theory, Logic, Model Checking

As UML 2.0 is evolving into a family of languages with individually specified semantics, there is an increasing need for automated and provenly correct model transformations that (i) assure the integration of local views (different diagrams) of the system into a consistent global view, and, (ii) provide a well-founded mapping from UML models to different semantic domains (Petri nets, Kripke automaton, process algebras, etc.) for formal analysis purposes as foreseen, for instance, in submissions for the OMG RFP for Schedulability, Performance and Time. However, such transformations into different semantic domains typically require the deep understanding of the underlying mathematics, which hinders the use of formal specification techniques in industrial applications. In the paper, we propose a UML-based metamodeling technique with precise static and dynamic semantics (based on a refinement calculus and graph transformation) where the structure and operational semantics of mathematical models can be defined in a UML notation without cumbersome mathematical formulae.

- by Daniel Varro
- •
- Formal Analysis, Formal Semantics, Graph Transformation, Model Transformation

We introduce CoCasl as a light-weight but expressive coalgebraic extension of the algebraic specification language Casl. CoCasl allows the nested combination of algebraic datatypes and coalgebraic process types. Moreover, it provides syntactic sugar for an observer-indexed modal logic that allows e.g. expressing fairness properties. This logic includes a generic definition of modal operators for observers with structured equational result types. We prove existence of final models for specifications in a format that allows the use of equationally specified initial datatypes as observations, as well as modal axioms. The use of CoCasl is illustrated by specifications of the process algebras CSP and CCS.

- by Horst Reichel
- •
- Modal Logic, Mathematical Sciences, Process Algebra, Algebraic Specification

Systems based on the service-oriented architecture (SOA) principles have become an important cornerstone of the development of enterprise-scale software applications. They are characterized by separating functions into distinct software units, called services, which can be published, requested and dynamically combined in the production of business applications. Service-oriented systems (SOSs) promise high flexibility, improved maintainability, and simple re-use of functionality. Achieving these properties requires an understanding not only of the individual artifacts of the system but also their integration. In this context, non-functional aspects play an important role and should be Communicated by analyzed and modeled as early as possible in the development cycle. In this paper, we discuss modeling of non-functional aspects of service-oriented systems, and the use of these models for analysis and deployment. Our contribution in this paper is threefold. First, we show how services and service compositions may be modeled in UML by using a profile for SOA (UML4SOA) and how non-functional properties of service-oriented systems can be represented using the nonfunctional extension of UML4SOA (UML4SOA-NFP) and the MARTE profile. This enables modeling of performance, security and reliable messaging. Second, we discuss formal analysis of models which respect this design, in particular we consider performance estimates and reliability analysis using the stochastically timed process algebra PEPA as the underlying analytical engine. Last but not least, our models are the source for the application of deployment mechanisms which comprise model-to-model and model-to-text transformations implemented in the framework VIATRA. All techniques presented in this work are illustrated by a running example from an eUniversity case study.

- by Marielle Stoelinga
- •
- Model-Based Testing, Computer Software, Formal method, Process Algebra
- by David Pym
- •
- Mathematics, Intuitionistic Logic, Calculus, Computer Science

A fundamental problem in the design and development of embedded control systems is the verification of safety requirements. Formal methods, offering a mathematical way to specify and analyze the behavior of a system, together with the related support tools can successfully be applied in the formal proof that a system is safe. However, the complexity of real systems is such that automated tools often fail to formally validate such systems.

- by ALESSANDRO FANTECHI
- •
- Computer Science, Distributed Computing, Software Engineering, Model Checking

The need for flexible manufacturing systems (FMSs) has become of utmost importance over the last years due to the fierce competition present in the manufacturing industry as well as the ever decreasing product life spans and the markets attempts to respond to customers' changing needs. These systems allow us to react quickly to changes, however this flexibility costs both time and money. Given this fact, it would be desirable to reduce costs by testing potential implementations before using them. We will use a timed process algebra called BTC (for bounded true concurrency) to face up to this challenge. We have developed this algebra by extending CSP in order to consider the duration of actions and the context (resources) in which processes are executed. This new algebra is able to take into account that the resources in a system must be shared by all the processes. So, we can find two kinds of delays in the execution of a process: delays related to the synchronization of processes, and delays related to the allocation of resources. Once FMSs are specified by means of BTC, we will focus our attention on the performance of the system which will be variable depending on the number of available resources. For this, we have developed a performance algorithm and a tool which implements it. Three examples are used to show how an FMS can be specified and how the algorithm and the tool work, allowing us to obtain the best performance with the lowest cost.

- by M Carmen Ruiz
- •
- Performance Evaluation, Mathematical Sciences, Formal method, Process Algebra

In this paper we propose a new characterization of model-based diagnosis based on process algebras, a framework which is widely used in several areas of computer science. We show that process algebras provide a powerful modelling language which allows us to capture, in an uniform way, different types of models of physical systems, including models of time-varying and dynamic behavior. Then we provide a characterization of diagnosis which is equivalent to the "classical" abductive one. This suggests new interesting opportunities for research on relations between modelbased reasoning and process algebras. (L. Console), picardi@di.unito.it (C. Picardi), marina@di.unito.it (M. Ribaudo). 0004-3702/02/$ -see front matter  2002 Elsevier Science B.V. All rights reserved. PII: S 0 0 0 4 -3 7 0 2 ( 0 2 ) 0 0 2 9 2 -8 20 L. Console et al. / Artificial Intelligence 142 (2002) 19-51 (e.g., computational complexity [13,57] or diagnosability ). Moreover, they provided conceptual tools for analyzing application problems and domains and for relating them to the different approaches for modelling and problem solving; as a result, they have been used for defining frameworks which provide guidelines for studying which approaches to modelling and diagnosis are suitable for a given application problem or domain (e.g., see ). Together with the applications, the foundational works contributed to singling out new open problems and opportunities for research. Last, but not least, they contributed to the creation of bridges between model-based reasoning and other areas of artificial intelligence and computer science such as logical and non-monotonic reasoning, probabilistic reasoning, machine learning, control theory, to mention only some of them.

A Chu space is a binary relation =| from a set A to an antiset X defined as a set which transforms via converse functions. Chu spaces admit a great many interpretations by virtue of realizing all small concrete categories and most large ones arising in mathematical and computational practice. Of particular interest for computer science is their interpretation as computational processes, which takes A to be a schedule of events distributed in time, X to be an automaton of states forming an information system in the sense of Scott, and the pairs (a, x) in the =| relation to be the individual transcriptions of the making of history. The traditional homogeneous binary relations of transition on X and precedence on A are recovered as respectively the right and left residuals of the heterogeneous binary relation =| with itself. The natural algebra of Chu spaces is that of linear logic, made a process algebra by the process interpretation.

- by Vaughan Pratt
- •
- Linear Logic, Process Algebra, Binary relation
- by Kees Verstoep
- •
- Information Systems, Distributed Computing, Model Checking, Data Analysis

This report considers the problem of interpreting behavioural meanings from model-based speci cations written in formal speci cation languages such as Z, VDM-SL or AMN. It contends that certain requirements { such as the order in which operations are invoked, the origin, destination, and ordering (together with the implied presence) of inputs and outputs { signi cant in certain problem domains, are di cult to express within the established approaches. In the light of this discussion we promote an approach that combines the expressive powers of both process algebras and model-based approaches for the modelling of systems with a pronounced behavioural perspective as well as signi cant emphasis on data and process requirements. As a rst step toward an integrated language involving Z and CCS, a language, ZCCS, is presented { a dialect of value-passing CCS that employs Z as its value-calculus. The (abstract) syntax of the language is de ned and a small example of a ZCCS speci cation is supplied. Finally, the current state of our own research into integrated formal methods is overviewed.

- by bill stoddart
- •
- Software Engineering, Models, CCS, Formal method

- by Alessandro Fantechi
- •
- Distributed Computing, Model Checking, Formal methods, System Design

The expansion of inter-organizational scenarios based on different authorization schemes involves the development of integration solutions allowing different authorization domains to share, in some way, protected resources. This paper analyzes different emerging technologies. On the one hand, we have two XML-based standards, the SAML standard, which is being widely accepted as a language to express and exchange authorization data, and the XACML standard, which constitutes a promising framework for access control policies. On the other hand, PERMIS is a trust management system for X.509 attribute certificates and includes a powerful authorization decision engine governed by the PERMIS XML policy. This paper presents a sample scenario where domains using these technologies can be integrated allowing, for example, the use of attribute certificates in a SAML environment and the utilization of the PERMIS authorization engine to decide about the disclosure or concealment of attributes. In order to design this scenario we have based our work on a Credential Conversion Service (CCS) which is able to convert ACs into SAML attributes, and a User Attribute Manager (UAM) which controls the disclosure of credentials. These modules are governed by policies defining the conversion process (the Conversion Policy) and the disclosure of attributes (the Disclosure Policy).

- by Gabriel Lopez
- •
- Social Psychology, Access Control, Confidence, Trust Management

Understanding the performance of backoff algorithms in multihop ad hoc networks is a key feature to design efficient Medium Access Protocols for wireless networks. The 802.11 backoff algortihm, the Binary Exponential Backoff, and all the enhancement done to this algorithm are studied in depth in a single hop context. Very few analytical studies are done on 802.11 backoff algorithms in a multi-hop context due to the difficulty of modelling. In this paper we propose an analytical study, based on process algebra, of 4 backoff algorithms on 2 multi-hop scenarios. We evaluate the performance of each backoff algorithms from efficiency point of view and when possible from a fairness point of view.

Linda is a coordination language, originally presented as a set of inter-agent communication primitives which can virtually be added to any programming language. In this paper, we analyse the use of Linda to specify the interactive behaviour of software components. We first introduce a process algebra for Linda and we define a notion of process compatibility that ensures the safe composition of components. In particular, we prove that compatibility implies successful computation. We also argue that Linda features some advantages with respect to similar proposals in the context of dynamic compatibility checking. In this perspective, we propose an alternative definition of compatibility that takes into account the state of a global store, which gives some relevant information about the current execution of the system.

- by Ana Roldan
- •
- Cognitive Science, Computer Software, Process Algebra, Programming language

Most recently, the concept of business documents has started to play double role. On one side, a business document (word
processing text or calculation sheet) can be used as specification tool, on the other side the business document is an immanent
constituent of business processes, thereby essential component of business information systems. The recent tendency is that the
majority of documents and their contents within business information systems remain in semi-structured format and a lesser part
of documents is transformed into schemas of structured databases. The semi structured documents can be stored and processed in
the modern database management systems, in compliance with the requirements of business processes. In order to keep in hand
the emerging situation, we suggest the creation (1) a theoretical framework for modelling business information systems; (2) and a
design method for practical application based on the theoretical model that provides the structuring principles. The modelling
approach that focuses on documents and their interrelationships with business processes assists in perceiving the activities of
modern information systems. The interrelationships between documents-centric modelling, the Enterprise Architecture and
systematic approach for design provides an opportunity for a unified modelling.

This report documents the program and the outcomes of the Seminar 11151 ‘Formal Methods in

- by Adelinde Uhrmacher
- •
- Model Checking, Computational Biology, Systems Biology, Petri Nets

In this deliverable we introduce ambient LCC, a language to program interaction models for P2P networks. The language is based on process algebra concepts and is specially designed to support the execution of electronic institutions. An algorithm that automatically translates electronic institution specifications into ambient LCC code is presented and illustrated though an example. Background material on electronic institutions, LCC,

- by David Robertson
- •
- Process Algebra, Interaction model

In this tutorial we present two major applications of process algebras to performance modelling. Thefirst is the use of classical or timed process algebra to verify simulation models. The second is the directuse of stochastic process algebras to construct and solve performance models. The tutorial presents anoverview of the current trends and areas of active research, as well as their

- by Rob Pooley
- •
- Performance Model, Process Algebra, Performance Modelling, Simulation Model

One of the main aims of certificate based Public Key Infrastructure (PKI) is to provide authentication in distributed systems. Through its functions, PKI authentication can be viewed as a re-usable component that can be integrated with other systems to offer strong authentication, scalability, and mobility, particularly for large organizations. PKI has been used to describe authentication in various types of applications ranging from e-commerce and web services applications to large scale systems such as Grid computing. This paper presents a formal approach for modeling certificate based PKI authentication. The approach makes use of two complementary models: one is state-based, described in Z, and the other is event-based, expressed in the Process Algebra of Hoare's Communicating Sequential Processes (CSP). The former will be used to capture the state of PKI key components used in the authentication process, the relationships between them, and model "back-end" operations on these components. Whereas the latter, CSP, will be used to model behavior, and in particular, "front-end" interactions and communications. Only when this authentication mechanism is properly formulated, reasoning about its correctness, vulnerabilities and usability can be scrutinized and possibly aided by automation.

- by Ali E. Abdallah
- •
- Cognitive Science, Grid Computing, Public Key Infrastructure, Formal methods

The subject of this work is to establish a mathematical framework that provides the basis and tool for automated reasoning and uncertainty reasoning based on linguistic information. This paper focuses on a flexible and realistic approach, i.e., the use of linguistic terms, specially, the symbolic approach acts by direct computation on linguistic terms. An algebra model with linguistic terms, which is based on a logical algebraic structure, i.e., lattice implication algebra, is constructed and applied to represent imprecise information and deal with both comparable and incomparable linguistic terms (i.e., non-ordered linguistic terms). Some properties and its substructures of this algebraic model are discussed.

In this paper, we introduce a dense time process algebraic formalism with support for specification of (shared) resource requirements and resource schedulers. The goal of this approach is to facilitate and formalize introduction of scheduling concepts into process algebraic specification using separate specifications for resource requiring processes, schedulers and systems composing the two. The benefits of this research are twofold. Firstly, it allows for formal investigation of scheduling strategies. Secondly, it provides the basis for an extension of schedulability analysis techniques to the formal verification process, facilitating the modelling of real-time systems in a process algebraic manner using the rich background of research in scheduling theory.

- by mohammad mousavi
- •
- Real Time Systems, Process Algebra, Formal Verification, Scheduling Theory

SUMMARY We have already proposed a process algebra µLOTOS as a mathematical framework to synthesize a process from a number of (incomplete) specifications, in which requirements for the process do not have to be completely determined. It is guaranteed that the synthesized process satisfies all the given specifications, if they are consistent. For example, µLOTOS is useful for incremental design. The advantage of µLOTOS is that liveness properties can be expressed by least fixpoints and disjunctions ∨. In this paper, we present µLOTOS R , which is a refined µLOTOS. The improvement is that µLOTOS R has a conjunction operator ∧. Therefore, the consistency between a number of specifications S1, ··· ,S 2 can be checked by the satisfiability of the conjunction specification S1 ∧ · ·· ∧S2. µLOTOSR does not need the complex consistency check used in µLOTOS.

- by Yoshinao Isobe
- •
- Process Algebra, Boolean Satisfiability

We develop a 2-categorical theory for recursively defined domains.<br />In particular, we generalise the traditional approach based on order-theoretic structures to category-theoretic ones. A motivation for this development is the need of a domain theory for concurrency, with an account of bisimulation. Indeed, the leading examples throughout the paper are provided by recursively defined presheaf models for concurrent process calculi. Further, we use the framework to study (open-map) bisimulation.

- by G. Winskel
- •
- Logic Programming, Category Theory, Domain Theory, Assembly
- by Eerke Boiten
- •
- Cognitive Science, Computer Software, Process Algebra, Relational Model