Verifying Quantum Communication Protocols with Ground Bisimulation

One important application of quantum process algebras is to formally verify quantum communication protocols. With a suitable notion of behavioural equivalence and a decision method, one can determine if an implementation of a protocol is consistent with its specification. Ground bisimulation is a convenient behavioural equivalence for quantum processes because of its associated coinduction proof technique. We exploit this technique to design and implement two on-the-fly algorithms for the strong and weak versions of ground bisimulation to check if two given processes in quantum CCS are equivalent. We then develop a tool that can verify interesting quantum protocols such as the BB84 quantum key distribution scheme.


Introduction
Process algebras provide a useful formal method for specifying and verifying concurrent systems. Their extensions to the quantum setting have also appeared in the literature. For example, Jorrand and Lalire [18,21] defined the Quantum Process Algebra (QPAlg) and presented a branching bisimulation to identify quantum processes with the same branching structure. Gay and Nagarajan [15] developed Communicating Quantum Processes (CQP), for which Davidson [6] established a bisimulation congruence. Feng et al. [10] have proposed a quantum variant of Milner's CCS [23], called qCCS, and a notion of probabilistic bisimulation for quantum processes, which is then improved to be a general notion of bisimulation that enjoys a congruence property [12]. Later on, motivated by [25], Deng and Feng [9] defined an open bisimulation for quantum processes that makes it possible to separate ground bisimulation and the closedness under super-operator applications, thus providing not only a neater and simpler definition, but also a new technique for proving bisimilarity. In order to avoid the problem of instantiating quantum variables by potentially infinitely many quantum states, Feng et al. [11] extended the idea of symbolic bisimulation [17] for value-passing CCS and provided a symbolic version of open bisimulation for qCCS. They proposed an algorithm for checking symbolic ground bisimulation.
In the current work, we consider the ground bisimulation proposed in [9]. We put forward an on-the-fly algorithm to check if two given processes in qCCS with fixed initial quantum states are ground bisimilar. The algorithm is simpler than the one in [11] because the initial quantum states are determined for the former but can be parametric for the latter. Moreover, in many applications, we are only interested in the correctness of a quantum protocol with a predetermined input of quantum states. This is especially the case in the design stage of a protocol or in the debugging of a program.
The ground bisimulation defined in [9] is a notion of weak bisimulation because a strong transition can be matched by a weak transition where invisible actions are abstracted away. We also consider a strong version where all actions are visible, for which we have a simpler algorithm. Both algorithms are obtained by adapting the on-the-fly algorithm for checking probabilistic bisimulations [8,7], which in turn has its root in similar algorithms for checking classical bisimulations [14,17]. The basic idea is as follows. A quantum process with an initial quantum state forms a configuration. We describe the operational behaviour of a configuration as a probabilistic labelled transition system (pLTS), where probabilistic transitions arise naturally because measuring a quantum system can entail a probability distribution of post-measurement quantum systems. Ground bisimulations are a strengthening of probabilistic bisimulations by imposing some constraints on quantum variables and the environment states of processes. The skeleton of the algorithm for the strong ground bisimulation resembles to that for strong probabilistic bisimulation [8]. The algorithm for the (weak) ground bisimulation is inspired by [28] and uses as a subroutine a procedure in the aforementioned work. The procedure reduces the problem of finding a matching weak transition to a linear programming problem that can be solved in polynomial time. We have developed a tool that implements both algorithms and can check if two given configurations are strongly or weakly bisimilar. It is useful to validate whether an implementation of a protocol is equivalent to the specification. We have conducted experiments on a few interesting quantum protocols including super-dense coding, teleportation, secret sharing, and several quantum key distribution protocols, in particular the BB84 protocol [5], to analyse the functional correctness of the protocols.
Other related work Ardeshir-Larijani et al. [3] proposed a quantum variant of CCS to describe quantum protocols. The syntax of that variant is similar to qCCS but its semantics is very different. The behaviour of a concurrent process is a finite tree and an interleaving is a path from the root to a leaf. By interpreting an interleaving as a superoperator [26], the semantics of a process is a set of superoperators. The equivalence checking between two processes boils down to the equivalence checking between superoperators, which is accomplished by using the stabiliser simulation algorithm invented by Aaronson and Gottesman [1]. Ardeshir-Larijani et al. have implemented their approach in an equivalence checker in Java and verified several quantum protocols from teleportation to secret sharing. However, they are not able to handle the BB84 quantum key distribution protocol because its correctness cannot be specified as an equivalence between interleavings. Our approach is based on ground bisimulation and keeps all the branching behaviour of a concurrent process. Our algorithms for checking ground bisimulations are influenced by the on-the-fly algorithm of Hennessy and Lin for value-passing CCS [17]. We are inspired by the probabilistic bisimulation checking algorithm of Baier et al. [4] for the strong version of ground bisimulation, and by the weak bisimulation checking algorithm of Turrini and Hermanns [28] for the weak version.
Kubota et al. [20] implemented a semi-automated tool to check a notion of symbolic bisimulation and used it to verify the equivalence of BB84 and another quantum key distribution protocol based on entanglement distillation [27]. There are two main differences between their work and ours. (1) Their tool is based on equational reasoning and thus requires a user to provide equations while our tool is fully automatic. (2) Their semantic interpretation of measurement is different and entails a kind of linear-time semantics for quantum processes that ignores the timepoints of the occurrences of probabilistic branches. However, we use a branching-time semantics. For instance, the occurrence of a measurement before or after a visible action is significant for our semantics but not for the semantics proposed in [20].
Besides equivalence checking, based on either superoperators or bisimulations as mentioned above, model checking is another feasible approach to verify quantum protocols. For instance, Gay et al. developed the QMC model checker [16]. Feng et al. implemented the tool QPMC [13] to model check quantum programs and protocols. There are also other approaches for verifying quantum systems. Abramsky and Coecke [2] proposed a categorical semantics for quantum protocols. Quantomatic [19] is a semi-automated tool based on graph rewriting. Ying [30] established a quantum Hoare logic, which has been implemented in a theorem prover [22].
The rest of the paper is structured as follows. In Section 2 we recall the syntax and semantics of the quantum process algebra qCCS. In Section 3 we present an algorithm for checking ground bisimulations. In Section 4 we report the implementation of the algorithm and some experimental results on verifying a few quantum communication protocols. Finally, we conclude in Section 5 and discuss some future work.
In particular, we let e e be a boolean expression for any e, e ∈ Exp and ∈ {>, <, ≥, ≤, =}. We further assume that only classical variables can occur freely in both data expressions and boolean expressions. Two types of channels are used: cChan for classical channels, ranged over by c, d, ..., and qChan for quantum channels, ranged over by c, d,.... A relabelling function f is a map on cChan ∪ qChan such that f (cChan) ⊆ cChan and f (qChan) ⊆ qChan. Sometimes we abbreviate a sequence of distinct variables q 1 , ..., q n intoq.
The terms in qCCS are given by: where f is a relabelling function and L ⊆ cChan ∪ qChan is a set of channels.
Most of the constructors are standard as in CCS [23]. We briefly explain a few new constructors. The process c?q.P receives a quantum datum along quantum channel c and evolves into P , while c!q.P sends out a quantum datum along quantum channel c before evolving into P . The symbol E represents a tracepreserving super-operator applied on the quantum system referred to by the variablesq. The process M [ q; x].P measures the state of qubits q according to the observable M and stores the measurement outcome into the classical variable x of P . Free classical variables can be defined in the usual way, except for the fact that the variable x in the quantum measurement M [q; x] is bound. A process P is closed if it contains no free classical variable, i.e. f v(P ) = ∅.
The set of free quantum variables for process P , denoted by qv(P ) can be inductively defined as in Figure 1. For a process to be legal, we require that 3. Each constant A(q;x) has a defining equation A(q;x) := P , where P is a term with qv(P ) ⊆q and f v(P ) ⊆x.
The first condition says that a quantum system will not be referenced after it has been sent out. This is a requirement of the quantum no-cloning theorem.
The second condition says that parallel composition || models separate parties that never reference a quantum system simultaneously. Throughout the paper we implicitly assume the convention that processes are identified up to α-conversion, bound variables differ from each other and they are different from free variables.
Before introducing the operational semantics of qCCS processes, we review the model of probabilistic labelled transition systems (pLTSs). Later on we will interpret the behaviour of quantum processes in terms of pLTSs because quantum measurements give rise to probability distributions naturally.
We begin with some notations. A (discrete) probability distribution over a set S is a function ∆ : S → [0, 1] with s∈S ∆(s) = 1; the support of such a ∆ is the set ∆ = { s ∈ S | ∆(s) > 0 }. The point distribution s assigns probability 1 to s and 0 to all other elements of S, so that s = {s}. We only need to use distributions with finite supports, and let Dist(S) denote the set of finite support distributions over S, ranged over by ∆, Θ, etc. If k∈K p k = 1 for some collection of p k ≥ 0, and the ∆ k are distributions, then so is k∈K p k · ∆ k with ( k∈K p k · ∆ k )(s) = k∈K p k · ∆ k (s). Definition 1. A probabilistic labelled transition system is a triple S, Act τ , → , where S is a set of states, Act τ is a set of visible actions Act augmented with the invisible action τ , and → ⊆ S × Act τ × Dist(S) is the transition relation.
We often write s α −→ ∆ for (s, α, ∆) ∈ →. In pLTSs we not only consider relations between states, but also relations between distributions. Therefore, we make use of the lifting operation below [7].
We now give the semantics of qCCS. For each quantum variable q we assume a 2-dimensional Hilbert space H q . For any nonempty subset S ⊆ qVar we write H S for the tensor product space q∈S H q and H S for q ∈S H q . In particular, H = H qVar is the state space of the whole environment consisting of all the quantum variables, which is a countably infinite dimensional Hilbert space.
Let P be a closed quantum process and ρ a density operator on H , the pair P, ρ is called a configuration. We write Con for the set of all configurations, ranged over by C and D. We interpret qCCS with a pLTS whose states are all the configurations definable in the language, and whose transitions are determined by the rules in Figure 2; we have omitted the obvious symmetric counterparts to the rules (C-Com), (Q-Com), (Int) and (Sum). The set of actions Act takes the following form, consisting of classical/quantum input/output actions.
As H is infinite dimensional, ρ should be understood as a density operator on some finite dimensional subspace of H which contains H qv (P ) . 1 1 We use cn(α) for the set of channel names in action α. For example, we have cn(c?x) = {c} and cn(τ ) = ∅.
In the first eight rules in Figure 2, the targets of arrows are point distributions, and we use the slightly abbreviated form C α −→ C to mean C α −→ C . The rules use the obvious extension of the function || on terms to configurations and distributions. To be precise, C || P is the configuration Q || P, ρ where C = Q, ρ , and ∆ || P is the distribution defined by:

