A linear-time branching-time perspective on interface automata

Over the past two decades, de Alfaro and Henzinger’s interface automata (IA) have become a popular formal framework for the component-based specification of concurrent systems. IA’s parallel composition assumes that a component may wait on inputs but never on outputs, implying that an output must be consumed immediately or a communication error occurs. By now, the literature contains a number of semantics for IA: linear-time semantics based on traces observing communication errors, quiescence and/or divergence, as well as branching-time semantics based on alternating simulation. This article surveys these semantics from Rob van Glabbeek’s linear-time branching-time perspective, which does not consider settings with communication errors. We shed light onto the subtleties implied by IA’s pruning of all behaviour that might lead a component to autonomously enter an error state, and investigate when exactly de Alfaro and Henzinger’s restriction of input-determinism is needed. In addition, we introduce several new semantics for IA, in particular the linear-time ready semantics and the branching-time ready simulation.


Introduction
Modern software systems are assembled from components that need to interoperate properly in order to ensure a system's correctness.Behavioural interfaces allow one to specify contracts between concurrent components [5] and, thus, to statically reason about component compatibility.This is of particular relevance during early system design and also when integrating legacy components.
The theoretical foundations of such interfaces have been studied intensively in the concurrency theory community [4,[9][10][11]19,21,29,35,38], especially since the inception of interface automata (IA) by de Alfaro and Henzinger [12,13].These automata are based on labelled transition systems but distinguish a component's input and output actions, and define a parallel composition whereby a component may wait on inputs but never on outputs.Therefore, a communication error occurs if one component receives a message for which it is not ready.In case no potential system environment may restrict the system components' behaviour so that all errors are avoided, the components are deemed to be incompatible.Behavioural preorders for IA Over the years, IA have been equipped with a number of behavioural relations for interface refinement and implementation.Originally, de Alfaro and Henzinger presented the IA-setting with branching-time preorders based on co-inductive notions of alternating simulation [12,13]: a component satisfies an interface if it implements all input behaviour prescribed by the interface and if the interface permits all output behaviour executed by the implementing component, thereby preserving compatibility wrt.arbitrary system environments.Later, Göhrle [21] studied preorders that vary the degree to which internal behaviour surrounding input and output actions is abstracted and that lie in-between the two preorders proposed by de Alfaro and Henzinger.
More recently, various fully-abstract, linear-time preorders based on decorated traces have been developed for IA: the error semantics of [10,11], the quiescence and the divergence semantics of [38], and the CJK-semantics of [11].Strictly speaking, these preorders have been studied in the setting of Error-IO Transition Systems (EIO) [10,38], which are inputenabled interface automata with explicit error states.EIO and IA are essentially the same model: the error states in EIO are eliminated in IA by pruning locally reachable errors, i.e., states from which a component can autonomously reach some error state via output and internal transitions only.
Contributions This article surveys and extends the above works and is intended for concurrency theoreticians to gain an overview and better understanding of the subtle semantic issues introduced by the notions of communication errors and component compatibility.We first recall the above preorders on EIO and IA, together with their precongruence properties and, where applicable, full-abstraction properties.Then, we study these preorders for a general notion of parallel composition that considers multicast synchronization and enables action internalisation via a separate hiding operator, whereas some of the preorders, e.g., the original IA-preorders proposed by de Alfaro and Henzinger [12,13] have so far been studied only for a binary, internalising parallel composition operator.
As a first contribution, we arrange all these preorders in a linear-time branching-time spectrum, as inspired by van Glabbeek's seminal works on the spectrum for behavioural relations on ordinary labelled transition systems [41][42][43].We add to the IA-spectrum a number of new preorders: ready semantics to the linear-time part, as well as ready simulation and several bi-variant variations [3] of alternating simulation, including IA-bisimulation, to the branching-time part.Our final IA-spectrum (see Figs. 6,13) depicts all implications between the studied 16 preorders, and counterexamples are provided wherever implications fail to hold.
As a second contribution, we discuss various design decisions and properties of the preorders.For the linear-time preorders, we show that the pruning of locally reachable errors does not change an interface's semantics.We also take a closer look at the CJK-semantics and a variation of quiescence semantics.Regarding the branching-time preorders, we present characterizations of both IA-preorders by de Alfaro and Henzinger in terms of standard simulations.
The main insight is that the original preorder for IA, to which we refer as IA-refinement [12], also supports associativity for parallel composition, even for interfaces that are not input-deterministic.That associativity fails in [12] is solely owed to the incomplete notion of pruning employed therein.Hence, there is no need to restrict IA to input-deterministic interfaces as is done, e.g., in [13], and we recommend future investigations into IA to be based on the coarser IA-refinement preorder rather than on the alternating simulation of [13].For those who prefer the latter preorder, we show how it can be generalized to arbitrary, i.e., not necessarily input-deterministic IA.
Related work A linear-time branching-time spectrum for behavioral specification theories is presented by Fahrenberg and Legay [18].They employ disjunctive modal transition systems [28] to define a spectrum of refinement preorders, including failure semantics [7] and ready simulation [6], each giving rise to a specification theory for some equivalence-but not preorder-in van Glabbeek's Linear-Time Branching-Time Spectrum I (without internal actions) [41,43].Moreover, Fahrenberg and Legay do not specifically consider interface theories: neither IA and its parallel composition, nor a notion of communication error, nor alternating simulation and related behavioural relations are studied.

Structure of this article
The next section introduces IA informally, and points out the main aspects of parallel composition, communication error, pruning and compatibility.Sect. 3 then defines the formal framework considered by us, i.e., Interface Automata and Error-IO Transition Systems and their parallel and hiding operators.The subsequent Sects.4 and 5 develop the linear-time and resp.branching-time part of our IA-spectrum, as announced above, and explores how exactly these two parts are connected.Finally, Sect.6 briefly discusses two fields closely related to IA, namely interface theories and certain parts of model-based testing, while Sect.7 presents our conclusions and suggestions for future work.

