Trace Equivalence Research Articles

Towards scalable compositional analysis

Due to the state explosion problem, analysis of large concurrent programs will undoubtedly require compositional techniques. Existing compositional techniques are based on the idea of replacing complex subsystems with simpler processes with the same interfaces to their environments, and using the simpler processes to analyze the full system. Most algorithms for proving equivalence between two processes, however, require enumerating the states of both processes. When part of a concurrent system consists of many highly coupled processes, it may not be possible to decompose the system into components that are both small enough to enumerate and have simple interfaces with their enviornments. In such cases, analysis of the systems by standard methods will be infeasible.In this paper, we describe a technique for proving trace equivalence of deterministic and divergence-free systems without enumerating their states. (For deterministic systems, essentially all the standard notions of process equivalence collapse to trace equivalence, so this technique also establishes failures equivalence, observational equivalence, etc.) Our approach is to generate necessary conditions for the existence of a trace of one system that is not a trace of the other; if the necessary conditions cannot be satisfied the systems are equivalent. We have implemented the technique and used it to establish the equivalence of some systems with state spaces too large for enumeration to be practical.

When is partial trace equivalence adequate?

Abstract Two processes are partial trace equivalent iff they can perform the same sequences of actions in isolation. Partial trace equivalence is perhaps the simplest possible notion of process equivalence. In general, it is too simple: it is not usually an adequate semantics. We investigate the circumstances under which it is adequate, which are surprisingly rich. We give two substantial classes of languages for which partial traces are adequate. In one class, partial trace equivalence suffices for total correctness, and operations such as true sequencing are possible; but all processes are determinate and silent moves are not possible. The other class — which includes many standard process calculi, such as CCS and CSP — admits indeterminacy and silent moves, but partial traces only suffice for partial correctness and true sequencing is not definable.

Finite Petri nets as models for recursive causal behaviour

Goltz (1988) discussed whether or not there exist finite Petri nets (with unbounded capacities) modelling the causal behaviour of certain recursive CCS terms. As a representative example, the following term is considered: B=(a.nil∣b.B)+c.nil. We will show that the answer depends on the chosen notion of behaviour. It was already known that the interleaving behaviour and the branching structure of terms as B can be modelled as long as causality is not taken into account. We now show that also the causal behaviour of B can be modelled as long as the branching structure is not taken into account. However, it is not possible to represent both causal dependencies and the behaviour with respect to choices between alternatives in a finite net. We prove that there exists no finite Petri net modelling B with respect to both pomset trace equivalence and failure equivalence.

On deciding trace equivalences for processes

In this paper, we investigate the complexity of deciding trace, maximal trace and ω-trace equivalences for finite state processes and recursively defined processes specified by normed context-free grammars (CFGs) in Greibach normal form (GNF). The main results are as follows: 1. (1) Trace, maximal trace and ω-trace equivalences for processes specified by normed GNF CFGs are all undecidable. For this class of processes, the regularity problem with respect to trace, maximal trace or ω-trace equivalence is also undecidable. Moreover, all these undecidability results hold even for locally unary processes. For processes specified by unary GNF CFGs, the maximal trace equivalence is Π 2 p -complete while the ω-trace equivalence is NL-complete and the trace equivalence is decidable in polynomial time by a dynamic programming algorithm. 2. (2) Trace, maximal trace and ω-trace equivalences for finite state processes are PSPACE-complete. This holds even for locally unary finite state processes. For unary finite state processes, the maximal trace equivalence is co-NP-complete while trace and ω-trace equivalences are NL-complete.

Step bisimulation is pomset equivalence on a parallel language without explicit internal choice