Similar extension applies to ∆[f ] and ∆\L.
Suppose there is a configuration C = P, ρ , the partial trace over system P at such state can be defined as tr qv(P ) (ρ) whose result is a reduced density operator representing the state of the environment. We give the definition of ground bisimulation and bisimilarity as follows.
A relation R is a ground bisimulation if both R and R −1 are ground simulations. We denote by ≈ the largest ground bisimulation, called ground bisimilarity. If the above weak transition Dα =⇒ Θ is replaced by a strong transition D α −→ Θ, we obtain a strong ground bisimulation.
In the rest of the paper, we mainly focus on ground bisimulation and only briefly mention the algorithm for checking strong ground bisimulation.

Algorithm
We present an on-the-fly algorithm to check if two configurations are ground bisimilar.
The algorithm maintains two sets N onBisim and Bisim to keep non-bisimilar and bisimilar state pairs, respectively. When the algorithm terminates, Bisim should contain all the state pairs satisfying the bisimulation relation.
The function Bisim(t, u), as shown in Algorithm 1, is the main function of the algorithm, which attempts to find the smallest bisimulation containing the pair (t, u). It initialises Bisim and a set named V isited to store the visited pairs, then calls the function Match to search for a bisimulation. The function Match(t, u, V isited) invokes a depth-first traversal to match a pair of states (t, u) with all their possible behaviours. The set V isited is updated before the traversal for detecting loops. We also match the behaviours of t and u from both directions as we are checking bisimulations. Two states are deemed non-bisimilar in three cases: one state has a transition that cannot be matched by any possible weak transition from the other; they do not have the same set of free quantum variables; the density operators of them corresponding to their quantum registers are different.
The first case is checked by MatchAction, and the other two are done in Match. We add a pair of states to N onBisim if one of the three cases above has occurred. Otherwise, it will be stored in Bisim.
An auxiliary function Act(t) is invoked in Match to discover the next action that t can perform. If t have no more action to perform the function will return an empty set.
The function MatchAction(α, t, u, V isited) checks the equivalence of configurations through comparing their transitions. The function recursively discovers the next equivalent state pairs between the target states of the transitions. Technically, it checks the condition that if t α −→ ∆ then there exists some Θ such that uα =⇒ Θ and ∆ R • Θ. Here we use as a subroutine a procedure of [28] to reduce the problem to a linear programming problem that can be solved in polynomial time. The problem is defined in Appendix. In MatchAction, we introduce a predicate LP(∆, u, α, R) which is true if and only if the linear programming problem has a solution. We invoke the function Close to construct an equivalence relation R between S and the states in the support of the target distribution. Note that in Lines 28 and 34 we have two distinct cases because in output actions the emitted values are required to be equal, which are unlike other types of actions.
In general, there are loops in pLTSs. When a state pair to be considered is already contained in V isited it will be assumed to be bisimilar and added to Assumed (Lines 42-43). Later on, if the pair of states are found to be nonbisimilar, the pair will be added to N onBisim and a wrong assumption exception (Lines 18-21) will be raised to restart the checking process from the original pair of states. Then Bisim(t, u) renews the sets Bisim, V isited and Assumed to remove the pairs checked under the wrong assumption (Lines 4-6).
Proof. The algorithm starts with two empty sets N onBisim and Bisim. The next action to perform is detected in Match. Then it invokes function MatchAction to find the next new pair of configurations and recursively call function Match to check them. Once a state pair is checked to be non-bisimilar in function Match, it is added into N onBisim. Meanwhile, if it is also contained in the set Assumed, the algorithm restarts a new execution of Bisim. Let k denote the number of executions of Bisim, and N onBisim k be the set N onBisim at the end of Bisim k . It is easy to show by induction that N onBisim k ⊂ N onBisim k+1 for any k ≥ 0. Since the system under consideration is finite-state, there always exists some n such that N onBisim n is the largest set of non-bisimilar state pairs and Bisim n is the last execution of Bisim.
After the execution of Bisim n , no more exceptions will be raised. Each time Match is executed with t and u as its parameters, we add (t, u) into V isited. The quantum variables and the configurations of the quantum registers for t and u are compared. When no more state pairs are added into V isited, the function M atch will not be invoked again and the whole algorithm will terminate.
Theorem 2 (Correctness). Given two configurations t and u from two pLTSs, Bisim(t, u) returns true if and only if they are ground bisimilar.
Proof. Let Bisim n be the last execution of Bisim. Let N onBisim n and Bisim n be the values of the two sets N onBisim and Bisim, respectively, recording the checked state pairs at the end of Bisim n . By inspecting Match, we know that N onBisim n ∩ Bisim n = ∅.
Let us analyse the result returned by Bisim n , which is the output of the function call Match(t, u, V isited). If the result is f alse then one of the conjuncts in b res is invalid, which means that one of the three cases discussed in the beginning of Section 3 occurs, thus t and u are indeed non-bisimilar. If the return is true then there is Bisim n = V isited n \N onBisim n . For each pair (t, u) ∈ Bisim n , all the conjuncts in b res must be true. Both t and u must have the same set of free quantum variables and the same density operators. In addition, they have matching transitions. That is, for any action α, if t α −→ ∆ then there exists some weak distribution Θ such that u α =⇒ Θ and ∆ R • Θ. This is true because (i) the relation R in function MatchAction is correctly constructed, and (ii) the lifted relation R • exists. Below we argue for (i); the existence of the lifting operation in (ii) relies on the validity of the predicate LP whose correctness is established by Theorem 9 in [28].
The algorithm adds a pair into Assumed n if the pair to be checked has already been visited and passed the bisimulation checking conditions. It implies that Assumed n ⊆ V isited n . Furthermore, as there is no wrong assumption detected after the execution of Bisim n , we have Assumed n ⊆ Bisim n which implies that Bisim n = Assumed n ∪ Bisim n . So Bisim n constitutes a bisimulation relation containing the initial state pair (t, u).
Before concluding this section, we analyse the time complexity of the algorithm.
Theorem 3 (Complexity). Let the number of configurations reachable from t and u be n. The time complexity of function Bisim(t, u) is polynomial in n.
Proof. The number of state pairs is at most n 2 . The number of state pairs examined in the kth execution of Bisim is at most O(n 2 − k). Therefore, the total number of state pairs examined is as most O(n 2 +(n 2 −1)+...+1) = O(n 4 ). Note that each state has finitely many outgoing transitions. Given a transition, to check if there exists a weak matching transition, we call the function LP at most once, the construction of a flow network and solving the linear programming problem are both polynomial in n if we use the algorithm in [28]. Consequently, the whole algorithm is also polynomial in n.
For the strong version of ground bisimulation, we are only concerned with the matching of strong transitions. Therefore, Algorithm 1 can be simplified and there is no need of the predicate LP in the function MatchAction.

