No full-text available
To read the full-text of this research,
you can request a copy directly from the author.
Abstract
We study bisimilarity and regularity problems of simple process algebras. In particular, we show PSPACE-hardness of the following
problems: (i) strong bisimilarity of Basic Parallel Processes (BPP), (ii) strong bisimilarity of Basic Process Algebra (BPA),
(iii) strong regularity of BPP, and (iv) strong regularity of BPA. We also demonstrate NL-hardness of strong regularity problems
for the normed subclasses of BPP and BPA.
Bisimilarity problems of simple process algebras are introduced in a general framework of process rewrite systems, and a uniform
description of the new techniques used for the hardness proofs is provided.
... Lower complexity bounds have also been obtained: Stříbrná [9] showed that weak bisimilarity of BPAs is PSPACEhard. 2 Mayr [10] subsequently proved PSPACE-hardness for bisimilarity of pushdown automata. Srba [11] improved both results by showing PSPACEhardness for bisimilarity of BPAs. Kučera and Mayr [12] proved that bisimilarity of pushdown automata is EXPTIME-hard. ...
... BPPs can be viewed as a parallel (or commutative) variant of BPAs in which the rules may not only rewrite the leftmost stack symbol but an arbitrary one. BPP bisimilarity was shown PSPACE-complete as well [11,15]. Our EXPTIME lower bound shows that the complexity for BPAs is different (unless EXPTIME = PSPACE). ...
... From a technical point of view, the proof in this note improves Srba's PSPACE-hardness proof [11]. A careful inspection shows that his reduction (from the QBF satisfiability problem to bisimilarity of BPAs) can be decomposed into two parts: ...
Given a basic process algebra (BPA) and two stack symbols, the BPA
bisimilarity problem asks whether the two stack symbols are bisimilar. We show
that this problem is EXPTIME-hard.
... Regarding the computational complexity, we only mention the known PSPACE-completeness of ∼ for Basic Parallel Processes [7], where ∼ = . (The PSPACE-lower bound was shown in [37].) ...
Petri nets are a popular formalism for modeling and analyzing distributed systems. Tokens in Petri net models can represent the control flow state or resources produced/consumed by transition firings. We define a resource as a part (a submultiset) of Petri net markings and call two resources equivalent when replacing one of them with another in any marking does not change the observable Petri net behavior. We consider resource similarity and resource bisimilarity, two congruent restrictions of bisimulation equivalence on Petri net markings. Previously it was proved that resource similarity (the largest congruence included in bisimulation equivalence) is undecidable. Here we present an algorithm for checking resource bisimilarity, thereby proving that this relation (the largest congruence included in bisimulation equivalence that is a bisimulation) is decidable. We also give an example of two resources in a Petri net that are similar but not bisimilar.
... Only recently, Jančar proved the containment of the problem in PSPACE (Jančar, 2003) using a different technique based on the so-called dd-functions. Together with the previously known PSPACE-hardness result from (Srba, 2003), PSPACE-completeness of the problem was finally shown. Even though the tableau technique did not provide the best complexity upper bound in this case, it demonstrates a useful proof strategy that is applicable also to several other classes of systems. ...
Introduction
A model for reactive computation, for example that of labelled transition systems [Kel76], or a process algebra (such asACP [BW90], CCS [Mil89], CSP [Hoa85]) can be used to describe both implementations of processes and specifications of their expected behaviours. Process algebras and labelled transition systems therefore naturally support the so-called single-language approach to process theory, that is, the approach in which a single language is used to describe both actual processes and their specifications. An important ingredient of the theory of these languages and their associated semantic models is therefore a notion of behavioural equivalence or behavioural approximation between processes. One process description, say SYS, may describe an implementation, and another, say SPEC, may describe a specification of the expected behaviour. To say that SYS and SPEC are equivalent is taken to indicate that these two processes describe essentially the same behaviour, albeit possibly at different levels of abstraction or refinement. To say that, in some formal sense, SYS is an approximation of SPEC means roughly that every aspect of the behaviour of this process is allowed by the specification SPEC, and thus that nothing unexpected can happen in the behaviour of SYS. This approach to program verification is also sometimes called implementation verification or equivalence checking.
Designers using implementation verification to validate their (models of) reactive systems need only learn one language to describe both their systems and their specifications, and can benefit from the intrinsic compositionality of their descriptions, at least when they are using a process algebra for denoting the labelled transition systems in their models and an equivalence (or preorder) that is preserved by the operations in the algebra.
... Regarding the lower bounds for the (full) BPA problem, Srba [19] showed PSpacehardness, and Kiefer [15] recently shifted this to ExpTime-hardness (using the ExpTimecompleteness of countdown games [14]); he thus also strengthened the lower bound results known for (visibly) pushdown processes [16], [20] and for weak bisimilarity [17]. This was a bit surprising since the bisimulation equivalence problem for related classes of basic parallel processes (generated by commutative context-free grammars) and of one-counter processes were shown PSpace-complete [11], [3]. ...
Burkart, Caucal, Steffen (1995) showed a procedure deciding bisimulation
equivalence of processes in Basic Process Algebra (BPA), i.e. of sequential
processes generated by context-free grammars. They improved the previous
decidability result of Christensen, H\"uttel, Stirling (1992), since their
procedure has obviously an elementary time complexity and the authors claim
that a close analysis would reveal a double exponential upper bound. Here a
self-contained direct proof of the membership in 2-ExpTime is given. This is
done via a Prover-Refuter game which shows that there is an alternating Turing
machine deciding the problem in exponential space. The proof uses similar
ingredients (size-measures, decompositions, bases) as the previous proofs, but
one new simplifying factor is an explicit addition of infinite regular strings
to the state space. An auxiliary claim also shows an explicit exponential upper
bound on the equivalence level of nonbisimilar normed BPA processes. The
importance of clarifying the 2-ExpTime upper bound for BPA bisimilarity has
recently increased due to the shift of the known lower bound from PSpace (Srba,
2002) to ExpTime (Kiefer, 2012).
... Mayr proved the problem to be co-NP-hard [11] and we recently improved the result to PSPACE [15]. Note: full and extended version of this paper appears as [16] ...
Strong bisimilarity and regularity checking problems of Basic Process Algebra (BPA) are decidable, with the complexity upper
bounds 2-EXPTIME. On the other hand, no lower bounds were known. In this paper we demonstrate PSPACE-hardness of these problems.
... Hirshfeld et al.'s technique does not extend to strong bisimilarity on the full BPP class. Indeed, it has turned out that this problem is PSPACE-complete [14,8]. The PSPACE decision procedure uses a special technique developed by Jančar, which can also be applied to obtain polynomial-time algorithms for strong bisimilarity on normed BPP and distributed bisimilarity on BPP [9,10]. ...
We propose a decision procedure for a general class of normed commutative,process rewrite systems and,their induced bisimulation equivalences. Our technique is inspired by the polynomial-time algorithm for strong bisimilarity on normed Basic Parallel Processes (BPP), developed by Hirshfeld, Jerrum and Moller. We apply our general technique to derive polynomial-time algorithms for strong bisimilarity on normed BPP with communication,and for distributed bisimilarity on all BPP with communication. Moreover, our technique yields the first elementary upper bound for weak and branching bisimilarity on totally normed BPP.
... This chapter is based on the technical report "Strong Bisimilarity of Simple Process Algebras: Complexity Lower Bounds" [179]. The report is an extended and unified version of two papers: "Strong Bisimilarity and Regularity of Basic Process Algebra is PSPACE-Hard" [178] and "Strong Bisimilarity and Regularity of Basic Parallel Processes is PSPACE-Hard" [177]. ...
This thesis studies decidability and complexity border-lines for algorithmic verification of infinite-state systems. Verification techniques for finite-state processes are a successful approach for the validation of reactive programs operating over finite domains. When infinite data domains are introduced, most of the verification problems become in general undecidable. By imposing certain restrictions on the considered models (while still including infinite-state spaces), it is possible to provide algorithmic decision procedures for a variety of properties. Hence the models of infinite-state systems can be classified according to which verification problems are decidable, and in the positive case according to complexity considerations.
Deciding bisimulation equivalence of two normed pushdown automata is one of the most fundamental problems in formal verification. The problem is proven to be ACKER-MANN-complete recently. Both the upper bound and the lower bound results indicate that the number of control states is an important parameter. In this paper, we study the parametric complexity of this problem. We refine previous results in two aspects. First, we prove that the bisimulation equivalence of normed PDA with two states is EXPTIME-hard. Second, we prove that the bisimulation equivalence of normed PDA with d states is in Fd+3, which improves the best known upper bound Fd+4 of this problem.
The main aim of this paper is to give a simple transparent proof of the result showing that the problem of bisimulation equivalence on the class of Basic Parallel Processes (BPP), denoted by BPP-Bisim, can be decided by a polynomial-space algorithm. This result (by the author) has been previously only presented in a conference version, in a rather technical form that is not easily readable and verifiable. Since the result has clarified the complexity of the problem BPP-Bisim, namely its PSPACE-completeness (using the lower bound by Srba), and the problem deals with a fundamental behavioural equivalence and with one of the simplest models that naturally extend finite-state systems into infinite-state ones, it seems appropriate to have a transparent version of the proof.
Decidability of bisimilarity for process algebra (PA) processes, arising by mixing sequential and parallel composition, is a long-standing open problem. The known results for subclasses contain the decidability of bisimilarity between basic sequential (i.e. BPA) processes and basic parallel processes (BPP). Here we revisit this subcase and derive an exponential-time upper bound. Moreover, we show that the problem if a given basic parallel process is inherently sequential, i.e., bisimilar with an unspecified BPA process, is PSPACE-complete. We also introduce a model of one-counter automata, with no zero tests but with counter resets, that capture the behaviour of processes in the intersection of BPA and BPP.
The paper tries to highlight some crucial ideas appearing in the decidability and undecidability proofs for the bisimilarity
problem on models originating in language theory, like context-free grammars and pushdown automata. In particular, it focuses
on the method of finite bases of bisimulations in the case of decidability and the method of “Defender’s forcing” in the case
of undecidability. An intent was to write an easy-to-read article in a slightly informal way, which should nevertheless convey
the basic ideas with sufficient precision.
In this paper we define sheaf spaces of BL-algebras (or BL-sheaf spaces), we study completely regular and compact BL-sheaf spaces and compact representations of BL-algebras and, finally, we prove that the category of non-trivial BL-algebras is equivalent with the category of compact local BL-sheaf spaces.
We investigate the simulation preorder between finite-state systems and a simple subclass of BPP-nets (communication-free nets). We show EXPSPACE lower bounds for the simulation problems, in both directions, as well as for the simulation equivalence. Our results improve PSPACE and co-NP lower bounds for the simulation between finite-state systems and BPP-nets, given by Kučera and Mayr in [A. Kučera, R. Mayr, Simulation preorder over simple process algebras, Information and Computation 173 (2) (2002) 184–198].
We describe the summary graph lattice for dataflow analysis of programs that dynamically construct XML documents. Summary graphs have successfully been used to provide static guarantees in the JWIG language for programming interactive Web services. In particular, the JWIG compiler is able to check validity of dynamically generated XHTML documents and to type check dynamic form data. In this paper we present summary graphs and indicate their applicability for various scenarios. We also show that the expressive power of summary graphs is similar to that of the regular expression types from XDuce, but that the extra structure in summary graphs makes them more suitable for certain program analyses.
The tcc paradigm is a formalism for timed concurrent constraint programming. Several tcc languages di#ering in their way of expressing infinite behavior have been proposed in the literature. In this paper we study the expressive power of some of these languages. In particular, we show that: (1) recursive procedures with parameters can be encoded into parameterless recursive procedures with dynamic scoping, and viceversa. (2) replication can be encoded into parameterless recursive procedures with static scoping, and viceversa. (3) the languages from (1) are strictly more expressive than the languages from (2). Furthermore, we show that behavioral equivalence is undecidable for the languages from (1), but decidable for the languages from (2). The undecidability result holds even if the process variables take values from a fixed finite domain.
We study the following problems for strong and weak bisimulation equivalence: given a labelled Petri net and a finite transition system, are they equivalent?; given a labelled Petri net, is it equivalent to some (unspecified) finite transition system? We show that both problems are decidable for strong bisimulation and undecidable for weak bisimulation.
Many formal models for infinite-state concurrent systems are equivalent to special classes of rewrite systems. We classify these models by their expressiveness and define a hierarchy of classes of rewrite systems. We show that this hierarchy is strict with respect to bisimulation equivalence. The most general and most expressive class of systems in this hierarchy is called process rewrite systems (PRS). They subsume Petri nets, PA-processes, and pushdown processes and are strictly more expressive than any of these. Intuitively, PRS can be seen as an extension of Petri nets by subroutines that can return a value to their caller. We show that the reachability problem is decidable for PRS. It is even decidable if there is a reachable state that satisfies certain properties that can be encoded in a simple logic. Thus, PRS are more expressive than Petri nets, but not Turing-powerful.
We consider the problem of deciding regularity of normed BPP and normed BPA processes. A process is regular if it is bisimilar to a process with finitely many states. We show that regularity of normed BPP and normed BPA processes is decidable in polynomial time and we present constructive regularity tests. Combining these two results we obtain a rich subclass of normed PA processes (called sPA) where the regularity is also decidable. Moreover, constructiveness of this result implies decidability of bisimilarity for pairs of processes such that one process of this pair is sPA and the other has finitely many states.
The string statistics problem consists of preprocessing a string of length n such that given a query pattern of length m, the maxi- mum number of non-overlapping occurrences of the query pattern in the string can be reported efficiently. Apostolico and Preparataintroduced the minimal augmented suffix tree (MAST) as a data structure for the string statistics problem, and showed how to construct the MAST in time O(nlog2 n) and how it supports queries in time O(m) for constant sized alphabets. A subsequent theorem by Fraenkel and Simpson stating that a string has at most a linear number of distinct squares implies that the MAST requires space O(n). In this paper we improve the con- struction time for the MAST to O(nlog n) by extending the algorithm of Apostolico and Preparata to exploit properties of efficient joining and splitting of search trees together with a refined analysis.
In a previous paper the authors proved the decidability of bisimulation equivalence over two subclasses of recursive processes involving a parallel composition operator, namely the so-called normed and live processes. In this paper, we extend this result to the whole class. The decidability proof permits us further to present a complete axiomatisation for this class of basic parallel processes. This result can be viewed as a proper extension of Milner's complete axiomatisation of bisimulation equivalence on regular processes.
We consider the factorization (collapse) of infinite transition graphs wrt. bisimulation equivalence. It turns out that almost none of the more complex classes of the process taxonomy, which has been established in the last years, are preserved by this operation. However, for the class of BPA graphs (i.e. prefix transition graphs of context-free grammars) we can show that the factorization is effectively a regular graph, i.e. finitely representable by means of a deterministic hypergraph grammar. Since finiteness of regular graphs is decidable, this yields, as a corollary, a decision procedure for the finiteness problem of context-free processes wrt. bisimulation equivalence.
A polynomial-time algorithm is presented for deciding bisimulation equivalence of so-called Basic Parallel Processes: multisets of elementary processes combined by a commutative parallelcomposition operator.
This thesis is concerned with the question of obtaining decidable theories for behavioural equivalences on various models of (parallel) computation encompassing systems with infinitely many states. The models on which we concentrate are based on the process calculi BPA and BPP but we also consider labelled Petri nets. The equivalences which we are interested in are language equivalence, bisimulation equivalence and distributed bisimulation equivalence.
BPA (Basic Process Algebra) is provided by a standard calculus which admits of a general sequencing operator, along with atomic actions, choice and recursion. In contrast, BPP (Basic Parallel Processes) is provided by a standard calculus which admits of a simple parallel operator (full merge), along with atomic actions, choice and recursion. From the point of view of language equivalence we show that BPA and BPP are incomparable. This result is in part obtained through a pumping lemma for BPP. We furthermore show that the class of languages generated by BPP is included in a class of languages generated by labelled Petri nets as well as contained in the class of context-sensitive languages. Next we investigate into decidability of language equivalence on language classes related to BPP and Petri nets.
We then move on to bisimulation equivalence. We show that this equivalence is decidable on all of BPA, answering a question left open by Baeten, Bergstra and Klop. We also show that bisimulation equivalence is decidable on BPP and BPPr, (where BPPr is similar to BPP except for its parallel operator which allows for synchronisation). By these results we have obtained a delicate line between decidable and undecidable theories for bisimilarity; by extending BPPr, with the operator of restriction we know that bisimilarity is undecidable. By relying on Jancar's recent result on the undecidability of bisimilarity on labelled Petri nets we further narrow the gap between decidable and undecidable theories; when extending BPP with a notion of forced synchronisation we know that bisimilarity is undecidable.
The decidability proofs of bisimulation equivalence on BPP and BPPr (obtained via the tableau technique) permit us further to present sound and complete equational theories for these process classes. As BPP and BPPr contain the regular processes their results may be seen as proper extensions of Milner's equational theory for regular processes.
In this thesis we shall also consider the problem of decomposing a process into the parallel composition of simpler processes. A particular aspect of decomposition involves decomposing uniquely into prime processes, i.e. those processes which cannot themselves be expressed as a parallel composition of other non-trivial processes. We shall present several unique decomposition results for bisimilarity and distributed bisimilarity on BPP and BPPr as well as subclasses thereof.
Finally, for distributed bisimulation equivaalence we show decidability on the process classes BPP and BPPr. Again our proofs of decidability permit us to present sound and complete equational theories. These results may be seen as extensions of Castellani's equational theories for distributed bisimilarity on the recursion-free fragments of BPP and BPPr. Also for a fragment of BPPr where general summation is replaced by guarded summation shall we present an equational theory for distributed bisimilarity. The proof of completeness relies on the unique decomposition property admitted by this equivalence on BPP.
We present an elementary algorithm for deciding bisimulation equivalence be-tween arbitrary context-free processes. This improves on the state of the art algo-rithm of Christensen, H uttel and Stirling consisting of two semi-decision procedures running in parallel, which prohibits any complexity estimation. The point of our algorithm is the eeective construction of a nite relation characterizing all bisimula-tion equivalence classes, whose mere existence was exploited for the above mentioned decidability result.
Recent results show that strong bisimilarity is decidable for the class of Basic Parallel Processes (BPP), which corresponds to the subset of CCS definable using recursion, action prefixing, nondeterminism and the full merge operator. In this paper we examine all other equivalences in the linear/branching time hierarchy [12] and show that none of them are decidable for BPP.
We show that the problem of checking whether two processes definable in the syntax of Basic Parallel Processes (BPP) are strongly
bisimilar is PSPACE-hard.
We also demonstrate that there is a polynomial time reduction from the strong bisimilarity checking problem of regular BPP
to the strong regularity (finiteness) checking of BPP. This implies that strong regularity of BPP is also PSPACE-hard.
In finite labelled transition systems the problems of deciding strong bisimilarity, observation equivalence and observation
congruence areP-complete under many—oneNC-reducibility. As a consequence, algorithms for automated analysis of finite state systems based on bisimulation seem to be
inherently sequential in the following sense: the design of anNC algorithm to solve any of these problems will require an algorithmic breakthrough, which is exceedingly hard to achieve.
KeywordsCCS-Bisimilarity-
P-completeness-Many-oneNC-reduction
In this paper eleven semantics in the linear time — branching time spectrum are presented in a uniform, model-independent way. Restricted to the domain of finitely branching, concrete, sequential processes, most semantics found in the literature that can be defined uniformly in terms of action relations coincide with one of these eleven. Several testing scenarios, motivating these semantics, are presented, phrased in terms of button pushing experiments on generative and reactive machines. Finally nine of these semantics are applied to a simple language for finite, concrete, sequential, nondeterministic processes, and for each of them a complete axiomatization is provided.
The previous best upper bound on the complexity of deciding bisimilarity between normed context-free processes is due to Huynh and Tian (1994), who put the problem in Σ2P = NPNP: their algorithm guesses a proof of equivalence and validates this proof in polynomial time using oracles freely answering questions which are in NP. In this paper we improve on this result by describing a polynomial-time algorithm which solves this problem. As a corollary, we have a polynomial algorithm for the equivalence problem for simple grammars.
We consider a pushdown automaton as a word-rewriting system with labelled rules applied only in a prefix way. The notion of pushdown transition graph is then extended to the notion of prefix transition graph generated by a word-rewriting system and accessible from a given axiom. Such accessible prefix transition graphs are context-free graphs in the sense of Muller and Schupp (1985), and we show that they are also the rooted pattern graphs of finite degree, where a pattern graph is a graph produced from a finite graph by iterating the addition of a finite family of finite graphs (the patterns). Furthermore, this characterization is effective in the following sense: any finite family of patterns generating a rooted graph G of finite degree, is mapped effectively into a word-rewriting system R such that the accessible prefix transition graph of R is isomorphic to G, and the reverse transformation is effective.
We present an axiom system ACP, for communicating processes with silent actions (‘τ-steps’). The system is an extension of ACP, Algebra of Communicating Processes, with Milner's τ-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 probed using the method of recursive path orderings.
It is shown that the problem whether two labelled place/transition Petri nets (with initial markings) are weakly bisimilar is highly undecidable — it resides at least at level of the hyperarithmetical hierarchy; on the other hand it belongs to 1
1 (the first level of the analytical hierarchy). It contrasts with 0
1-completeness of the same problem for trace (language) equivalence. Relations to similar problems for the process algebra BPP (Basic Parallel Processes) are also discussed.
An introduction to (first-order) Ehrenfeucht-Fraïssé games is presented, and three applications in theoretical computer science are discussed. These are concerned with the expressive power of first-order logic over graphs, formal languages definable in first-order logic, and modal logic over labelled transition systems.
We present a procedure for deciding whether two normed PA terms are bisimilar. The procedure is \elementary," having doubly exponential non-deterministic time complexity.
Strong bisimilarity and regularity checking problems of Basic Process Algebra (BPA) are decidable, with the complexity upper
bounds 2-EXPTIME. On the other hand, no lower bounds were known. In this paper we demonstrate PSPACE-hardness of these problems.
The paper is concerned with ways in which fair concurrency can be modelled using notations for omega-regular languages — languages containing infinite sequences, whose recognizers are modified forms of Büchi or Muller-McNaughton automata. There are characterization of these languages in terms of recursion equation sets which involve both minimal and maximal fixpoint operators. The class of -regular languages is closed under a fair concurrency operator. A general method for proving/deciding equivalences between such languages is obtained, derived from Milner's notion of simulation.
This paper provides a comprehensive summary of equivalence checking results for infinite-state systems. References to the relevant papers will be updated continuously according to the development in the area. The most recent version of this document is available from the web-page http://www.brics.dk/~srba/roadmap.
A result originally due to Baeten, Bergstra, and Klop shows that strong bisimulation equivalence for normed BPA processes is decidable. On the other hand, Huynh and Tian, and Groote and Hüttel, have proved that all other standard equivalences are undecidable for normed BPA and thus for BPA in general, The open problem remaining has been whether bisimulation is decidable for the full BPA language. In this paper, we answer this question in the affirmative, using a proof technique based on the proof by Caucal of the decidability of language equivalence for simple algebraic grammars. The decision procedure relies on our main result, extending that of Caucal, that the maximal bisimulation of any BPA transition graph is finitely representable as a Thue congruence. The decision procedure consists of two semi-decision procedures, one testing for non-bisimilarity and one testing for bisimilarity.
Bisimilarity and regularity are decidable properties for the class of BPA (or context-free) processes (Christensen et al., Inform. and Comput. 121 (1995) 143–148; Burkart et al., Proc. CONCUR’96, Lecture Notes in Computer Science, Vol. 119, Springer, Berlin, 1996, pp. 247–262). We extend BPA with a deadlocking state obtaining BPAδ systems. We show that the BPAδ class is more expressive w.r.t. bisimilarity, but it remains language equivalent to BPA. We prove that bisimilarity and regularity remain decidable for BPAδ. Finally, we give a characterisation of those BPAδ processes that can be equivalently (up to bisimilarity) described within the “pure” BPA syntax.
We show that the pomset-trace equivalence problem for 1-safe, finite Petri nets is decidable; in fact it is complete for expspace. We also show that history-preserving bisimulation between such nets is complete for dexptime. Our methods also yield tight complexity bounds for several other “true concurrency” and interleaving equivalences. The results are independent of the presence of hidden transitions.
A simple and direct method for specifying the semantics of programing languages was discussed. The method was intended to produce concise comprehensible semantic definitions. The 'symbol pushing' nature of the operational method specified semantics based on semantic transformations of programs and simple operation on discrete data. The method was found to be highly efficient in automatic handling of run-time errors and debugging. It was found that a finite memory and compile-time type-checking was necessary to make the system efficient.
Strong bisimilarity of Basic Parallel Processes (BPP) is decidable, but the best known algorithm has non-elementary complexity
[7]. On the other hand, no lower bound for the problem was known. We show that strong bisimilarity of BPP is co-NP-hard.
Weak bisimilarity of BPP is not known to be decidable, but an NP lower bound has been shown in [31]. We improve this result by showing that weak bisimilarity of BPP is Π2
p-hard.
Finally, we show that the problems if a BPP is regular (i.e., finite) w.r.t. strong and weak bisimilarity are co-NP-hard and Π2
p-hard, respectively.
A process # is regular if it is bisimilar to a process # # with finitely many states. We prove that regularity of normed PA processes is decidable and we present a practically usable polynomial-time algorithm. Moreover, if the tested normed PA process # is regular then the process # # can be e#ectively constructed. It implies decidability of bisimulation equivalence for any pair of processes such that one process of this pair is a normed PA process and the other process has finitely many states. 1 Introduction We consider the problem of deciding regularity of normed PA processes. A process # is regular if there is a process # # with finitely many states such that # # # # . Finite-state processes have been intensively studied in the last decades (see e.g. [Mil89]). Almost all interesting properties are decidable for finite-state processes. Moreover, designed algorithms are practically usable. This is no more true if one moves to process classes which contain also proce...
In this chapter, we present a hierarchy of infinite-state systems based on the primitive operations of sequential and parallel composition; the hierarchy includes a variety of commonly-studied classes of systems such as context-free and pushdown automata, and Petri net processes. We then examine the equivalence and regularity checking problems for these classes, with special emphasis on bisimulation equivalence, stressing the structural techniques which have been devised for solving these problems. Finally, we explore the model checking problem over these classes with respect to various linear- and branching-time temporal logics. Keywords: infinite-state rewrite transition systems, sequential/parallel composition /computation, automatic verification, decidability, complexity, behavioural equivalences, bisimulation, equivalence checking, regularity checking, linear/branching-time temporal logics, model checking Contents
. We study the following problems for strong and weak bisimulation equivalence: given a labelled Petri net and a finite transition system, are they equivalent?; given a labelled Petri net, is it equivalent to some (unspecified) finite transition system? We show that both problems are decidable for strong bisimulation and undecidable for weak bisimulation. 1 Introduction The decidability of equivalence notions for infinite-state systems has been extensively studied in the last years. Among other results, it has been shown that trace equivalence is undecidable for Basic Process Algebra (BPA) and Basic Parallel Processes (BPP), while bisimulation equivalence is decidable in both cases [1, 2, 4]. For arbitrary labelled Petri nets (called just Petri nets in the rest of this introduction), all the equivalence notions commonly used in the literature are undecidable [8, 6]. Therefore, in order to obtain positive results some constraints have to be imposed on the nets accepted as problem insta...
Bisimulation equivalence is decidable for normed process algebra Local model checking games
- Y Hirshfeld
- M Jerrum
- C Stirling
Y. Hirshfeld and M. Jerrum. Bisimulation equivalence is decidable for normed process algebra. In Automata, Languages and Programming, 26th International [30] C. Stirling. Local model checking games. In Proceedings of the 6th International Conference on Concurrency Theory (CONCUR'95), volume 962 of LNCS, pages 1–11. Springer-Verlag, 1995.
On the Ehrenfeucht-Frassé game in theoretical computer science (extended abstract)
- W Thomas
W. Thomas. On the Ehrenfeucht-Frassé game in theoretical computer science (extended abstract). In Proceedings of the 4th International Joint Conference CAAP/FASE, Theory and Practice of Software Development (TAPSOFT'93), volume 668 of LNCS, pages 559–568. Springer-Verlag, 1993.
New results for bisimilarity on basic parallel processes
- P Janč
P. Janč. New results for bisimilarity on basic parallel processes. In Proceedings of the 4th International Workshop on Verification of Infinite-State Systems (INFINITY'02), page 153. Technical report, Faculty of Informatics, Masaryk University Brno, FIMU-RS-2002-04, 2002. Short presentation
Computational Complexity
- H Ch
- Papadimitriou
Ch.H. Papadimitriou. Computational Complexity. Addison-Wesley, New York,
1994.