We focus attention on a language ℒ generated by a set of elementary actions under operations of sequential composition, external binary choice, iteration, and non-nested disjoint parallel composition: that is, on an especially simple parallel language without explicit internal, or ‘local’, nondeterminism. ℒ is nondeterministic, despite the restriction to external choice, since a given action may occur in both subterms F and G of the parallel composition F ║ G. We exhibit a single set of equations that axiomatizes both step bisimulation and pomset equivalence on ℒ Given that step bisimulation and pomset equivalence are incomparable on the language ℒ+ obtained from ℒ by relaxing just the constraint on choice, the coincidence of these equivalences on ℒ suggests that the elimination of explicit internal choice can result in simplifications at the semantic level. We reinforce this impression by showing for ℒ that step bisimulation (i) coincides with pomset bisimulation equivalence, (ii) is real-time consistent, and (iii) has step trees as concrete representatives of its equivalence classes. Moreover, we show that none of these results holds for the language ℒ+ Finally, step trace equivalence is proved not to coincide with step bisimulation equivalence on ℒ.

Unique decomposition of processes

In this paper, we examine questions about the prime decomposability of processes, where we define a process to be prime whenever it cannot be decomposed into nontrivial components. We show that any finite process can be uniquely decomposed into prime processes with respect to bisimulation equivalence, and demonstrate counterexamples to such a result for both failures (testing) equivalence and trace equivalence. Although we show that prime decompositions cannot exist for arbitrary infinite processes, we motivate but leave as open a conjecture on the unique decomposability of a wide subclass of infinite behaviours.

On Some Equivalence Relations for Probabilistic Processes1

In this paper, we investigate several equivalence relations for probabilistic labeled transition systems: bisimulation equivalence, readiness equivalence, failure equivalence, trace equivalence, maximal trace equivalence and finite trace equivalence. We formally prove the inclusions (equalities) among these equivalences. We also show that readiness, failure, trace, maximum trace and finite trace equivalences for finite probabilistic labeled transition systems are decidable in polynomial time. This should be contrasted with the PSPACE completeness of the same equivalences for classical labeled transition systems. Moreover, we derive an efficient polynomial time algorithm for deciding bisimulation equivalence for finite probabilistic labeled transition systems. The special case of initiated probabilistic transition systems will be considered. We show that the isomorphism problem for finite initiated labeled probabilistic transition systems is NC(1) equivalent to graph isomorphism.

The parallel complexity of two problems on concurrency

We study the parallel complexity of two problems on concurrency: membership for firing sequences on Petri nets and trace equivalence for partially commutative monoids. Both of them can be solved in constant time by unbounded fan-in circuits with threshold gates. However, they cannot be solved in constant time by a PRAM algorithm.

The expressive power of parallelism

We explore an algebraic language for networks consisting of a fixed number of reactive units, communicating synchronously over a fixed linking structure. The language has only two operators: disjoint parallelism, where two networks are composed in parallel without any interconnections, and linking, where an interconnection is formed between two ports. The intention is that these operators correspond to the primitive steps when constructing networks, and that they therefore are conceptually simpler than the operators in existing process algebras. We investigate the expressive power of our language. The results are: (1) Definability of behaviours: with only three simple processing units, every finite-state behaviour can be constructed. (2) Definability of operators: we characterise the network operators which are definable within the language; these turn out to include most operators previously suggested for describing parallelism. Our results hold for any congruence between trace equivalence and observation equivalence.

Determinancy → (observation equivalence = trace equivalence)

If an experiment s is conducted on a parallel process p, then, in general, different processes may result from the experiment, due to the nondeterministic behaviour of p (in the notation of Milner (1980): p ▪p′ for different p′. Process p is called determinate if the resulting processes are all equivalent (i.e., if p ▪p′ and p ▪p″, then p′ and p″ are equivalent). This means that, although p behaves nondeterministically, this cannot be detected by an observer of p. Let ⋍ denote observation equivalence, used in CCS (Milner, 1980), let ⋍ f denote (the much weaker) failure equivalence, used for CSP (Hoare et al., 1981; Brookes, 1983), and let ⋍ t denote (the still weaker) trace equivalence. We show that the three corresponding notions of determinancy are the same, and that for determinate processes ⋍, ⋍ f, and ⋍ t are the same. Determinacy is preserved under ⋍ and ⋍ f, but not under ⋍ t.