Implementation and Experiments
In this section, we report on an implementation of our approach and provide the experimental results of verifying several quantum communication protocols.

Implementation
We have implemented both strong and weak ground bisimulation checkers in Python 3.7. The workflow of our tool is sketched in Figure 3. The tool consists of a pLTS generation module and two bisimulation checking modules, devoted to modeling and verification, respectively. The input of this tool is a specification and an implementation of a quantum protocol, both described as qCCS processes, the definition of user-defined operators, as well as an initialisation of classical and quantum variables. Unlike classical variables, the initialisation of all quantum variables, deemed as a quantum register, is accomplished at the same time so to allow for superposition states. The final output of the tool is a result indicating whether the specification and the implementation are bisimilar under the same initial states. The algorithm also stores the bisimilar state pairs and non-bisimilar state pairs in two tables.
The pLTS generation module acts as a preprocessing unit before the verification task. It first translates the input qCCS processes into two abstract syntax trees (ASTs) by a parser. Then the ASTs are transformed into two pLTSs according to the operational semantics given in Figure 2, using the user-defined operators and the initial values of variables. The weak bisimulation checking module implements the weak ground bisimilarity checking algorithm we defined in the last section. It checks whether the initial states of the two generated pLTSs are weakly bisimilar.
The tool is available in [24], where we also provide all the examples for the experiments to be discussed in Section 4.3.