Interface automata by example
We introduce IA by an example that demonstrates the utility of de Alfaro and Henzinger's setting [12,13] for reasoning about component compatibility in concurrent systems.The essential feature of the setting is that, in the definition of parallel composition, one identifies error states and removes them in a suitable manner.If this leads to the removal of the initial state of the composition, the components are deemed to be incompatible, i.e., they cannot be used in combination in any system environment.
Consider the example depicted in Fig. 1, which is taken from [30] and adapted from [13].It shows a simple networking protocol consisting of a Client that repeatedly sends messages (output action send!) and expects to receive a positive response ( trnsmt!Fig. 2 Component TryOften (with the same inputs and outputs as TryOnce) and its parallel composition with Client, using the pruning of [12], and component Lower (with inputs {trnsmt, reset} and outputs {ack, nack} Client can also listen to retry messages (input retry?), it always ignores these.The transport layer protocol is modelled by component TryOnce that receives messages (input send?), sends them over the network (output trnsmt!), and receives either a positive acknowledgement (input ack?) and relays this (output ok!), or a negative acknowledgement (input nack?) after which the component resets the lower layer (output reset!) and sends a retry request to the client (output retry!).
We now consider the parallel composition Client|TryOnce of Client and TryOnce.For this, one first carries out a standard composition Client ⊗ TryOnce, called product, where an output action synchronizes with an equally named input action, resulting in the output action.This way, a third component can listen to and synchronize with the same output, i.e., a multicast synchronization is possible.Then, in our example, state E is identified as an error state because TryOnce sends a retry, which Client refuses to accept.Such a communication mismatch has to be avoided and, because a component controls its output actions, the source of transition reset! has to be avoided as well.In general, a state is deemed illegal if it can reach an error state autonomously, i.e., by locally controlled actions.The idea of pruning in [12,13] is to obtain Client|TryOnce by removing all illegal states, whereby also the input transition nack? is cut.The resulting pruned automaton can also be seen as an operating guideline on how to use the two components working in parallel.Here, the guideline states that this automaton should not be confronted with input nack? after trnsmt!.
Unfortunately, the pruning of de Alfaro and Henzinger [12] leads to an associativity problem of parallel composition.To see this, we extend TryOnce to TryOften by adding a second transition nack?, as shown in Fig. 2. Thereby, TryOften can nondeterministically decide how often to re-transmit a message before forcing a reset.Furthermore, we add a lower-level component Lower that forwards a transmission to the communication medium, returns a positive or negative acknowledgement after some internal activity (non-observable action τ ), and accepts reset requests in its initial state.If we compose Client and TryOften, we obtain the same systems as in Fig. 1 as the product and also as the parallel composition, except for the additional nack?-transition.We use the operator | in Client | TryOften to indicate that this composition is unsatisfactory.If we further add Lower as third component, there are no error states (see Fig. 3, left), i.e., Client, TryOften and Lower are deemed to be compatible.However, when we first compose TryOften with Lower, we obtain the error-free IA depicted in the middle of Fig. 3 and, then, the product with Client as shown on the right-hand side of the figure.Here, the initial state can reach the error state autonomously by local actions; note that τ is locally-controlled, too.Thus, with this bracketing, the three components are incompatible and their parallel composition is undefined.Consequently, | is not associative.3 Completing our example to illustrate the associativity defect of the pruning of [12] This associativity defect, which was first discovered in [10], is rooted in the nondeterministic choice on input nack?, which was avoided by de Alfaro and Henzinger in their later work [13] by restricting the IA-setting to input-deterministic components.Additionally, they replaced the original refinement relation of [12] by a stricter one, which is however unrelated to the associativity defect.In fact, the restriction to input-deterministic components in [13] is unnecessary, because the conceptual mistake lies in the notion of pruning.Recall that cutting the nack?-transition in Client ⊗ TryOnce, and similar in Client ⊗ TryOften (not shown in the figures), should indicate that the environment must refrain from sending nack in the state after trnsmt!.However, the pruning of [12] incompletely reflects this requirement, because the second nack?-transition in Client ⊗ TryOften is not pruned.To obtain a proper pruning, one must always prune all transitions of an input at a state, if one prunes one transition of this input at the state.In our example, the nack?-transition remaining in Fig. 2 in the middle is then also pruned, so that the composition with the third component Lower is incompatible due to that component's output nack!.In the following, we use the ordinary symbol | for the parallel composition with proper pruning.Observe that, in Fig. 1, the kind of pruning does not matter and one may use either | or | there.
To conclude, the above discussion leads to the following understanding of parallel product and composition.The product of, e.g., Client and TryOnce describes how the two automata interact with each other, while their composition is more concise and describes the behaviour only as far as needed.At the same time, the composition captures more clearly the requirements imposed upon the system environment, in which the composition may be placed.For fundamental studies of this specification setting, the EIO variant of IA with explicit error states was introduced (cf.[10,11]).

The interface automata setting
This section presents the formal framework in which the linear-time and branching-time preorders studied in the literature were developed: the interface automata (IA) of de Alfaro and Henzinger [12] and the equally expressive Error-IO Transition Systems (EIO) of Bujtor and Vogler [10] (cf.also [11]).A particular focus is placed on the parallel composition of such automata and the pruning in IA; as just explained, our pruning subtly but importantly deviates from the one employed in [12].Generalizing the standard definition, we also equip IA with an associative multicast parallel operator; our additional hiding operator allows for the internalization of actions that implicitly occurs in [12,13] when actions synchronize.Definition 1 (Interface automata) An Interface Automaton (IA) is a tuple (P, I , O, −→, p 0 ), where -P is the set of states; -I and O are disjoint sets of input and output actions, resp., not containing the special, non-observable action τ , where A = df I ∪ O is called the automaton's action set or alphabet and (I , O) its signature; -−→ ⊆ P × A τ × P is the transition relation, where Note that the IAs studied by us are not by definition input-deterministic.In the following, we denote an IA as above also by P, i.e., we identify an IA by its state set.We often use p and p as representatives of the state set P, as well as i, o, ω, a and α as representatives of the action sets I , O, O τ , A and A τ , resp.If α = τ , then α = df ; otherwise, α = df α.In addition, we let p α −→ p denote the transition ( p, α, p ) ∈ −→, while p α −→ means that such a transition exists for some p , i.e., α is enabled at p.A state is stable if it does not enable τ .Unless defined otherwise, an IA P always has the components P, I , O, −→, and p 0 , and similarly P 1 has components P 1 , I 1 , etc.In figures, we sometimes display i? for an input i and o! for an output o.
Extending our transition notation to action sequences, we write p w −→ p if there exists a run p  Error-IO transition systems are input-enabled IA with explicit error states, for which we adopt the conventions above: Definition 2 (Error-IO transition system) An Error-IO Transition System (EIO) is a tuple (P, I , O, −→, p 0 , E), where (P, I , O, −→, p 0 ) is an IA and E ⊆ P is the set of error states.In addition, we require that P is input-enabled, i.e., for all p ∈ P and i ∈ I , there exists some p ∈ P with p i −→ p .
In essence, EIO and IA are the same model: a missing input transition at a state in an IA corresponds in EIO to an input transition to an error state.IA is convenient for simulationbased semantics where, simply, a missing input does not have to be matched.However, making errors explicit in EIO removes any prejudice present in the IA-setting as to how exactly error states arising in a parallel composition are avoided.This is why linear-time semantics with their full-abstraction results have been based on EIO.Furthermore, adopting inputenabledness in EIO (as in [11]) lends itself to an easier description of linear-time semantics.Observe that input-transitions to an error state in an EIO do not have to be implemented, and in fact cannot be implemented; this differs from the treatment of input-enabledness in the IO-automata model of Lynch [31].
We now introduce (proper) pruning for EIO, which enables one to translate between EIO and IA: Definition 3 (Pruning) Let P be an EIO.Then, e ∈ E is canonical if it is the only error state, has exactly a loop for each input as its outgoing transitions and, if p α −→ e, then α ∈ I and p has no other α-transitions.
A state p is illegal if an error state can be locally reached from p, i.e., reached via outputand τ -transitions only.We obtain EIO prune(P) from P in two steps: first, we remove all illegal states and, additionally, each input transition p i −→ p for which there is some illegal state p with p i −→ p .Second, we add a new error state e with ingoing transitions that ensure input-enabledness and make e canonical.If p 0 is illegal, then e is also initial.
In [10], it is shown that, when applying this proper pruning, each EIO P is equivalent to prune(P) according to our first linear-time refinement (cf.Sect.4.2).We prove in Sect. 4 that this also holds for the other linear-time refinements.

Remark 4 (Translating between EIO and IA)
IAs can be understood as special EIOs by adding a canonical error state as above.Thus, an input i missing at some state p of an IA is translated to the transition p i −→ e. Conversely, one can normalise an EIO P to prune(P) and then remove the canonical error state and the adjacent transitions to get a corresponding IA.If prune(P) only consists of the error state, it corresponds to the "undefined IA" that arises from an undefined parallel composition.
All previously known linear-time preorders (see Sect. 4) have been defined on EIOs in the literature, while all branching-time preorders (see Sect. 5) are defined on IAs.By the above remark, we may still compare linear-time to branching-time preorders, by lifting the preorders from IA to EIO or vice versa.We now define parallel composition on EIO, which is a multicast because an output of one EIO can synchronize with inputs from several other EIOs in its environment.This differs from broadcast in that all potential receivers must be ready to synchronize.Naturally, the receivers synchronize on their common inputs.

Definition 6 (EIO-parallel composition) Two EIOs P 1 and
, and the transition relation −→ is the least relation satisfying the following rules: −→ e 2 .In this case, ( p 1 , p 2 ) is illegal in P 12 and an error in P 1 ⊗ P 2 .Consequently, the illegal states in the IA-setting are the illegal states in the EIO-setting without the error states.This shows that on EIO coincides with | on the subclass IA of EIO.
In the original papers on IA [12,13], parallel composition is only applied to strongly composable IAs P 1 , P 2 -i.e., they are composable and I 1 ∩ I 2 = ∅-and immediately followed by hiding of the synchronized actions.This can be expressed in our setting as . Thus, the precongruence results for IA-parallel composition and hiding imply the precongruence property for the original IA-operator.In contrast to IA-parallel composition, observe that, with the original operator, only two components synchronize on a common action.

Linear-time preorders
This section investigates the linear-time spectrum for EIO.We largely follow [38] by studying the error semantics of [10,11], the quiescence and divergence semantics of [38] and the CJKsemantics of [11], and we also consider our new ready semantics.For each case, we show how to determine the semantics for a parallel composition and for an application of hiding from the semantics of the underlying components.This implies that the refinement preorders accompanying the semantics are precongruences; indeed, full-abstraction results are known for error, quiescence and divergence semantics [38].New contributions by us are, besides the addition of ready semantics (see Sect. 4.6), the equivalence results on pruning, a closer look at the CJK-semantics (see Sect. 4.5) and a variation of quiescence semantics (see Sect. 4.3).

Basic requirements, preorders and properties
The preorders to be considered for our linear-time spectrum compare EIOs having the same signature and, thus, the same interaction potential.Our basic requirement of a preorder is that a refinement, i.e., the smaller EIO, avoids errors whenever the specification, i.e., the larger EIO, avoids errors; here, avoiding an error means that an error state is not locally reachable, as discussed above.We write B E for the basic preorder that obeys just this preservation property.
In addition, for a preorder to be practically applicable, one expects that it enables compositional reasoning, i.e., that it is a precongruence.Ideally, a refinement precongruence does, at the same time, not unnecessarily distinguish EIOs, i.e., it is fully-abstract wrt. the initial, basic preorder and the EIO operators.Mathematically, this means with regards to B E that the desired fully-abstract preorder characterizes the coarsest precongruence C E contained in B E .Below we first establish full-abstraction wrt.parallel composition, and then show the precongruence property wrt.hiding, i.e., full abstraction also holds for full EIO.
While avoiding errors is obviously the basic observable on which a system designer wishes to base a preorder for interfaces, one may also consider two further observables that are extensively studied in the concurrency literature [42]: quiescence and divergence.This leads to the two basic preorders B Qui and B Div and their fully-abstract counterparts C Qui and C Div , resp., which are studied below for EIO.Intuitively, a state avoids quiescence, if it cannot locally reach a state that has only input transitions, i.e., in which the system cannot progress on its own.The state avoids divergence, if it cannot locally reach a state that is divergent, i.e., in which an infinite run of τ -transitions starts.Hence, we obtain the following definition [38]: Definition 10 (Faults and preorders) In addition to the errors contained in the definition of EIO, we consider the two following sets of observable faults for an EIO P: the set Qui(P) of quiescent states given by { p ∈ P | ∀ω ∈ O τ .p ω −→} and the set Div(P) of divergent 123 states defined by { p ∈ P | p has an infinite run of τ -transitions}.We say that P avoids errors/quiescence/divergence, if no error/quiescent/divergent state is locally reachable.
For EIOs P 1 , P 2 with the same signature, we write (i) P 1 B E P 2 , (ii) P 1

B
Qui P 2 and (iii) P 1 B Div P 2 whenever P 1 avoids (i) errors, (ii) errors and quiescence, (iii) errors and quiescence and divergence, resp., provided P 2 does.As explained above, C E , C Qui and C Div are the fully-abstract preorders for EIO-parallel composition and B E , B Qui and B Div , resp.
The characterizations of the desired fully-abstract preorders rely on traces that are often obtained via pruning and continuation operations [10]: Definition 11 (Pruning and continuation functions) Let P be an EIO, the empty word and P(M) the power set of a set M.
prune() : Intuitively, pruning is needed because a trace reaching an error state directly is as good as a trace that reaches a state that can locally reach an error state.Another operation on traces required in the sequel is parallel composition: Definition 12 (Parallel composition on action sequences) Let P 1 , P 2 be EIOs.
-The parallel composition w 1 w 2 of words w Obviously, the traces of a parallel composition are in close correspondence with the traces of each parallel component: Lemma 13 Let P 1 , P 2 be composable EIOs and P 12 be their parallel composition.
We call the second and third (underlying) run in the above first part the projections of the first run.

Preserving freedom from errors
Our technical considerations start off with the basic case of error avoidance, reciting the results of [10,38] (cf.also [11]).The following trace languages are required for characterizing the fully-abstract precongruence C E : Definition 14 (Error semantics) Let P be an EIO.We define the following: -Strict error traces: We call (ET(P), EL(P)) the error semantics of P. For EIOs P 1 , P 2 with the same signature, we write P 1 E P 2 if ET(P 1 ) ⊆ ET(P 2 ) and EL(P 1 ) ⊆ EL(P 2 ).From the semantics' name, we derive that P 1 is an error-refinement of P 2 , and EIOs error-refining each other are error-equivalent, and similarly for the other linear-time semantics.
The error semantics adds to the error traces only the error-flooded language.Thus, E corresponds to language inclusion in the standard linear-time branching-time spectrum [41][42][43].As a purely denotational model, error semantics has already been introduced by Dill [16].Note that E strictly refines B E : on the one hand, we show below that C E and E coincide.On the other hand, consider the EIO consisting of a single, initial, non-error state with an o-loop and a similar EIO without any transition.Obviously, the former is related to the latter according to B E but not according to E .The above definition reflects our intuitive understanding of a refinement semantics that preserves error avoidance, where both the direct reachability of errors (cf.strict error traces) and their indirect reachability via states that can locally reach error states (cf.pruned error traces) are relevant.Once some error manifests itself, any further behaviour does not matter, so that all continuations of error traces must also be considered to be error traces, leading to an error-flooded language and a notion of error semantics for which the following properties and, in particular, full-abstraction hold [10]: Theorem 15 (Error semantics for EIO-parallel composition) For composable EIOs P 1 , P 2 and their parallel composition P 12 : Hence, E is a precongruence wrt.EIO-parallel composition.Furthermore, E is fullyabstract, i.e., it coincides with C E .
The precongruence result is implied by the first two items since cont(), prune() and are monotonic on languages.The same argument applies in analogous situations below.We leave out the full-abstraction proof here; an example of such a proof is given below for the more involved quiescence semantics (see Theorem 21).
Theorem 16 (Error precongruence for hiding) Let P be an EIO and H ⊆ O.Then, Hence, E is a precongruence wrt.hiding, too.
This precongruence result is implied by the fact that hiding turns outputs into internal τ s and, thus, preserves local reachability.The next theorem has been shown in [10]; we prove it here for the present variant of EIOs that requires input-enabledness: Theorem 17 (Pruning) Each EIO P is error-equivalent to prune(P).
Proof Assume that p 0 is not illegal; otherwise, the claim is clear.To show ET(P) ⊆ ET(prune(P)), it suffices to consider a prefix-minimal w ∈ ET(P), because both sides are continuation-closed.Obviously, w ∈ PrET(P) and a suitable underlying run ends with p i −→ p , where i ∈ I and p is illegal while p is not.Because all i-transitions exiting p 123 are removed to obtain prune(P), we get a new p i −→ e.Thus, w ∈ ET(prune(P)) and the first inclusion is established.Next, consider some w ∈ L(P).Either, some run underlying w is still in prune(P) and w ∈ L(prune(P)).Or, some transition of the run is missing and redirected to e; then, some prefix of w and, thus, also w is in EL(prune(P)).
For the reverse inclusions, first consider a prefix-minimal w ∈ ET(prune(P)).An underlying run ends with p i −→ e, where i ∈ I and p = e.This run also exists in P up to the last transition and p i −→ p for some illegal p , implying w ∈ ET(P).Second, each run of prune(P) exists in P as well, except if some transition along the run ends in e in prune(P) and in some illegal p in P.This implies L(prune(P)) ⊆ EL(P).
Consequently, we may essentially work on EIOs without error states.
We conclude by remarking on how component compatibility is reflected in linear-time semantics.In fact, this notion is not so relevant for EIO, because parallel composition is always defined for composable EIOs.In Sect.2, we have explained that components are incompatible if the initial state of their composition is illegal.Here, we have that the initial state of an EIO P is illegal if and only if ∈ ET(P).Error-refinement preserves compatibility: if

Preserving freedom from quiescence
This section adds quiescence as an observable fault [38], which requires us to extend error semantics by quiescence traces, or qsc-traces for short.Analogous to our various kinds of error traces, we consider strict qsc-traces and error-flooded qsc-traces: We call (ET(P), QET(P), EL(P)) the quiescence semantics of P. For EIOs P 1 , P 2 with the same signature, we write P 1 Qui P 2 if P 1 E P 2 and QET(P 1 ) ⊆ QET(P 2 ).
For this refinement preorder, we now show some details how to prove full abstraction.The following lemma is easily seen with Lemma 13.Observe that if, say, p 1 enables an output o, so does ( p 1 , p 2 ) by input-enabledness.

Lemma 19
Let P 1 , P 2 be EIOs and P 12 be their parallel composition.This lemma is essential for proving that Qui is compositional for parallel composition [38]: Theorem 20 (Quiescence semantics for EIO-parallel composition) For composable EIOs P 1 , P 2 and their composition P 12 :
Proof The first and the third part have been shown already for the previous setting in [38]; we recall the proof for the second part and note that ET(P 12 ) is contained in both sides.For the inclusion, we only have to consider some w ∈ StQT(P 12 ), and this is in QET(P 1 ) QET(P 2 ) by Lemma 19 (2).For the reverse inclusion, it suffices to consider some w 1 ∈ QET(P 1 ) and w 2 ∈ QET(P 2 ).If w 1 , say, is an error trace, then w 1 w 2 is in ET(P 1 ) EL(P 2 ) ⊆ ET(P 12 ) by the first part.Otherwise, w 1 w 2 consists of strict qsc-traces, again by Lemma 19 (2).
The precongruence result follows by monotonicity of cont(), prune() and .
It is relatively easy to show that Qui is as fine as C Qui , see the treatment of the reverse implication in the next proof.What is missing then is a proof that a precongruence wrt.

EIO-parallel composition that refines B
Qui is as fine as Qui , i.e., that Qui is fully-abstract.What we prove is actually stronger: it suffices to be interested in a relation that is compositional wrt.just for partners and that refines B Qui just on systems without inputs.On such systems, which result from the composition with a partner, local reachability coincides with reachability.That we do not want to introduce a reachable error or quiescence in a refinement step if there was none initially, is possibly even more convincing than the same for local reachability.To prove the implication, we only use that C Qui has the two properties just declared to be sufficient [38]: Theorem 21 (Full abstraction for quiescence semantics) For EIOs P 1 , P 2 with the same signature, ( 1 (2) Next, we give an impression of how to prove the second statement.We restrict ourselves to partners with I U = O 1 and O U = I 1 ∪ {o} for a fresh action o.This action allows the partner to prevent quiescence.In fact, ET(P 1 ) ⊆ ET(P 2 ) and EL(P 1 ) ⊆ EL(P 2 ) are shown in [38] with partners that enable o in each state such that quiescence does not play a role.We only recall the proof for QET(P 1 ) ⊆ QET(P 2 ) [38]: Due to ET-inclusion, it suffices to prove that any w = a 1 • • • a n ∈ StQT(P 1 ) with n ≥ 0 is also in QET(P 2 ).We construct the partner EIO U as shown in Fig. 4, where E U = ∅.Clearly, w reaches a quiescent state in U P 1 and consists of outputs only.By assumption, also U P 2 can locally reach an error state or quiescent state.
(a) If an error is reached locally, U and P 2 each perform some a 1 • • • a i u with some u ∈ I * U = O * 1 in the respective run.With this, P 2 reaches a state in E 2 , because U does not have any errors.Thus, prune(a This implies that a 1 • • • a i and also w are in ET(P 2 ) ⊆ QET(P 2 ).Quiescence is the counterpart of deadlock in standard LTS, and quiescence semantics and failure semantics [7] are just right to avoid these in the resp.settings.Hence, we can regard the former semantics as the counterpart of the latter.In failure semantics, each trace is combined with a set of visible actions that are impossible in some state that can be reached by the trace.Such a set is not needed here, because synchronization is of a different nature in the IA-setting.More precisely, the above semantics corresponds to stable failures, where sets are only considered for stable states.Quiescence semantics can also be seen as the counterpart of completed traces as defined by van Glabbeek [42].
Because hiding transforms one local action to another, the quiescence status of a state is not changed.Therefore, the following result holds (cf.Theorem 17 and [38]): Theorem 22 (Quiescence precongruence for hiding) For EIO P and H ⊆ O: Hence, Qui is a precongruence wrt.hiding.
Analogous to the situation in error semantics, we add to the results of [38] that pruning an EIO preserves its quiescence semantics:

Theorem 23 (Pruning) Each EIO P is quiescence-equivalent to prune(P).
Proof In view of Theorem 17, we only have to deal with the QET-sets.As in the proof of that theorem, we assume that p 0 is not illegal.For a strict qsc-trace w of P, a suitable underlying run still exists in prune(P), or it is cut because a prefix of w can lead to an illegal state.Thus, w ∈ QET(prune(P)).Conversely, a run in prune(P) underlying a strict qsc-trace w / ∈ ET(prune(P)) also exists in P.
The authors of [11] use the same definition of quiescent state as we do, but regard it as necessary to consider divergence when dealing with quiescence.Their intuition could be that a system can be stuck in a divergent state, just as it can be in a state with only inputs.This view could be supported by the notion of complete traces in [44], which includes strict div-traces.With such a view, divergence and our quiescence are regarded as faults, and the coarsest precongruence is Div , presented in Sect.4.4.
Another variant is to define a state p ∈ P as quiescent if there is no output o with p o ⇒.Due to τ -transitions, such a p might not be quiescent in our sense, so we call it weakly quiescent.Let wQui(P) be the set of these states.Starting from wQui(P), we can modify the definitions of StQT(P), QET(P) and Qui to obtain wStQT(P), wQET(P) and wQui .Similarly, we can define weak versions of B Qui and C Qui .Because we have given all quiescence-relevant proofs for Theorems 20 and 21, it should not be hard to check that the easy Lemma 19 as well as the 'weak versions' of the two theorems hold.Thus, we have also a full-abstraction result for this variant of quiescence.Unfortunately, this is not really satisfactory, because wQui is not a precongruence for hiding, as can be seen from P, P in Fig. 5.Both EIOs have no errors and the same traces, as well as wStQT(P) = wStQT(P ).After hiding o, however, ∈ wStQT(P) but / ∈ wStQT(P ).Developing a fully-abstract precongruence for parallel composition and hiding with this variant of quiescence is an open problem.

Preserving freedom from divergence
Lastly, we add divergence as a third observable for a fault in EIO and, therefore, consider divergent traces, too [38].Note that divergent behaviour of some component cannot be prevented when placing the component in any environment and, thus, not only errors but also divergences are catastrophic.Consequently, in addition to strict divergent traces, their pruned and continuation variants are also of interest: This leads to the definition of divergence semantics [38], for which the quiescence semantics from above needs to be modified by flooding with div-traces: Definition 25 (Divergence semantics) Let P be an EIO.We define the following: -Error-div-traces: EDT(P) = df DT(P) ∪ ET(P); -Flooded qsc-traces: QDT(P) = df StQT(P) ∪ EDT(P); -Flooded language: EDL(P) = df L(P) ∪ EDT(P).
The divergence semantics here is the counterpart to the failure-divergence semantics of [7].
In a divergence-sensitive setting, precongruence for hiding usually needs some finiteness condition.For simplicity, we restrict ourselves to finite EIOs and to the hiding of single outputs as in [38].Hiding of finite sets can be obtained by repeating such hiding.Hence, Div is a precongruence wrt.hiding.
The finiteness requirement on EIO P in this theorem may be replaced by the weaker requirement that P is image-finite.We have chosen finiteness because this is also assumed in [38] and, throughout, in [11].
Divergence semantics yields a new, analogous theorem regarding pruning insensitivity as above for error semantics and quiescence semantics:

Theorem 28 (Pruning) Each EIO P is divergence-equivalent to prune(P).
Proof Again, we assume that q 0 is not illegal.For the EDT-semantics, we already know that pruning preserves the ET-semantics.For a prefix-minimal w ∈ DT(P), a suitable underlying run still exists in prune(P), or it is cut because a prefix of w can lead to an illegal state.Thus, w ∈ EDT(prune(P)).A run in prune(P) underlying a strict div-trace w / ∈ ET(prune(P)) also exists in P. Together, pruning preserves the EDT-semantics.
For a strict qsc-trace w of P, we can argue as in the proof of Theorem 23 that w ∈ QET(prune(P)) ⊆ QDT(prune(P)).A run in prune(P) underlying a strict qsc-trace w / ∈ ET(prune(P)) also exists in P, and preservation of the QDT-semantics follows.
The arguments for preservation of the L-semantics are the same as in the proof of Theorem 17, again because the ET-semantics is contained in the EDT-semantics.
We end this section by discussing the implications of the weak quiescence variant on the divergence semantics; recall the definitions at the end of Sect.4.3.

Remark 29
Adapting the divergence semantics to this weak variant, we let QDT(P) be built upon wStQT(P) instead of StQT(P), resulting in wQDT(P).This semantics can only differ from divergence semantics, if there is some w ∈ wStQT(P)\StQT(P) due to some p 0 w ⇒ p ∈ wQui(P).Because p / ∈ Qui(P) by choice of w, it has a τ -transition to some p .However, due to p ∈ wQui(P), it cannot reach by τ -transitions a state that enables an output.The same applies to p , so we have p 0 w ⇒ p ∈ wQui(P).Repeating this argument, p is seen to be divergent.We conclude that w ∈ QDT(P), so the weak variant of divergence semantics coincides with the one of Definition 25.Similarly, B Div does not change for weak quiescence, and full abstraction holds for the variant because we would only change the text of the definitions but not the relations.

CJK-semantics
Another quiescence-and divergence-sensitive precongruence is presented by Chilton et al. [11] and denoted here by CJK .This is based on sets like ET(•) and EL(•), too, but ET(•) is not closed under pruning, and this difference carries over to the other semantic sets like EL(•).To compensate this, refinement is not component-wise inclusion.Here, we give a new characterization of CJK in the style of the above precongruences: Definition 30 (CJK-semantics) Let P be an EIO.We define the following: -Error-flooded strict div-traces: ESDT(P) = df StDT(P) ∪ ET(P); -ESD-flooded strict qsc-traces: ESDQ(P) = df StQT(P) ∪ ESDT(P).
Observe that, as CJK-refinement works with strict div-traces, it is finer than Div where div-traces are closed under pruning and continuation.Our new characterization leads to new equations in the next theorem; they look quite similar to those in [11], but the proof obligations are a bit different so that we provide the theorem's proof.
Proof We start with the first equation and note that both sides contain ET(P 12 ).For inclusion, consider a strict div-trace of P 1 P 2 .It projects to a strict div-trace of one component and a trace of the other, so it is contained in the right-hand side.For the reverse inclusion, consider w.l.o.g.some w ∈ ESDT(P 1 ) EL(P 2 ) that is not an error trace.Then, w| A 1 is a strict divtrace and w| A 2 is a trace, so w is a strict div-trace.The proof of the second equation is similar, except that a strict qsc-trace projects to two strict qsc-traces, and w is not an error trace or a strict div-trace.
At this stage, we can discuss the patterns that appear when determining the semantic sets of a parallel composition.A strict error trace (div-trace) of the composition projects to a strict error trace (div-trace) of one component and a trace of the other.This explains subsets such as ET(P 1 ) EL(P 2 ), EDT(P 1 ) EDL(P 2 ) and ESDT(P 1 ) EL(P 2 ).The resulting sets are not necessarily closed under pruning, so EDT(P 12 ) and ET(P 12 ) have to be closed under pruning and then under continuation.For a trace or strict qsc-trace, both projections must be traces or strict qsc-traces, leading to EL(P 1 ) EL(P 2 ), EDL(P 1 ) EDL(P 2 ), QET(P 1 ) QET(P 2 ), QDT(P 1 ) QDT(P 2 ) and ESDQ(P 1 ) ESDQ(P 2 ).
The resp.semantic sets are flooded with the pruning-and continuation-closed sets ET(•) or EDT(•).But though, e.g., EL(P 1 ) EL(P 2 ) contains (ET(P 1 ) EL(P 2 ))∪(EL(P 1 ) ET(P 2 )), it might fail to contain all pruned error traces of the composition.Hence, ET(P 12 ) (EDT(P 12 )) has to be added to get EL(P 12 ) (EDL(P 12 )), and the case of ESDT(P 12 ) is similar.For QET(P 12 ) and QDT(P 12 ), even some strict error or div-traces may be missing, because these semantic sets might not cover the language.The same argument (for strict div-traces) shows that, for ESDQ(P 12 ), adding ET(P 12 ) might not suffice.
Hiding can be handled similarly to the resp.results above; see [11] for details.Again, pruning of an EIO preserves the semantics.For the proof, one can argue for strict div-and qsc-traces as for strict qsc-traces in the proof of Theorem 23.

Ready semantics
This section adds to the class of linear-time refinements for IA a counterpart to standard ready semantics [42].In that semantics, for each run, its trace is combined with the set of visible actions offered in the state that is reached by the run.Due to input-enabledness, only local actions are relevant here.But also without the assumption, one should proceed this way: inputs that are missing in a state give rise to error traces and, thus, have some visibility already.Inputs that are possible in a state but missing in another state reached by the same trace, are not so relevant, because the environment would risk an error when providing such an input; we assume that the environment does not do this.Thus, and consistent with the above notion of quiescence, we include all actions that, in the resp.state, can prevent such a quiescence.

Definition 33 (Ready semantics)
Let P be an EIO.We define the following: -Strict ready pairs: We call (ET(P), RP(P)) the ready semantics of P. Note that EL(P) can be derived as {w ∈ A * | ∃X ⊆ O τ .(w, X ) ∈ RP(P)}.For EIOs P 1 , P 2 with the same signature, we write P 1 Rd P 2 if ET(P 1 ) ⊆ ET(P 2 ) and RP(P 1 ) ⊆ RP(P 2 ).

RP(P
Hence, Rd is a precongruence wrt.EIO-parallel composition. Proof For the second equation, consider some (w, X ) in the left-hand side and the projections ⇒ p 2 by Lemma 13.Because the ready set X of ( p 1 , p 2 ) is the union of the ready sets of p 1 and p 2 by input-enabledness, (w, X ) is contained in the right-hand side as well.
If (w 1 , X 1 ) and (w 2 , X 2 ) satisfy the conditions on the right-hand side, each w i is contained in the resp.flooded language.If one of them is an error trace, then w is as well.Otherwise, there are suitable runs p 01 ⇒ p 2 and, in both cases, we are done as above.
Because only outputs are hidden when applying our hiding operator, each ready set is modified by deleting hidden outputs and adding τ if some output is deleted.This also works for a ready pair in which the trace is an error trace; adding τ is not necessary here.
Theorem 35 (Ready precongruence for hiding) Let P be an EIO and H ⊆ O.Then,
Again, pruning of an EIO preserves the semantics: Theorem 36 (Pruning) Each EIO P is ready-equivalent to prune(P).
Proof Analogously to above, we just have to deal with the strict ready pairs and assume that p 0 is not illegal.Also, it suffices to consider a pair in which the trace is not an error trace.
The underlying runs are the same in both EIOs, and the transitions exiting from the reached state are only modified if they are inputs.

The linear-time IA-spectrum
The resulting overall spectrum of linear-time preorders on EIO is shown in Fig. 6: Theorem 37 (Linear-time IA spectrum) All inclusions between E , Qui , Div , CJK and Rd are depicted in Fig. 6 as arrows; note that these inclusions are strict.
Proof The inclusions of the preorders except for Rd have been established in [38].In case an inclusion holds, this is because the semantic sets needed in the larger preorder can be determined from the sets employed by the smaller preorder.This is also the case for the inclusion of Rd in Qui : from RP(P), one can read off EL(P) as noted above, and QET(P) = {w | (w, ∅) ∈ RP(P)}.
The proofs that the missing inclusions fail to hold, are by example.In particular, Qui is not included in Rd as can be seen from EIOs Q 1 and Q 2 in Fig. 7, for which Q 1 Qui Q 2 but Q 1 Rd Q 2 due to the ready pair ( , {o}).Observe that no state is quiescent or an error.To check that no other preorder implies Rd , it suffices to show that CJK is not included in Rd .Consider EIOs Q 3 and Q 4 in Fig. 7, for which Q 3 CJK Q 4 because the additional strict quiescent trace in Q 3 is covered by the divergence .However, Q 3 Rd Q 4 due to the ready pair ( , ∅).It remains to show that Rd is not included in Div .For this, we refer to the EIOs Q 5 and Q 6 in Fig. 7, where Q 5 Rd Q 6 but Q 5 Div Q 6 .Note that Q 6 also has the ready pair ( , {τ }) by staying in its initial state.The other counterexamples for failing inclusions are given in [38].It might be instructive to recall why Div is not included in any of the other preorders.Simply take Q 5 and div-equivalent EIO consisting of a single, initial error-state.

Branching-time preorders
This section develops the branching-time spectrum for IA.It first recalls de Alfaro and Henzinger's original IA-refinement [12], as well as their notion of alternating simulation that they adopted four years later in [13].Whereas the former preorder is defined on general IA, the latter requires input-determinism in order to be a precongruence for parallel composition.Possibly, the former preorder was abandoned by de Alfaro and Henzinger as parallel composition is not associative in the setting of [12], unless our proper pruning is applied or, alternatively, the setting is restricted to input-deterministic IA as in [13] (cf.Sect.2).Below, we first characterize both preorders in terms of standard simulations (see Theorems 42,45), discuss a couple of preorders studied by Göhrle [21] that lie in-between, and adapt ready simulation to the IA-setting.We then introduce several bi-variant variations [3] of alternating simulation, including IA-bisimulation.We conclude this section by proving that (almost) all considered preorders are precongruences for IA, possibly under some restrictions, and by presenting the branching-time IA-spectrum, for which we also study its relationships with the linear-time spectrum of Sect. 4.
We start off by introducing several kinds of initial action set for a state p in a given IA P, which are needed in the definitions of the branching-time preorders: Intuitively, I ∀ ( p) and O ∃ ( p) capture the guaranteed inputs and possible outputs of p, resp., while I( p) ⊇ I ∀ ( p) contains all inputs that are immediately enabled at p.

Original IA-refinement
We revisit the first refinement preorder devised by de Alfaro and Henzinger for IA [12], which we call IA-refinement IA .Our definition adopts the phrasing employed by Chilton et al. [11]: Definition 38 (IA-refinement) For IAs P, Q with the same signature, R ⊆ P × Q is an IA-simulation if the following conditions hold for all ( p, q) ∈ R: IA-refinement is a preorder and defined on the basis of a simulation with a couple of nonstandard features.First, the step of the implementation side requires one to also consider steps with leading τ s; although τ -transitions do not have to be matched explicitly, in general many more matches have to be found than is usual for a simulation.Furthermore, the step on the specification side does not allow trailing τ s.Second, there is an unusual superset inclusion on I ∀ (•).The idea is that I ∀ (•) contains the guaranteed inputs, and only the guaranteed inputs in the specification are simulated.This is because the environment cannot rely on other inputs, i.e., those that can be dropped after some τ -transitions.The environment does not send such an input in order not to cause an error and, thus, the implementation does not have to provide it.Finally, observe that the second condition follows from the third, so we ignore the former in the following.We can also ignore O ∃ ( p), replacing it by the output alphabet O in the third condition.
Next, we define a standard simulation combined with the idea of guaranteed inputs, called (input) acceptance refinement acc , which turns out to characterize IA-simulation.Our definition closely resembles I4-refinement 4  sacc of Göhrle's Master's thesis [21].Indeed, his definition differs only in the first condition from ours, where he demands I ∀ (q) ⊆ I( p).Definition 39 (Acceptance refinement) For IAs P, Q with the same signature, R ⊆ P × Q is an (input) acceptance simulation if the following conditions hold for all ( p, q) ∈ R: P acc-refines Q, in signs P acc Q, if ( p 0 , q 0 ) ∈ R for some acceptance simulation R.
The term acceptance refinement uses acceptance sets, which is the name Hennessy adopted for ready sets in the following context with standard labelled transition systems [23]: he requires that an implementation state has a larger ready set than the specification state that it refines.Hence, if the implementation refuses an action set, then the specification also refuses this action set.This leads to a compact representation for checking failures inclusion [7].
For the proof of the coincidence of IA-refinement and acceptance refinement, we employ a saturation on simulation relations: Definition 40 (Saturation) For IAs P, Q and R ⊆ P × Q, we define: 123 We can now prove the desired characterization result, which was not noticed by Göhrle [21]: Proof For inclusion "⊆", consider some IA-simulation R and its saturation R L according to Definition 40.Assume ( p , q) ∈ R L due to ( p, q) ∈ R and further p α −→ p .For α = τ , a suitable match exists due to the third condition of Definition 38.If α = τ , then p ⇒ p and ( p , q) ∈ R L by saturation.Hence, R L is an acceptance simulation.
Regarding inclusion "⊇", let R be an acceptance simulation and consider its rightsaturation R R .Assume ( p, q ) ∈ R R due to ( p, q) ∈ R. First, we note that I ∀ (q ) ⊆ I ∀ (q) ⊆ I ∀ ( p).Now, let p ⇒ p a −→ p for a ∈ I ∀ (q) ∪ O.By repeated application of acceptance simulation, one obtains q ⇒ q ⇒ a −→ q ⇒ q for some q , q and q with ( p , q ), ( p , q ) ∈ R. Note that a ∈ I ∀ (q ) if a ∈ I ∀ (q).Hence, q ⇒ a −→ q and ( p , q ) ∈ R R , and R R is an IA-simulation.

Standard IA-refinement
Today's understanding of the IA-setting considers alternating simulation alt [13] as the refinement preorder on IA: Definition 43 (Alternating simulation) For input-deterministic IAs P, Q with the same signature, R ⊆ P × Q is an alternating simulation if the following conditions hold for all ( p, q) ∈ R: P alt-refines Q, in signs P alt Q, if ( p 0 , q 0 ) ∈ R for some alternating simulation R.
Note that this preorder is only defined on input-deterministic IA.This is because, otherwise, alt-refines is not a precongruence for parallel composition, independent of the pruning used.
As an example, consider the IAs P, Q, R in Fig. 8 (cf.[30]), where P violates inputdeterminism in its initial state.We would have P alt Q because P can obviously match Q's i?-transition.However, the additional i?-branch of P means that P|R is undefined due to backward propagation, whereas Q|R is defined.We show how compositionality can be fixed by providing an alternative definition, which yields a preorder that coincides with alternating simulation on input-deterministic IAs, but is a precongruence for all IAs.The trick is to define a pure simulation that matches only the inputs that are enabled in the specification, as demanded by the first condition of alternating Fig. 8 Example illustrating the need for input-determinism in alt-refines.P and Q have the input alphabet {i} and the output alphabet {o}, and the converse for R simulation.Our resulting strict acceptance refinement sacc does this by adding a condition on initial input action sets, this time concerning all initial input actions I(•) instead of only the guaranteed input actions I ∀ (•) as above.We call our preorder strict, because more inputs have to be matched than in acceptance refinement.
Definition 44 (Strict acceptance refinement) For IAs P, Q with the same signature, R ⊆ P × Q is a strict acceptance simulation if the following conditions hold for all ( p, q) ∈ R: 1. I(q) ⊆ I( p); 2. p i −→ p implies ∃q .q i −→ q and ( p , q ) ∈ R, for all i I(q); 3.
This definition was studied by Göhrle [21] under the name I1-refinement, where also the desired coincidence result was proved: Theorem 45 (Coincidence II) alt = sacc on input-deterministic IAs.
Proof We show that the two types of simulations are the same.For establishing inclusion "⊆", the first condition of alternating simulation implies the first condition of strict acceptance simulation.Further, let p i −→ p be the i-transition of p for some i ∈ I(q); this transition is unique due to input-determinism.Then, q has a unique i-transition q i −→ q .Hence, the first condition of alternating simulation also implies the second condition of strict acceptance simulation.
Regarding inclusion "⊇", let q i −→ q be the unique i-transition of q.The first condition of strict acceptance simulation implies that p has a (unique) i-transition p i −→ p ; these match each other by the second condition.

Further simulations: I2-, I3-refinement and ready simulation
Göhrle also introduced the preorders I2-refinement and I3-refinement [21], which lie inbetween I1-and I4-refinement.In the definitions of his refinements, he successively replaced the conditions of I1 (sacc-simulation) by those of I4 (acc-simulation).This time, a more generous use of τ s when matching a transition makes a difference.
Definition 46 (I2-refinement) For IAs P, Q with the same signature, R ⊆ P × Q is an I2-simulation if the following conditions hold for all ( p, q) ∈ R: Hence, I2-refinement is defined analogously to sacc-simulation, but it allows an ω-transition to be matched by a weak ω-transition that does not only permit leading but also trailing τ s.I3-refinement now relaxes the matching of inputs by permitting leading and trailing τ s: Definition 47 (I3-Refinement) For IAs P, Q with the same signature, R ⊆ P × Q is an I3-simulation if the following conditions hold for all ( p, q) ∈ R: The following result was established in [21], when considering the coincidence of acc with 4  sacc (cf.Theorem 58): Göhrle showed that all these inclusions are indeed strict.Most important for our branchingtime spectrum is the fact that sacc acc .To demonstrate this, we state in Fig. 9 an example that highlights the difference between I3-and I4-refinement; note that I(q 0 ) = {i} and I ∀ (q 0 ) = ∅.
Finally, we adapt ready simulation rs [6] to our IA-setting, which requires related states to have the same ready sets.In particular, all branching-time preorders discussed so far allow one to omit any specified output in an implementation.This is often unsatisfactory in practice, and ready simulation is our first proposal of a preorder that remedies the shortcoming: Definition 49 (Ready simulation) For IAs P, Q with the same signature, R ⊆ P × Q is a ready simulation if the following conditions hold for all ( p, q) ∈ R: This preorder refines acc-refinement by adding the condition on ready sets, which are defined as in Sect. 4. So far, outputs could be removed in a refinement step, whereas here we require the same outputs (and τ s) to be enabled, without insisting that all subsequent behaviour is preserved.Inclusion of τ in a ready set fits our notion of quiescence, so that rs-refinement refines the linear-time ready semantics.

Bivariant simulations and IA-bisimulation
In the τ -free setting of [3], simulations are studied where some actions are simulated in one direction, some in the opposite direction, and others in both directions; the latter are called bivariant.As another proposal for not losing desired outputs during refinement, we define the new preorders (strict) output-bivariant refinement that strengthen (strict) acceptance refinement by requiring that specified outputs are kept; in contrast to rs-refinement, also their subsequent behaviour must be preserved.Observe that strict output-bivariant refinement differs from output-bivariant refinement in the same way that sacc-refinement differs from acc-refinement.
Definition 50 (Output-bivariant refinement) For IAs P, Q with the same signature, R ⊆ P × Q is an output-bivariant simulation if the following conditions hold for all ( p, q) ∈ R: Definition 51 (Strict output-bivariant refinement) For IAs P, Q with the same signature, R ⊆ P × Q is a strict output-bivariant simulation if the following conditions hold for all ( p, q) ∈ R: 1. I(q) ⊆ I( p); In [37], sobs-refinement was studied in a restricted Petri net setting, which adopts certain determinism requirements, and was called correct STG-decomposition.This decomposition allows efficient asynchronous circuits to be developed from large, monolithic specifications.
Here, the compatibility as in IA is crucial, because asynchronous circuits cannot deal with unexpected inputs [16].
Analogously to output-bivariance, we define a version where inputs are bivariant.This is essentially sacc-refinement with the additional condition on matching a specification's inputs.Because the matching of such inputs should be direct, i.e., without leading and trailing τ s, we only define a strict variant, called input-bivariant refinement ibs .Note that the added condition is stronger than the condition I(q) ⊆ I( p) of sacc-refinement, which can thus be omitted.Obviously, ibs ⊆ sacc .
Definition 52 (Input-bivariant refinement) For IAs P, Q with the same signature, R ⊆ P ×Q is an input-bivariant simulation if the following conditions hold for all ( p, q) ∈ R: Observe that allowing trailing τ s in the third condition above would not only deviate from alternating simulation, the resulting refinement would also fail to be transitive and, thus, to be a preorder.Consider the example in Fig. 10: input i of P matches the first i of Q, and 10 Problem regarding the allowance of trailing τ s in the third condition of Definition 52 matches with the lower branch of R. Now, the first i in the upper branch of R is matched by iτ in Q, but cannot be matched in P. Hence, if additional τ s are allowed to match some action in one direction, also single τ s should be matched in this direction.
The strongest behavioural relation typically studied in a linear-time branching-time spectrum [42] is the equivalence bisimilarity a.k.a.observation equivalence [32,34], i.e., a mutually recursive simulation.Our variant ≈ of bisimilarity does not permit extra τ s when matching inputs and only leading τ s when matching outputs, so that ≈ refines sacc-refinement and our bivariant refinements: Definition 53 (IA-bisimilarity) For IAs P, Q with the same signature, R ⊆ P × Q is an IA-bisimulation if the following conditions hold for all ( p, q) ∈ R: P is IA-bisimilar to Q, in signs P ≈ Q, if ( p 0 , q 0 ) ∈ R for some IA-bisimulation R.

Precongruence results
We now give a concise proof that the branching-time preorders presented above are (mostly) precongruences.The precongruence results for de Alfaro and Henzinger's preorders were stated in [12,13], resp., for a binary parallel composition where synchronized actions are hidden.The precongruence proofs can be found, e.g., in Göhrle's work [21] for a slightly different but equivalent characterization of IA-refinement (cf.Theorems 42, 58), and in [30] for alternating simulation.These results are re-proved here for our multicast parallel operator |, and the result for alternating simulation is extended to our notion of sacc-refinement (cf.Theorem 45).Because of Theorems 42 and 45, we do not consider IA-refinement and alternating simulation in the following theorem: Theorem 54 (Precongruence for IA-parallel composition) Let be any one of the preorders except for 3 sacc and obs .Then, for all IAs P, Q, R, where Q, R are composable and compatible and P Q, we have that P, R are composable and compatible and that P|R Q|R.For sobs , this only holds if Q is input-deterministic.
Before proving this theorem, we first note that Göhrle also showed that I2-and I3-refinement are precongruences for the binary parallel operator [21].However, I3-refinement is only a precongruence, if the pruning involved is further strengthened (cf.also [8]); it also fails to be a precongruence for the operator | studied here.This can be seen in Göhrle's example that is reproduced in Fig. 11, where P 3 sacc Q since P's i?-transition can be matched by the τ -and the i-transition of Q.However, when composing both IAs with IA R that has no behaviour τ Fig. 11 Example illustrating the precongruence defect for I3-refinement for general IAs, where the only action in the alphabet of Fig. 12 Example illustrating the precongruence defects for the output-bivariant preorders but input alphabet {o}, the o!-transition raises an error and, thus, the preceding i?-transition is cut by pruning.Hence, P|R 3 sacc Q|R.Regarding our output-bivariant preorders, the example IAs P, Q 1 , R in Fig. 12 testify to the precongruence defect of sobs (and obs ) in the general case.The problem is that the choice between the initial a?-transitions of Q 1 does not matter for sobs (and obs ); however, after synchronization, these inputs are essentially turned into outputs and the lower a!-transition has to be matched.While this defect disappears for sobs when restricting the specification side to input-deterministic IAs, the same is not true for obs .This can be seen (a) from IAs P, Q 2 , R, where Q 2 matches P's a?-transition by the aand the upper trailing τ -transition of Q 2 , and (b) from IAs P, Q 3 , R, where Q 3 matches P's a?-transition by the leading τ -and the upper a-transition of Q 3 .To avoid this problem, one would need to significantly change the second condition of Definition 50, which seems to be too drastic to us.
The proof of Theorem 54 makes use of the following two lemmas.The first lemma collects properties that are shared among several preorders, for ease of reference: Lemma 55 Let be any one of the preorders except for 3  sacc and obs , and let R be a -simulation for IAs P, Q such that ( p, q) ∈ R.

If p i
−→ p then, in all cases, ∃q .q ⇒ i −→ ⇒ q with ( p , q ) ∈ R or, alternatively, If is 2 sacc or requires one to match p ω −→ p with some q ⇒ ω −→ q , then it also requires one to match p i −→ p with q i −→ q for i ∈ I(q).
If is not 2 sacc and the first match is some q ⇒ ω −→ ⇒ q , then the second one is some q ⇒ i −→ ⇒ q for i ∈ I ∀ (q).
5. If I ∀ (•) matters, then a transition p i −→ p with i ∈ I ∀ (q) is matched with some q ⇒ i −→ ⇒ q ; otherwise, the match is some q i −→ q for i ∈ I(q).Proof Let , R and ( p, q) ∈ R be as stated in the lemma.
1. Obvious.(Note that this claim also holds for the preorders that do not allow trailing τ s.) 2. We could have i / ∈ I(q) if I(•) matters, or i / ∈ I ∀ (q) if I ∀ (•) matters.In both cases, the second alternative holds.Otherwise, there exists some q such that q i −→ q or q ⇒ i −→ ⇒ q with ( p , q ) ∈ R, so the first alternative holds.

4.
For ≈ and the first part of the statement, observe that p i −→ p implies i ∈ I(q) by Definition 53(1). 5. See the proof for (4).
Lemma 56 Let be any one of the above preorders except for 3  sacc and obs , and let P, Q, R be IAs with P Q due to the -simulation R and such that Q, R are composable.If (( p, r ), (q, r )) ∈ R = df {(( p, r ), (q, r )) | ( p, q) ∈ R} and ( p, r ) is illegal, then so is (q, r ).
Proof First observe that P, R are composable because P, Q have the same signature (I , O).We now proceed by induction on the length of a run from ( p, r ) to an error state of P ⊗ R. In the base case, ( p, r ) is an error state and there are two sub-cases to distinguish: p a −→ and r a −→ with a ∈ O ∩ I R : Then, q ⇒ q a! −→ for some q by Lemma 55 (1).Hence, (q, r ) ⇒ (q , r ) and (q , r ) is an error.Thus, (q, r ) is illegal.-p a −→ and r a −→ with a ∈ I ∩ O R : By Lemma 55(3), there exists some q such that q ⇒ q a? −→, and (q, r ) is illegal as above.
For the induction step, consider the first transition ( p, r ) ω −→ ( p , r ) of a run of local transitions to an error state, i.e., ( p , r ) is illegal due to a shorter run.There are three subcases: p ω −→ p , r = r and ω ∈ O τ \A R : Then, q ⇒ ω −→ ⇒ q for a q with ( p , q ) ∈ R by Lemma 55(1).Hence, (q, r ) ⇒ ω −→ ⇒ (q , r ) with (( p , r ), (q , r )) ∈ R. State (q , r ) is illegal by induction hypothesis, and so is (q, r ).
a ∈ I ∩ O R : By Lemma 55(2), we might have q ⇒ a? −→ ⇒ q and ( p , q ) ∈ R for some q .Then, (q, r ) ⇒ a! −→ ⇒ (q , r ) with (( p , r ), (q , r )) ∈ R, and we are done.Otherwise, q ⇒ q a −→ for some q , and (q, r ) is illegal as in the second base case.

Proof of Theorem 54
The following proof mainly works for obs and sobs , too.In each of these cases, one proof part fails as indicated below; for sobs , the defect disappears when requiring input-determinism of the specification Q.Now, let be one of the refinements mentioned in the theorem and consider R and R as in Lemma 56.The theorem's statement on composability is trivial because P, Q have the same signature (I , O).Further, we write (I Q R , O Q R ) for the signature of Q ⊗ R. Lemma 56 shows the theorem's statement regarding compatibility.Now, we restrict R to those pairs (( p, r ), (q, r )) where q|r , and hence p|r , is defined; we call the restriction R .The sequel considers some (( p, r ), (q, r )) ∈ R and has a sub-case for each requirement appearing in the definition of at least one of our relations: (Pω) Assume p|r ω −→ p |r .Then, requires q|r ⇒ ω −→ q |r (or q|r ⇒ ω −→ ⇒ q |r , which can mostly be handled analogously) for some q with ( p , q ) ∈ R.There are four sub-cases needed to show this: p ω −→ p , r = r and ω / ∈ A R : Then, we have q ⇒ ω −→ q for some q with ( p , q ) ∈ R, implying q|r ⇒ ω −→ q |r , where all states on this run are defined since q|r is.−→, then we would have (q, r ) ⇒ (q , r ).The latter state would be an error, contradicting that q|r is defined.Thus, ω ∈ I ∀ (q) ⊆ I(q).By Lemma 55(4), there is q ω −→ q with ( p , q ) ∈ R. Hence (also for 2 sacc ), we have q|r ω −→ q |r (cf. the first sub-case) and are done.
In the case in brackets, there is some q with q ⇒ ω −→ ⇒ q and ( p , q ) ∈ R.
(I ∀ (•)) Assume that requires I ∀ (q|r ) ⊆ I ∀ ( p|r ).In a product like P ⊗ R, we have ; in particular, note that some i ∈ I ∀ ( p)\I R could be an output of the composition, so we need to intersect with I Q R .Therefore, I ∀ (q|r) ⊆ I ∀ ( p|r ) could only fail for some i ∈ ) for some illegal ( p , r ).From (Pω), we get q|r ⇒ q |r with ( p , q ) ∈ R. Further, consider the following three sub-cases: -If the i-transition is due to r only, we have p = p and (q , r ) i −→ (q , r ).Because ( p , r ) is illegal and (( p , r ), (q , r )) ∈ R, the latter pair is also illegal and also i / ∈ I ∀ (q|r).
-If the i-transition is due to p only, i.e., if r = r and p i −→ p , we may have q ⇒ q i −→ by Lemma 55 (2).Then, q |r ⇒ q |r i −→ and i / ∈ I ∀ (q|r ).
Otherwise, q ⇒ i −→ ⇒ q and ( p , q ) ∈ R. Hence, (q , r ) ⇒ i −→ ⇒ (q , r ) and (( p , r ), (q , r )) ∈ R. Again, (q , r ) is illegal, and so is the state after the i-transition.The state before the i-transition is not illegal because q |r is defined.Thus, i / ∈ I ∀ (q|r ).
- for i ∈ I ∀ (q|r) (or just q|r i −→ q |r for i ∈ I(q|r)) by Lemma 55 (5), for some q with ( p , q ) ∈ R.There are three sub-cases: p i −→ p , r = r and i / ∈ A R : We have i ∈ I ∀ (q) by i ∈ I ∀ (q|r ), and further Then, q|r ⇒ i −→ ⇒ q |r .The states before the i-transition exist because q|r is defined, and the states after because i ∈ I ∀ (q|r).
The other variant with q|r i −→ q |r is easier, where the latter state exists by i ∈ I(q|r).
r i −→ r , p = p and i / ∈ A: Then, (q, r ) i −→ (q, r ) and state q|r is defined by i ∈ I(q|r) ⊇ I ∀ (q|r ).≈) for some p with ( p , q ) ∈ R. We distinguish four sub-cases: q ω −→ q , r = r and ω / ∈ A R : Then, p ⇒ ω −→ ⇒ p with ( p , q ) ∈ R (the other case is almost the same).Thus, p|r ⇒ ω −→ ⇒ p |r and ( p |r , q |r ) ∈ R , and all states are defined since p|r is.-r ω −→ r , q = q and ω / ∈ A: Easier.- hence, p|r ω −→ p |r as above.For sobs , in case that P is input-deterministic, p has an ω-transition, and this must match q ω −→ q in the same way.(Note that this sub-case fails for sobs in general and also for obs .)(Qi) Let q|r i −→ q |r and assume, as is the case for ibs and ≈, that requires p|r i −→ p |r for some p with ( p , q ) ∈ R. Hence, we have three sub-cases: q i −→ q , r = r and i / ∈ A R : Then, there exists some p such that p i −→ p and ( p , q ) ∈ R. Thus, p|r i −→ p |r and the latter state is defined by Lemma 56.
r i −→ r , q = q and i / ∈ A: Obvious.
q i −→ q , r i −→ r and i ∈ I ∩ I R : Similar to the first sub-case.
(R(•)) For rs , observe that R(q|r ) = R(q) ∪ R(r ) because, if an output o of, say, Q is in R(q) and I(r ), then r must provide its input o; otherwise, (q, r ) would be an error state.Now, R(q|r We finish this section by establishing the precongruence property for hiding: Theorem 57 (Precongruence for hiding) Let be any one of the above branching-time preorders.Then, P/H Q/H for all IAs P, Q with P Q and all H ⊆ O.
Proof Assume that P Q holds due to -simulation R. We show that R is also suitable to prove the theorem's statement.First observe that all conditions, except for condition I ∀ (q) ⊆ I ∀ ( p), are obviously preserved.Hence, we establish this remaining condition: If i ∈ I ∀ ( p) is lost in P/H , then there is some run in P from p to p with actions in H ∪{τ } such that p i −→.This run is matched by q to reach some state q with ( p , q ) ∈ R. By Lemma 55(3), there exists some q such that q ⇒ q i −→.Thus, i / ∈ I ∀ (q) in Q/H .

The branching-time IA-spectrum
Overall, our spectrum of branching-time preorders on IA is as shown in Fig. 13; again, arrows display inclusions between the preorders.I4-refinement is not depicted, because it coincides with acc-refinement.Recall that the definition of Göhrle's 4 sacc [21] only differs from acc in the first condition, where he demands I ∀ (q) ⊆ I( p).
Proof Clearly, each acceptance simulation is an I4-simulation.Conversely, consider some I4-simulation R with ( p, q) ∈ R and some input i ∈ I ∀ (q)\I ∀ ( p).Then, there is some p such that p ⇒ p but p i −→.Now, p ⇒ p can be matched according to I4-simulation by q ⇒ ⇒ • • • ⇒ q for some q satisfying ( p , q ) ∈ R. Hence, i ∈ I ∀ (q) ⊆ I ∀ (q ) but i / ∈ I( p ), which is a contradiction to the first condition of I4-simulation.Thus, R is an acceptance simulation.
The strict inclusions between sacc-and acc-refinement have been the subject of Theorem 48 above.The other implications follow because, in each case, a condition is added for the finer refinement.The only exception is the implication from sobs-refinement to obsrefinement: Theorem 59 sobs obs .
Proof For the proof, we define an OB4-simulation just as an output-bivariant simulation, except that we require I ∀ (q) ⊆ I( p) in the first condition.Clearly, each strict output-bivariant simulation R is an OB4-simulation, because the allowed matchings are more generous and I ∀ (q) ⊆ I(q); the latter also implies that fewer inputs have to be matched in the OB4simulation.Now, we repeat the arguments in the proof of Theorem 58 for OB4 in place of I4, obtaining that R is an output-bivariant simulation.Inequality follows from Lemma 60(d) below.
Also the other inclusions omitted in Fig. 13 fail: Lemma 60 (Failing implications) The following properties hold: (a) rs is not included in 3 sacc ; (b) rs is not included in obs ; (c) ≈ is not included in rs ; (d) obs is not included in 3  sacc ; (e) ibs is not included in obs ; (f) sobs is not included in ibs .
Proof First, we prove Parts (a)-(c): (a) Consider P, Q of Fig. 9, where P rs Q due to i / ∈ I ∀ (q 0 ), such that the i-transition of p 0 does not have to be matched.However, P 3 sacc Q, as pointed out before.(b) Let P 1 , P 2 as in Fig. 14.Then, P 1 rs P 2 due to the upper branch of P 2 , but P 1 obs P 2 since the lower branch cannot be matched.(c) For IAs P 3 , P 4 in Fig. 14, P  Last, for Part (f) and P 5 , P 6 in Fig.The above properties of our preorders yield the branching-time spectrum for IA: Theorem 61 (Branching-time IA spectrum) All inclusions between our branching-time preorders are depicted in Fig. 13 as arrows; in particular, these inclusions are strict.
Proof We have shown above that the indicated implications hold.Parts (a)-(c) of Lemma 60 settle the missing implications around rs .Parts (d) and (e) testify to the missing implications for obs , but Part (e) also shows that ibs is not included in sobs .By Part (f), the proof is finished.
Finally, we remark that, when restricting ourselves to input-deterministic IAs, strict acceptance refinement and input-bivariant refinement coincide: Proposition 62 sacc = ibs on input-deterministic IAs.

Completing the spectrum
We conclude the technical part of this article by connecting our branching-time spectrum for IA to the linear-time spectrum studied in Sect.4, recalling that any IA can be understood as an EIO (see Remark 4).
Proof Let P, Q be IAs satisfying P acc Q, and let P , Q be the corresponding EIOs with an additional, canonical error state.Consider a prefix-minimal error trace wi of P , which must end with an input transition to the error state.The same run exists in P, except for the last i-transition.In principle, due to acc-refinement, a run with the same w exists in Q.This fails only if an intermediate i -transition along the run in P is not matched in Q because it is not guaranteed in the resp.state q in Q.In this case, we extend the run in Q from q to a state q that does not enable i .Thus, q has an i -transition to the error state of Q , and we have a prefix w of w that is an error trace in Q .If the translated run exists, i cannot be guaranteed in the last state, because i is missing in P. Now, we repeat the argument for this last state and obtain that wi is an error trace of Q .
A similar argument holds for the languages: for a trace w in P , we either find the same trace in Q or an error trace that is a prefix of w.

Next, we consider our two ready preorders:
Theorem 64 (IA-spectrum) rs ⊆ Rd .
Proof Let P rs Q due to R, and consider wi ∈ StET(P) = PrET(P) due to p 0 w ⇒ p i −→ e.We proceed by induction on the length of the underlying run.Assume that p 0 v ⇒ p due to a prefix of this run, and we have q 0 v ⇒ q for some q with ( p , q ) ∈ R due to induction or because p = p 0 and q = q 0 .Let p α −→ p be the next transition.If α ∈ O τ , then q α ⇒ q for some q satisfying ( p , q ) ∈ R. The same holds for α ∈ I , except if α / ∈ I ∀ (q ).In the latter case, vα ∈ ET(Q) for the prefix vα of w, and we are done.If the latter never happens, we get q 0 w ⇒ q with ( p, q) ∈ R, and i / ∈ I ∀ (q) due to i / ∈ I ∀ ( p).
Thus, q ⇒ i −→ e and wi ∈ ET(Q).Now, it suffices to consider some (w, X ) ∈ StRP(P) due to p 0 w ⇒ p.As above, (w, X ) ∈ RP(Q) due to flooding or q 0 w ⇒ q with ( p, q) ∈ R and R Fig. 15 Example IAs (EIOs) for comparing the linear-time and branching-time preorders However, many inclusions between the preorders presented in this article are invalid, due to following lemma: Lemma 65 (Failing implications) The following properties hold: Proof Regarding Parts (a)-(c), consider IAs R 1 , R 2 in Fig. 15.These are bisimilar, and R 1 rs R 2 due to R 2 staying put in the initial state.However, R 1 Div R 2 due to R 1 being divergent, and R 2 Qui R 1 because only R 2 has a quiescent trace.
Regarding Part (d), examine IAs R 3 , R 4 of Fig. 15.They have the same language and quiescent traces, no (strict) divergent traces, and the same error traces due to the missing input transitions to the implicit canonical error state.Hence, they are CJK-equivalent, but the i-transition of R 3 cannot be properly simulated by R 4 , i.e., R 3 acc R 4 .
Regarding Part (e), the IAs R 5 , R 6 in Fig. 15 satisfy R 5 Rd R 6 but R 5 acc R 6 , analogous to the argument above for Part (d).
This lemma now allows us to conclude this section with the desired theorem for corroborating our IA-spectrum: Theorem 66 (IA-spectrum) All inclusions between the linear-time and branching-time refinement are depicted using dashed arrows in Fig. 6; in particular, these inclusions are strict.
Proof The positive statements are proved in Theorems 63 and 64.Furthermore, rs does not imply any other linear-time preorders by Lemma 65(a).The other branching-time preorders do not imply any linear-time preorder except E , and the linear-time preorders do not imply any branching-time preorder.

Discussion
De Alfaro and Henzinger's IA-setting and its preorders IA-simulation and alternating simulation have influenced the field of interface theories and are closely related to a research direction in model-based testing.In the former field, the majority of recent interface theories are based on Modal Transition Systems (MTS) and the modal refinement preorder [28], which is more expressive than IA [29].In the latter field, the ioco approach [39] uses a trace-comparing relation not unlike alternating simulation.

MTS-based interface theories
Refinement in the IA-setting is characterized by allowing the addition of inputs and the removal of outputs, which implies that, e.g., the single-state interface with a self-loop for every input action and no further transition refines any interface.Thus, output actions in IA specify permitted but not required behaviour.This why recent research [4,9,19,29,35] has focused on combining IA [13] and Modal Transition Systems (MTS) [28]; MTS allows one to specify required and optional behaviour, for any action.Taking stepwise decisions on the optional behaviour permits a component-based, incremental design, which is supported in MTS by the compositional modal refinement preorder.
This research on combining IA and MTS has led to Modal Interface Automata (MIA) [9], which resolves the conflict between unspecified inputs being allowed in IA but forbidden in MTS and does away with the input-determinism requirement of IA.MIA fixes various shortcomings of earlier works: modal refinement in the IOMTS-setting of Larsen et al. [29] is not a precongruence for parallel composition; the MI-setting of Raclet et al. [35] considers deterministic interfaces only; the MIO-setting of Bauer et al. [4] adopts pessimistic compatibility that deems a composition undefined as soon as some error can potentially occur in some system environment.Not unlike EIO [10,38], there is also an error-aware variant EMIA [19] of MIA, which leaves error states explicit and does not prune them away.Thereby, one may distinguish potential errors that can be resolved by refinement, from actual, unresolvable errors that arise when an output is required but the corresponding input is forbidden.
Finally, it should be noted that all MTS-based theories mentioned above are interface theories in the sense that they are equipped also with a conjunction and a quotienting operator.Conjunction is necessary when reasoning about a component that must satisfy several interfaces, while quotienting enables one to calculate residual interfaces when given some partial system implementation.
The ioco approach This approach [39] for model based testing is somewhat related to interface automata, because it allows one to implement unspecified inputs and to ignore specified outputs, at least to some degree.One difference is that the ioco-relation compares an implementation to a specification, i.e., the approach does not aim at stepwise refinement.Furthermore, an implementation is required to be input-enabled.Another and essential difference is that it suffices to provide an input via some preceding τ s; there is no concept of communication error and, in particular, no concern about an input not being provided immediately (cf.[40]).
An additional feature of the ioco-setting is that each quiescent state is decorated with a δ-labelled loop.(Usually, these loops are left implicit.)For δ-decorated models without τ , it is shown in [1], for an input-deterministic implementation P and a deterministic specification Q, that P ioco-implements Q if and only if P alt Q. Conceptually, the ioco-relation compares traces of P and Q and, under the restrictions mentioned, it coincides with quiescence-, divergence-and CJK-refinement due to the δ-transitions.This does not hold without determinism, because our strict quiescence traces just end in a quiescent state, whereas a trace in the ioco-approach can additionally inform about quiescent states passed along the way.
Motivated by the ioco-approach, a refinement based on alternating simulation is introduced in [22] under the name of iocos, which stands for ioco-simulation.The referenced paper considers δ-decorated IAs without τ as models (and without distinguishing implementations and specifications) and defines a natural variation of ioco for these models.The new iocos coincides with IA , except for the additional discrimination due to δ.It is shown in [22] that iocos is finer than ioco and that it can be characterized with a testing scenario; a general parallel composition is not considered.
The very recent paper [26] also looks at stepwise refinement in relation to the iocoapproach and alternating simulation in a setting without parallel composition, precongruence results and internal actions.It introduces input-failure refinement, which is another characterization of error-refinement as in [10,11], although this result is not formally stated or proven.Taking also δ into account, this refinement fits another variant of ioco in the literature called uioco.

Conclusions and future work
De Alfaro and Henzinger's Interface automata (IA) [12] are a popular framework for formally reasoning about the compatibility of concurrently interacting components, for which a sizeable number of behavioural preorders have been proposed in the literature over the years.In this article, we characterized and compared these preorders, both trace-based and simulation-based preorders, so as to arrive at a linear-time branching-time spectrum for IA, in analogy to the linear-time branching-time spectrum of van Glabbeek for ordinary labelled transition systems [42].This was done via a uniform and general notion of parallel composition that constitutes a multicast communication mechanism for synchronizing components, as well as a hiding operator for action scoping.Alongside, we also explored several new preorders for IA, based on ready semantics, ready simulation and bi-variant simulation.
An important insight obtained by our work was that the problem in the original publication on IA [12], namely that parallel composition is not associative, disappears if a proper pruning of states that can locally reach an error state is applied, even for interfaces that are not input-deterministic.Complementing the work of Göhrle [21], we characterized this original preorder of [12], which is coarser than strict acceptance refinement, as a simulation-preorder called acceptance refinement.Thereby, our framework of general interface automata and acceptance refinement paves the way for further investigations into semantic theories for interface automata, without the need for input-determinism.

Future work
We propose to complete the presented IA-spectrum by using van Glabbeek's Linear-Time Branching-Time Spectrum II [42] as guidance.Our spectrum is currently missing, among other behavioural relations, ready trace semantics [33] and possible futures semantics [36] in the lower, linear-time half and branching bisimulation [45] in the upper, branching-time half.These have not yet been considered in the IA-literature.Some of the linear-time preorders studied in this article, namely error semantics, quiescence semantics and divergence semantics, are supported by full-abstraction results.Such results are closely related to observational justifications via testing or button pushing scenarios [15,41,42], which are missing for the remaining linear-time and all branching-time preorders.It would be nice to improve the situation, e.g., using ideas of Abramsky [2].
Concerning the applicability of interface theories, we note that reasoning about communication errors is already employed in the design of asynchronous circuits, which are vulnerable to unexpected inputs (see, e.g., [16,17]).We suggest that IA is developed further towards practical applications in software engineering, for which one would need to consider at least extensions of the model with data (see, e.g., [14,20,24]).As a final note, programming languages such as Go have been extended with session types; these check for communication safety, which is related to communication error in IA [25,27].

123
Dedication We dedicate this article to Rob van Glabbeek, an exceptional researcher and outstanding colleague, on the occasion of his 60th birthday.Foremost, we thank him for the many fruitful discussions that we had on various topics in concurrency theory.We are also grateful for Rob's strong dedication to the scientific community, which led him to establish, with his own time and financial resources, the Electronic Proceedings in Theoretical Computer Science (EPTCS) series, an international, refereed open access venue for the rapid electronic publication of workshop and conference proceedings and other scientific works.
Open Access This article is licensed under a Creative Commons Attribution 4.0 International License, which permits use, sharing, adaptation, distribution and reproduction in any medium or format, as long as you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons licence, and indicate if changes were made.The images or other third party material in this article are included in the article's Creative Commons licence, unless indicated otherwise in a credit line to the material.If material is not included in the article's Creative Commons licence and your intended use is not permitted by statutory regulation or exceeds the permitted use, you will need to obtain permission directly from the copyright holder.To view a copy of this licence, visit http://creativecommons.org/licenses/by/4.0/.

⇒
p if w ∈ A * and ∃w ∈ A * τ .w | A = w and p w −→ p ; we say that the run according to p w −→ p underlies p w ⇒ p , or just w if the context is clear.As above, we write p w −→ for ∃ p .p w −→ p and p w ⇒ for ∃ p .p w ⇒ p .The language L(P) of P consists of all traces of P and is the set {w ∈ A * | p 0 w ⇒}.

Fig. 4 2 a
Fig.4 Partner EIO U in the proof of Theorem 21, where a? = a i represents all a ∈ I U \{a i } and q is the only quiescent state

Fig. 5
Fig. 5 EIO demonstrating the precongruence defect wrt.hiding for the alternative quiescence semantics

w 1 ⇒
p 1 and p 02 w 2

Fig. 6
Fig. 6 Linear-time spectrum: lower half of the IA-spectrum

Fig. 7
Fig. 7 Example EIOs for comparing the linear-time preorders.(No state above is an error state.)

R
L and R R are called the left-saturation and right-saturation of R, resp.Lemma 41If R is an IA-simulation, then so are R L and R R .

Fig. 9
Fig.9 Example illustrating the strict inclusion of I3-refinement in I4-refinement[21] r , a ∈ O ∪ O R : Here, we have to distinguish two sub-cases.

-r ω −
→ r , p = p and ω / ∈ A: Easier.-p ω −→ p , r ω −→ r and ω ∈ O ∩ I R : Similar to the first sub-case.-p ω −→ p , r ω −→ r and ω ∈ I ∩ O R : If q ⇒ q ω If p i −→ p and r i −→ r , we can argue as in the previous sub-case.(I(•))Assume requires I(q|r ) ⊆ I( p|r ).This case is similar but much simpler than Case (I ∀ (•)) above, because p = p , r = r and, in the second and third sub-case of (I ∀ (•)), one just has to apply Lemma 55(5) instead of (2), leading directly to the "otherwise" case.(Pi) Let p|r i −→ p |r , and assume that requires the proof that q|r ⇒ i −→ ⇒ q |r r : Essentially as in the first sub-case.(Qω) Assume q|r ω −→ q |r and that, as in obs , preorder requires p|r ⇒ ω −→ ⇒ p |r (or p|r ⇒ ω −→ p |r , for sobs and

Fig. 13
Fig.13 Branching-time spectrum: upper half of the IA-spectrum 3 ≈ P 4 , but P 3 rs P 4 because o / ∈ R( p 0 ).Second, we consider Parts (d) and (e): (d) The same example as in Part (a) applies; P obs Q holds for the same reason.(e) Consider the example of Part (b) again, which does not have any inputs.
input action ok?).While Fig. 1 Example illustrating IA-parallel composition, where component TryOnce has inputs {send, ack, nack} and outputs {trnsmt, ok, reset, retry}, while Client has inputs {ok, retry} and output {send} analogously, a run can also be infinite.A state p is reachable if p 0 w −→ p for some w; it is locally reachable if it is reachable by local actions only, i.e., if w ∈ O * τ .The projection w| B of w onto B ⊆ A arises by deleting from w all actions that are not in B. Now,

3 is enabled at p 3 , then ( p 1 | p 2 , p 3 ) is an error state as in the IA-case. Thus, associativity for IA follows because one can translate the two isomorphic MIA-compositions back to the two IA-compositions by removing the corresponding may- transitions and error states, so the latter two are isomorphic as well. Remark 9
[10]all P 1 a partner of P 2 if I 2 ⊆ O 1 and O 2 = I 1 ; intuitively, P 1 fully synchronizes with P 2 but might have additional outputs.The parallel product ⊗ on composable IAs P 1 , P 2 is defined as the EIO-parallel composition above, except thatE = df {( p 1 , p 2 ) ∈ P 1 × P 2 | ∃a ∈ O 1 ∩ I 2 .p 1 }, i.e., one component of an error state offers an output to the other that the other cannot receive.The IA-parallel composition P 1 |P 2 is obtained by applying the pruning of Definition 3 without adding an error state.If the initial state is illegal, then the parallel composition is undefined.Otherwise, we call P 1 and P 2 compatible.Proposition 8 (Associativity) (P 1 P 2 ) P 3 and P 1 (P 2 P 3 ) are isomorphic, for all pairwise composable EIOs P 1 , P 2 , P 3 .The analogous holds for | if P 1 , P 2 , P 3 are IAs -provided one of the two composed IAs is defined, in which case the other is as well.Proof Associativity on EIOs can be established by adapting the proof of Theorem 16 in[10].If the parallel compositions are defined, associativity on IAs is a consequence of a corresponding result in the setting of Modal Interface Automata (MIA) [9, Thm.12]: one translates every IA-transition into a must-transition in the MIA-setting and adds a disconnected error state.(Notethatthisdoes not preserve refinements.)Inmoredetail,consider (P 1 |P 2 )|P 3 and let P 1 , P 2 and P 3 be the resp.translations to MIA.P 1 |P 2 is the same as P 1 |P 2 except for the error state and the fact that, in the former, if some input i is cut at a state p 1 | p 2 , then there is a so-called may-transition with label i from p 1 | p 2 to the error state.Thus, we get P 1 |P 2 back from P 1 |P 2 by omitting such may-transitions and the error state.The same is true for (P 1 |P 2 )|P 3 , as we argue now.The only additional problem is that p 1 | p 2 has the above i-may-transition in the MIA and no i-transition in the IA.If state p 1 | p 2 of P 1 |P 2 is composed with some p 3 of P 3 , there are several cases to consider.First, if i ∈ A 3 is not enabled at p 3 , then ( p 1 | p 2 , p 3 ) as state of (P 1 |P 2 ) ⊗ P 3 has no i-transition, which fits (P 1 |P 2 ) ⊗ P 3 .Second, if i ∈ I 3 is enabled at p 3 or i / ∈ A 3 , then ( p 1 | p 2 , p 3 ) has an i-may-transition to the error state, which fits (P 1 |P 2 ) ⊗ P 3 after the translation back.Third, if i ∈ O For all IAs P 1 , P 2 , we have that P 1 |P 2 , if defined, is identical to the IA obtained in the following way.First, we consider P 1 , P 2 as EIOs according to Remark 4, apply EIOparallel composition to obtain P 12 , and translate this result back into an IA by pruning without adding the canonical error state.To see this coincidence, consider a transition ( p 1 , p 2 ) 1 p 1 and p 2 a −→ 2 p 2 for some a.

1 .
A state ( p 1 , p 2 ) in the parallel composition P 12 is quiescent if and only if the states p 1 and p 2 are quiescent in P 1 and P 2 , resp. 2. Let w ∈ A * 12 , as well as w 1 = w| A 1 and w 2 = w| A 2 .Then, w ∈ StQT(P 12 ) if and only if w 1 ∈ StQT(P 1 ) and w 2 ∈ StQT(P 2 ).
) P 1 C Qui P 2 if and only if P 1 Qui P 2 .Further, (2) P 1 Qui P 2 holds if U P 1 If P 1 Qui P 2 and P 1 can reach an error locally, we have ∈ ET(P 1 ); hence, ∈ ET(P 2 ) and P 2 can reach an error locally.If P 1 Qui P 2 and P 1 can reach a quiescent state locally with some w ∈ QET(P 1 ), i.e., w ∈ O * 1 , then w ∈ QET(P 2 ) and P 2 can reach a quiescent or error state locally.Thus, Qui is contained in B For this part, we use the second statement, which we prove below.Due to C Qui U P 2 for all partners U .With the second statement, we get P 1 Qui P 2 .
14, obviously P 5 sobs P 6 , but P 5 ibs P 6 due to the lower branch of P 6 .
14g.14Example IAs for comparing the branching-time preorders