BB84 Quantum Key Distribution Protocol
To illustrate the use of our tool, we formalise the BB84 quantum key distribution protocol. Our formalisation follows [11], where a manual analysis of the protocol is provided. Now we perform automatic verification via the ground bisimulation checker.
The BB84 protocol provides a provably secure way to create a private key between two partners with a classical authenticated channel and a quantum insecure channel between them. The protocol does not make use of entangled states. It ensures its security through the basic property of quantum mechanics: if the states to be distinguished are not orthogonal, such as |0 and |+ , then information gain about a quantum state is only possible at the expense of changing the state. Let the sender and the receiver be Alice and Bob, respectively. The basic BB84 protocol with a sequence of qubitsq with size n goes as follows: 1. Alice randomly generates two sequences of bitsB a andK a using her qubits q. Note thatq here are auxiliary qubits which are not modified in this step. 2. Alice sets the state ofq, such that the i th bits ofq is |x y where x and y are the i th bits ofB a andK a , and respectively, |0 0 = |0 , |0 1 = |1 , |1 0 = |+ = (|0 + |1 )/ √ 2 and |1 1 = |− = (|0 − |1 )/ √ 2. 3. Alice sends her qubitsq to Bob. 4. Bob randomly generates a sequence of bitsB b using his qubitsq . 5. Bob measures the i th qubit ofq he received from Alice according to the basis determined by the i th bit ofB b . Respectively, the basis is {|0 , |1 } if it is 0 and {|+ , |− } if it is 1. 6. Bob sends his choice of measurementsB b to Alice, and after receiving the information, Alice sends herB a to Bob. 7. Alice and Bob match two sequences of bitsB a andB b to determine at which positions the bits are equal. If the bits match, they keep the corresponding bits ofK a andK b . Otherwise, they discard them.
After the execution of the basic BB84 protocol, the remaining bits ofK a and K b should be the same, provided that the communication channels are perfect and there is no eavesdropper.
Implementation. For simplicity, we assume that the sequenceq consists of only one qubit. This is enough to reflect the essence of the protocol. The other qubits used below are auxiliary qubits for the operation Ran.
where there are several special operations: Specification. The specification can be defined as follows using the same operations: .
(key a !cmp(K a , B a , B b ).nil||key b !cmp(K a , B a , B b ).nil).
Input. For the implementation of BB84, we need to declare the following variables and operators in the input attached to it.
-The classical bits are named B a , K a for Alice and B b , K b for Bob.
-The qubits are declared together as a vector |q 1 , q 2 . The vector always needs an initial value. We can set it to be |00 in this example.
When modelling the protocol, we use several operators. They should be defined and their definitions are part of the input. The function cmp is treated as an in-built function, so there is no need to define it in the input.
For the specification BB84 spec , we only declare the classical bits B a , B b , K a , qubits q 1 , q 2 and the operator Ran. The variables and operators declared here are the same as those in the input of the implementation.
Output. Taking the input discussed above, the tool first generates two pLTSs, with over 150 states for the implementation and 80 states for the specification, and then runs the ground bisimulation checking algorithm. As we can see from the fifth row in Table 1, our tool confirms that BB84, ρ 0 ≈ BB84 spec , ρ 0 , where ρ 0 denotes the initial state of the quantum register, thus the implementation is faithful to the specification. In the output of the tool, there is an enumeration of 1084 pairs of non-bisimilar states and 3216 pairs of bisimilar states. The pLTSs and the state pairs can be found in [24].

Experimental Results
We conducted experiments on several quantum communication protocols with a few different input variables. Table 1  In each case, we report the final outcome (whether an implementation is ground bisimilar to its specification), the number of nodes in two pLTSs, the numbers of non-bisimilar and bisimilar state pairs in N onBisim and Bisim, respectively, as well as the verification time of our ground bisimulation checking algorithm. The time cost excludes the part of pLTS generation which takes around one second in all the examples.
Besides the protocol discussed in Section 4.2, we also verify other ones that make use of entangled qubits such as the teleportation and the quantum secrect sharing protocol. For quantum key distribution protocols, we conduct experiments on the BB84, the B92 and the E91.
Not all the cases in Table 1 give the size of the set N onBisim of non-bisimilar state pairs, as the bisimulation checking algorithm may immediately terminate once a negative verification result is obtained, i.e. the two initial states are not bisimilar.

Data Availability Statement
The datasets generated and/or analyzed during the current study are available in the figshare repository: https://doi.org/10.6084/m9.figshare.11874942.v1.

Conclusion and Future Work
We have presented an on-the-fly algorithm to check ground bisimulation for quantum processes in qCCS, and a simpler algorithm for strong ground bisimulation. Based on the algorithms, we have developed a tool to verify quantum communication protocols modelled as qCCS processes. We have carried out experiments on several non-trivial quantum communication protocols from superdense coding to key distribution and found the tool helpful.
As to future work, several interesting problems remain to be addressed. For example, a limitation of the current work is to compare quantum processes with predetermined states of quantum registers. Indeed, there are occasions where one would expect two processes to be equivalent for arbitrary initial states. It is infeasible to enumerate all those states. Then the symbolic bisimulations proposed in [11] will be useful. We are considering to implement the algorithm for symbolic ground bisimulation, and then tackle the more challenging symbolic open bisimulation, both proposed in that work. Another problem occurs in the experiment of Section 4.2. The example tested one qubit instead of a sequence of qubits because more qubits lead to a drastic growth of the running time, which shows a limitation of the current approach of explicitly representing state spaces.

Appendix
Algorithm 1 needs to check the condition that if t α −→ ∆ then there exists some Θ such that uα =⇒ Θ and ∆ R • Θ. We use as a subroutine a procedure of [28] to reduce the problem to a network flow problem that can be solved in polynomial time.
Technically, we construct a network graph G(∆, u, α, R) = (V, E) defined as follows. Let S be the set of reachable states, and R be a binary relation on the states.
Let and be two vertices that represent the source and the sink of the network, respectively. For each visible action α, the set of vertices V is given below V = { , } ∪ S ∪ S tr ∪ S α ∪ S tr α ∪ S ⊥ ∪ S R where S tr = {v tr |tr = v β −→ Γ, β ∈ {α, τ }}; S α = {v α |v ∈ S}; S tr α = {v tr α |v tr ∈ S tr }; S ⊥ = {v ⊥ |v ∈ S}; S R = {v R |v ∈ S}. and the set of edges E is For the invisible action τ , the definition is similar: If α is a visible action, we consider the following linear programming problem associated to G(∆, u, α, R): Note that the fourth constraint is referred to as the flow-conservation constraints. The last three constraints link the source state and the result distribution. For the invisible action τ , the linear programming problem associated to the network G(∆, u, τ, R) is the same as above except that the last two constraints are dropped.
We denote by LP(∆, u, α, R) the predicate that is true if and only if the linear programming problem above has a solution.