Symbolic model checking quantum circuits in Maude

Basic quantum mechanics

This section describes basic quantum mechanics based on the linear algebra approach. In classical computing, the fundamental unit of information is a bit whose value is either 0 or 1. In quantum computing, the counterpart is a quantum bit or qubit, which has two basis states, conventionally written in Dirac notation proposed by Dirac (1939) as |0〈.〉 and |1〈.〉, which denote two column vectors $\left(\begin{array}{c}\hfill 1\hfill \\ \hfill 0\hfill \end{array}\right)$ and $\left(\begin{array}{c}\hfill 0\hfill \\ \hfill 1\hfill \end{array}\right)$, respectively. In quantum theory, a general state of a quantum system is a superposition or linear combination of basis states. A single qubit has state |ψ〈.〉 = α|0〈.〉 + β|1〈.〉, where α and β are complex numbers such that |α|² + |β|² = 1. States can be represented by column complex vectors as follows:

$|\psi 〈.〉=\left(\begin{array}{c}\hfill \alpha \hfill \\ \hfill \beta \hfill \end{array}\right)=\alpha |\mathbf{0}〈.〉+\beta |\mathbf{1}〈.〉$,

where {|0〈.〉, |1〈.〉} forms an orthonormal basis of the two-dimensional complex vector space. Formally, a quantum state is a unit vector in a Hilbert space $\mathcal{H}$, which is equipped with an inner product satisfying some axioms.

The basis {|0〈.〉, |1〈.〉} is called the standard basis. Besides, we have some other bases of interest, such as the diagonal (or dual, or Hadamard) basis consisting of the following vectors:

$|+〈.〉=\frac{1}{\sqrt{2}}\left(|\mathbf{0}〈.〉+|\mathbf{1}〈.〉\right)$ and $|-〈.〉=\frac{1}{\sqrt{2}}\left(|\mathbf{0}〈.〉-|\mathbf{1}〈.〉\right)$.

The evolution of a closed quantum system can be performed by a unitary transformation. If the state of a qubit is represented by a column vector, then a unitary transformation can be represented by a complex-value matrix U such that UU^† = U^†U = I or U^† = U⁻¹, where U^† is the conjugate transpose of U. U acts on the Hilbert space $\mathcal{H}$ transforming a state |ψ〈.〉 to a state |ψ′〈.〉 by a matrix multiplication such that |ψ′〈.〉 = U|ψ〈.〉. There are some common quantum gates: the identity gate I, the Pauli gates X, Y, and Z, the Hadamard gate H, and the controlled-NOT gate CX. Note that the CX gate performs on two qubits, while the remaining gates perform on a single qubit.

For example, the Hadamard gate on a single qubit performs the mapping $|\mathbf{0}〈.〉\mapsto \frac{1}{\sqrt{2}}\left(|\mathbf{0}〈.〉+|\mathbf{1}〈.〉\right)$ and $|\mathbf{1}〈.〉\mapsto \frac{1}{\sqrt{2}}\left(|\mathbf{0}〈.〉-|\mathbf{1}〈.〉\right)$. The controlled-NOT gate on pairs of qubits performs the mapping |00〈.〉↦|00〈.〉, |01〈.〉↦|01〈.〉, |10〈.〉↦|11〈.〉, |11〈.〉↦|10〈.〉, which can be understood as inverting the second qubit (referred to as the target) if and only if the first qubit (referred to as the control) is 1. The common quantum gates are shown in Table 1 by names, circuit forms, and matrix representations, where i is the imaginary unit.

Table 1:

Quantum gates by names, circuit forms, and the corresponding unitary matrices.

Operator	Gate	Matrix
Identity (I2)		$\left(\begin{array}{c}\hfill 10\hfill \\ \hfill 01\hfill \end{array}\right)$
Pauli-X (X)		$\left(\begin{array}{c}\hfill 01\hfill \\ \hfill 10\hfill \end{array}\right)$
Pauli-Y (Y)		$\left(\begin{array}{c}\hfill 0-i\hfill \\ \hfill i0\hfill \end{array}\right)$
Pauli-Z (Z)		$\left(\begin{array}{c}\hfill 10\hfill \\ \hfill 0-1\hfill \end{array}\right)$
Hadamard (H)		$\frac{1}{\sqrt{2}}\left(\begin{array}{c}\hfill 11\hfill \\ \hfill 1-1\hfill \end{array}\right)$
Controlled-NOT (CX) (the first and second wires denote the control and target qubits, respectively)		$\left(\begin{array}{c}\hfill 1000\hfill \\ \hfill 0100\hfill \\ \hfill 0001\hfill \\ \hfill 0010\hfill \end{array}\right)$

DOI: 10.7717/peerjcs.2098/table-1

A quantum measurement is described as a collection {M_m} of measurement operators, where the indices m refer to the measurement outcomes. It is required that the measurement operators satisfy ${\sum }_m{\mathit{M}}_m^{†}{\mathit{M}}_m={\mathit{I}}_{\mathcal{H}}$. If the state of a quantum system is |ψ〈.〉 before the measurement, then the probability for the result m is as follows:

$p\left(m\right)=〈\psi \left|{\mathit{M}}_m^{†}{\mathit{M}}_m\right|\psi 〉$,

where 〈〉.ψ| is the dual of |ψ〈.〉 such that 〈〉.ψ|† = |ψ〈.〉 and |ψ〈.〉† = 〈〉.ψ|. The state of the quantum system after the measurement is $\frac{{\mathit{M}}_m|\psi 〈.〉}{\sqrt{p\left(m\right)}}$ provided that p(m) > 0. For example, if a qubit is in state α|0〈.〉 + β|1〈.〉 and measuring with {M₀, M₁} operators, we have the result 0 with probability |α|² at the post-measurement state |0〈.〉 and the result 1 with probability |β|² at the post-measurement state |1〈.〉, where M₀ = |0〈.〉 × 〈〉.0| and M₁ = |1〈.〉 × 〈〉.1|. The quantum measurement with {M₀, M₁} operators is called the binary projective measurement. In this study, we only use the binary projective measurement and its circuit form is depicted in Fig. 1 as follows:

For multiple qubits, we use the tensor product of Hilbert spaces. Let ${\mathcal{H}}_1$ and ${\mathcal{H}}_2$ be two Hilbert spaces. Their tensor product ${\mathcal{H}}_1\otimes {\mathcal{H}}_2$ is defined as a vector space consisting of linear combinations of the vectors |ψ₁ψ₂〈.〉 = |ψ₁〈.〉|ψ₂〈.〉 = |ψ₁〈.〉⊗|ψ₂〈.〉, where $|{\psi }_1〈.〉\in {\mathcal{H}}_1$ and $|{\psi }_2〈.〉\in {\mathcal{H}}_2$. Systems of two or more qubits may be in entangled states, meaning that states of qubits are correlated and inseparable. For example, we consider a measurement of the first qubit of the entangled state $\frac{1}{\sqrt{2}}\left(|\mathbf{00}〈.〉+|\mathbf{11}〈.〉\right)$. The result is either 0 with probability $\frac{1}{2}$ leaving its state |00〈.〉 or 1 with probability $\frac{1}{2}$ leaving its state |11〈.〉. In either case, a subsequent measurement of the second qubit gives a non-probabilistic result, which is immediate to the result of the first measurement before. Entanglement shows that an entangled state of two qubits cannot be expressed as a tensor product of single-qubit states. We can use H and CX gates to create entangled states as follows: $\mathit{CX}\left(\left(\mathit{H}\otimes \mathit{I}\right)|\mathbf{00}〈.〉\right)=\frac{1}{\sqrt{2}}\left(|\mathbf{00}〈.〉+|\mathbf{11}〈.〉\right)$.

Kripke structures

A Kripke structure K is a tuple 〈S, I, T, A, L〉 as represented by Clarke et al. (2018), where S is a set of states, I⊆S is the set of initial states, T⊆S × S is a left-total binary relation over S, A is a set of atomic propositions, and L is a labeling function whose type is S → 2^A. Each element (s, s′) ∈ T is called a state transition from s to s′ and T may be called the state transitions (with respect to K). For a state s ∈ S, L(s) is the set of atomic propositions that hold in s. A path π is an infinite sequence s₀, …, s_i, s_i+1, … such that s_i ∈ S and (s_i, s_i+1) ∈ T for each i. We use the following notations for paths: πⁱ≜s_i, s_i+1, …,  π_i≜s₀, …, s_i, s_i, s_i, …,  π(i)≜s_i, where ≜ is used as “be defined as.” πⁱ is obtained by deleting the first i states s₀, s₁, …, s_i−1 from π. π_i is obtained by taking the first i + 1 states s₀, s₁, …, s_i−1, s_i and adding s_i unboundedly many times at the end. π(i) is the ith state s_i. Let $\mathcal{P}$ be the set of all paths. π is called a computation if π(0) ∈ I. Let $\mathcal{C}$ be the set of all computations.

The syntax of a formula φ in LTL for K is as follows:

$\phi :=\top \left|p\right|\neg \phi |\phi \wedge \phi |○\phi |\phi \mathcal{U}\phi$

where p ∈ A, and $○$ and $\mathcal{U}$ are called the next temporal connective and the until temporal connective, respectively. We introduce the eventual temporal abbreviation ♢ which is defined as follows:

• $♢\phi \triangleq \top \mathcal{U}\phi$

This eventual temporal abbreviation is also used in Clarke et al. (2018).

Let $\mathcal{F}$ be the set of all formulas in LTL for K. Given an arbitrary path $\pi \in \mathcal{P}$ of K and an arbitrary LTL formula $\phi \in \mathcal{F}$ of K, K, π⊧φ is inductively defined as follows:

• K, π⊧⊤

• K, π⊧p iff p ∈ L(π(0))

• K, π⊧¬φ₁ iff K, π⁄⊧φ₁

• K, π⊧φ₁∧φ₂ iff K, π⊧φ₁ and K, π⊧φ₂

• $K,\pi \vDash ○{\phi }_1$ iff K, π¹⊧φ₁

• $K,\pi \vDash {\phi }_1\mathcal{U}{\phi }_2$ iff there exists a natural number i such that K, πⁱ⊧φ₂ and for all natural numbers j < i, K, π^j⊧φ₁

where φ₁ and φ₂ are LTL formulas. Then, K⊧φ iff K, π⊧φ for each computation $\pi \in \mathcal{C}$ of K.

In this article, we refer to ♢φ as eventual properties, which informally state that something will eventually happen. Termination or halting is one important system requirement that many systems should satisfy and can be expressed in LTL as an eventual property. Moreover, we aim to verify whether quantum circuits satisfy certain desired properties where something good eventually happens. For example, a qubit at the final state for each possible execution path is the same as another qubit at the initial state with a non-zero probability. Therefore, it is worthwhile to use eventual properties to express desired properties for our case studies under verification. For more details, the reader is referred to ‘Symbolic Model Checking’ to see how we express the desired properties for our case studies as eventual properties.

Terms

Terms are built from scalars and basic vectors with some operations.

• Scalars are complex numbers. We extend rational numbers supported in Maude to deal with complex numbers. Some operations for scalars, such as multiplication, division, addition, conjugation, absolute, power, and square roots are specified. The reader who is interested in how to specify complex numbers in Maude is referred to Appendix A.

• Basic vectors are the ones of the standard basis written in Dirac notation as |0〈.〉 and |1〈.〉.

• Operations for matrices consist of scalar multiplication ⋅, matrix product ×, matrix addition +, tensor product ⊗, and the conjugate transpose A^† of a matrix A.

In Dirac notation, 〈〉.0| is the dual of |0〈.〉 such that 〈0|^† = |0〉 and |0〈.〉^† = 〈〉.0|; similarly for 〈〉.1|. The terms |j〈.〉 × 〈〉.k| and the inner product of ket vectors |j〈.〉 and |k〈.〉 may be written shortly as |j〈.〉〈〉.k| and 〈j〉k for any j, k ∈ {0, 1}. By using these notations, we can intuitively explain how quantum operations work. For example, the X gate performs mapping |0〈.〉↦|1〈.〉 and |1〈.〉↦|0〈.〉. Therefore, we specify the X gate as |0〈.〉〈1| + |1〉〈〉.0| in Maude instead of using explicitly the matrix representation $\left(\begin{array}{cc}\hfill 0\hfill & \hfill 1\hfill \\ \hfill 1\hfill & \hfill 0\hfill \end{array}\right)$. We have X|0〈.〉 = |1〈.〉〈〉.0||0〈.〉 + |0〈.〉〈〉.1||0〈.〉 = |1〈.〉 because of laws L1 and L3 in Table 2 and similarly for X|1〈.〉 = |0〈.〉.

We conventionally specify some basic matrices B_i for i ∈ [0..3] as follows:

B₀ = |0〈.〉 × 〈〉.0|, B₁ = |0〈.〉 × 〈〉.1|, B₂ = |1〈.〉 × 〈〉.0|, B₃ = |1〈.〉 × 〈〉.1|.

The X, Y, Z, CX, and H gates are then a linear combination of the matrices B_i as follows:

X = B₁ + B₂, Y = (−i)⋅B₁ + i⋅B₂, Z = B₁ + (−1)⋅B₃,

CX = B₀⊗I₂ + B₃⊗X, $\mathit{H}=\frac{1}{\sqrt{2}}\cdot {\mathit{B}}_0+\frac{1}{\sqrt{2}}\cdot {\mathit{B}}_1+\frac{1}{\sqrt{2}}\cdot {\mathit{B}}_2+\left(-\frac{1}{\sqrt{2}}\right)\cdot {\mathit{B}}_3$.

Laws

We use a set of laws in Table 2 derived from the properties of quantum mechanics and basic matrix operations, and thus, they are immediately sound. The reader who is interested in their proofs in Coq is referred to Shi et al. (2021). Because |0〈.〉 and |1〈.〉 can be viewed as 2 × 1 matrices, then the laws actually describe matrix calculations with Dirac notation, zero and identity matrices, and scalars. These laws are described by equations in Maude and are used to automatically reduce terms until no more matrix operation is applicable. Some laws dedicated to simplifying the expressions about complex numbers are also specified in Maude by means of equations, but we do not mention them here for brevity.

For example, we would like to reduce the term CX × ((H⊗I) × |0〈.〉⊗|0〈.〉) to check whether its result is $\frac{1}{\sqrt{2}}\cdot |\mathbf{0}〈.〉\otimes |\mathbf{0}〈.〉+\frac{1}{\sqrt{2}}\cdot |\mathbf{1}〈.〉\otimes |\mathbf{1}〈.〉$. The term says that the H gate acts on the first qubit followed by the CX gate where the control and target bits are the first and second qubits, respectively. The simplification of the term goes as follows: ${\displaystyle \mathit{H}\times |\mathbf{0}〈.〉}$ ${\displaystyle =\left(\frac{1}{\sqrt{2}}\cdot {\mathit{B}}_0+\frac{1}{\sqrt{2}}\cdot {\mathit{B}}_1+\frac{1}{\sqrt{2}}\cdot {\mathit{B}}_2+\left(-\frac{1}{\sqrt{2}}\right)\cdot {\mathit{B}}_3\right)\times |\mathbf{0}〈.〉\left(\text{by replacement of}\mathit{H}\right)}$ ${\displaystyle =\frac{1}{\sqrt{2}}\cdot {\mathit{B}}_0\times |\mathbf{0}〈.〉+\frac{1}{\sqrt{2}}\cdot {\mathit{B}}_1\times |\mathbf{0}〈.〉+\frac{1}{\sqrt{2}}\cdot {\mathit{B}}_2\times |\mathbf{0}〈.〉+\left(-\frac{1}{\sqrt{2}}\right)\cdot {\mathit{B}}_3\times |\mathbf{0}〈.〉\left(\text{by law L15}\right)}$ ${\displaystyle =\frac{1}{\sqrt{2}}\cdot |\mathbf{0}〈.〉\times 〈\mathbf{0}|\times |\mathbf{0}〉+\frac{1}{\sqrt{2}}\cdot |\mathbf{0}〈.〉\times 〈\mathbf{1}|\times |\mathbf{0}〉+\frac{1}{\sqrt{2}}\cdot |\mathbf{1}〈.〉\times 〈\mathbf{0}|\times |\mathbf{0}〉+\left(-\frac{1}{\sqrt{2}}\right)\cdot |\mathbf{1}〈.〉\times 〈\mathbf{1}|\times |\mathbf{0}〉\left(\text{by replacements of}{\mathit{B}}_0,{\mathit{B}}_1,{\mathit{B}}_2,\text{and}{\mathit{B}}_3\right)}$ ${\displaystyle =\frac{1}{\sqrt{2}}\cdot |\mathbf{0}〈.〉+\frac{1}{\sqrt{2}}\cdot |\mathbf{1}〈.〉\left(\text{by law L1}\right)}$ ${\displaystyle \left(\mathit{H}\otimes \mathit{I}\right)\times \left(|\mathbf{0}〈.〉\otimes |\mathbf{0}〈.〉\right)}$ ${\displaystyle =\left(\mathit{H}\times |\mathbf{0}〈.〉\right)\otimes \left(\mathit{I}\times |\mathbf{0}〈.〉\right)\left(\text{by law L16}\right)}$ ${\displaystyle =\left(\frac{1}{\sqrt{2}}\cdot |\mathbf{0}〈.〉+\frac{1}{\sqrt{2}}\cdot |\mathbf{1}〈.〉\right)\otimes |\mathbf{0}〈.〉\left(\text{by the result of}\mathit{H}\times |\mathbf{0}〈.〉\text{and law L11}\right)}$ ${\displaystyle =\frac{1}{\sqrt{2}}\cdot |\mathbf{0}〈.〉\otimes |\mathbf{0}〈.〉+\frac{1}{\sqrt{2}}\cdot |\mathbf{1}〈.〉\otimes |\mathbf{0}〈.〉\left(\text{by law L18}\right)}$ ${\displaystyle \mathit{CX}\times \left(\left(\mathit{H}\otimes \mathit{I}\right)\times \left(|\mathbf{0}〈.〉\otimes |\mathbf{0}〈.〉\right)\right)}$ ${\displaystyle =\left({\mathit{B}}_0\otimes \mathit{I}+{\mathit{B}}_3\otimes \mathit{X}\right)\times \left(\frac{1}{\sqrt{2}}\cdot |\mathbf{0}〈.〉\otimes |\mathbf{0}〈.〉+\frac{1}{\sqrt{2}}\cdot |\mathbf{1}〈.〉\otimes |\mathbf{0}〈.〉\right)\left(\text{by replacement of}\mathit{CX},\text{and the result of}\left(\mathit{H}\otimes \mathit{I}\right)\times \left(|\mathbf{0}〈.〉\otimes |\mathbf{0}〈.〉\right)\right)}$ ${\displaystyle =\left({\mathit{B}}_0\otimes \mathit{I}\right)\times \left(\frac{1}{\sqrt{2}}\cdot |\mathbf{0}〈.〉\otimes |\mathbf{0}〈.〉\right)+\left({\mathit{B}}_0\otimes \mathit{I}\right)\times \left(\frac{1}{\sqrt{2}}\cdot |\mathbf{1}〈.〉\otimes |\mathbf{0}〈.〉\right)+\left({\mathit{B}}_3\otimes \mathit{X}\right)\times \left(\frac{1}{\sqrt{2}}\cdot |\mathbf{0}〈.〉\otimes |\mathbf{0}〈.〉\right)+}$ ${\displaystyle {\mathit{B}}_3\otimes \mathit{X}\times \left(\frac{1}{\sqrt{2}}\cdot |\mathbf{1}〈.〉\otimes |\mathbf{0}〈.〉\right)\left(\text{by laws L14 and L15}\right)}$ ${\displaystyle =\frac{1}{\sqrt{2}}\cdot \left({\mathit{B}}_0\times |\mathbf{0}〈.〉\right)\otimes \left(\mathit{I}\times |\mathbf{0}〈.〉\right)+\frac{1}{\sqrt{2}}\cdot \left({\mathit{B}}_0\times |\mathbf{1}〈.〉\right)\otimes \left(\mathit{I}\times |\mathbf{0}〈.〉\right)+\frac{1}{\sqrt{2}}\cdot \left({\mathit{B}}_3\times |\mathbf{0}〈.〉\right)\otimes \left(\mathit{X}\times |\mathbf{0}〈.〉\right)+}$ ${\displaystyle \frac{1}{\sqrt{2}}\cdot \left({\mathit{B}}_3\times |\mathbf{1}〈.〉\right)\otimes \left(\mathit{X}\times |\mathbf{0}〈.〉\right)\left(\text{by laws L8, L9, and L16}\right)}$ ${\displaystyle =\frac{1}{\sqrt{2}}\cdot |\mathbf{0}〈.〉\otimes |\mathbf{0}〈.〉+\frac{1}{\sqrt{2}}\cdot |\mathbf{1}〈.〉\otimes |\mathbf{1}〈.〉\left(\text{by replacements of}{\mathit{B}}_0,{\mathit{B}}_3,\text{and}\mathit{X},\text{and laws L1, L11,}\text{and L15}\right)}$

Using the laws, the term is reduced to a normal form that is a linear combination of the tensor product of the standard basis with scalars. The whole process is conducted automatically in Maude and the result is the same as expected. The key idea is to reduce the matrix multiplication in the form of 〈i|j〉 into a scalar and simplify the matrix representation by absorbing ones and eliminating zeros (see law L3). In this manner, our symbolic reasoning about matrices can be conducted automatically by rewriting in Maude instead of explicitly calculating matrices.

Maude specification of qubits, gates, and measurements

Qubits are specified in Maude as the linear combination of tensor product of the standard basis in Dirac notation with scalars and similarly for quantum gates. Because |0〈.〉 and |1〈.〉 can be viewed as 2 × 1 matrices, then qubits and quantum gates are basically matrices. Quantum gates act on qubits (a quantum state) specified in Maude as a matrix multiplication with a deterministic transition in Maude. In this article, we only consider binary projective measurements on the standard basis, and thus the measurement operators are {M₀, M₁}. A measurement of a single qubit in a quantum state is specified in Maude by two state transitions with probabilities p(m) for m ∈ {0, 1}, making a non-deterministic probabilistic transition. Each of the two transitions shows how its measurement operator acts on the single qubit in a state and is specified similarly as quantum gates, however, with respect to the probabilities.

A generic maude specification of quantum circuits

Quantum circuits are composed of a sequence of quantum gates, measurements, initializations of qubits, and possibly other actions. In this article, we consider the specification of the whole quantum state of a quantum circuit, the classical bits obtained from measurements, and the sequence of quantum gates, measurements, and conditional gates describing how a quantum circuit works. We then build Kripke structures for quantum circuits in order to conduct model checking that quantum circuits satisfy desired properties. Some essential elements are shared in the Kripke structures, making a first step toward a general framework for specifying and verifying quantum circuits.

 
 
   (i ↦→ b)    

 
 
   qstate    

 
 
   prob 

 
 
   bits 

 
 
   actions 

 
 
   isEnd 

 
 
   OCs    

 
 
   Q 

 
 
   Q’ 

 
 
   BM 

 
 
   Prob 

 
 
   Prob’ 

 
 
   AL 

  
 
   AL’ 

 
 
   B 

 
 
   N 

 
 
   N1 

 
 
   N2 

 
 
rl [I] : {(qstate: Q) (actions: (I(N) AL)) OCs} 
=> {(qstate: Q) (actions: AL) OCs} . 
crl [X] : {(qstate: Q) (actions: (X(N) AL)) OCs} 
=> {(qstate: Q’) (actions: AL) OCs} 
if Q’ := (Q).X(N) . 
crl [Y] : {(qstate: Q) (actions: (Y(N) AL)) OCs} 
=> {(qstate: Q’) (actions: AL) OCs} 
if Q’ := (Q).Y(N) . 
crl [Z] : {(qstate: Q) (actions: (Z(N) AL)) OCs} 
=> {(qstate: Q’) (actions: AL) OCs} 
if Q’ := (Q).Z(N) . 
crl [H] : {(qstate: Q) (actions: (H(N) AL)) OCs} 
=> {(qstate: Q’) (actions: AL) OCs} 
if Q’ := (Q).H(N) . 
crl [CX] : {(qstate: Q) (actions: (CX(N1, N2) AL)) OCs 
    } 
=> {(qstate: Q’) (actions: AL) OCs} 
if Q’ := (Q).CX(N1, N2) .    

 
 
   I 

 
 
   X 

 
 
   Y 

 
 
   Z 

  
 
   H 

 
 
   CX 

 
 
   qstate 

 
 
   actions 

 
 
crl [M0] : {(qstate: Q) (actions: (M(N) AL)) (prob: 
    Prob) (bits: BM) OCs} 
=> {(qstate: Q’) (actions: AL) (prob: (Prob .* Prob’)) 
     (bits: insert(N, 0, BM)) OCs} 
if {qstate: Q’, prob: Prob’} := (Q).M(P0,N) . 
crl [M1] : {(qstate: Q) (actions: (M(N) AL)) (prob: 
    Prob) (bits: BM) OCs} 
=> {(qstate: Q’) (actions: AL) (prob: (Prob .* Prob’)) 
     (bits: insert(N, 1, BM)) OCs} 
if {qstate: Q’, prob: Prob’} := (Q).M(P1,N) .    

 
 
   M0 

 
 
   M1 

 
 
   N 

 
 
   bits 

 
 
   prob  

 
 
   qstate 

 
 
rl [cif]: 
{(qstate: Q) (bits: ((N |-> N1),BM)) (actions: ((c[N] 
    == N2 ? AL’) AL)) OCs} 
=> {(qstate: Q) (bits: ((N |-> N1), BM)) 
     (actions: ((if (N1 == N2) then AL’ else nil fi) AL 
    )) OCs} .    

 
 
   c[N] x== N2 ? AL’ 

 
 
   N1 

 
 
   N 

 
 
   N2 

 
 
   AL’ 

 
 
   AL 

  
 
   actions 

 
 
rl [end]: {(actions: nil) (isEnd: false) OCs} 
=> {(actions: nil) (isEnd: true) OCs} . 
rl [stutter]: {(isEnd: true) OCs} 
=> {(isEnd: true) OCs} .    

 
 
   end 

 
 
   nil 

 
 
   stutter 

 
 
   isEnd 

Superdense coding

Specification of superdense coding

Regarding the actions specified in ‘Formal Specification’, we can describe the circuit for Superdense Coding with different values of classical bits used for (x, y) as follows:

• (x, y) = (0, 0) with σ₀ = I: H(0) CX(0, 1) I(0) CX(0, 1) H(0) M(0) M(1)

• (x, y) = (0, 1) with σ₁ = X: H(0) CX(0, 1) X(0) CX(0, 1) H(0) M(0) M(1)

• (x, y) = (1, 1) with σ₂ = Y: H(0) CX(0, 1) Y(0) CX(0, 1) H(0) M(0) M(1)

• (x, y) = (1, 0) with σ₃ = Z: H(0) CX(0, 1) Z(0) CX(0, 1) H(0) M(0) M(1)

Let I_SC be the set of initial states for Superdense Coding. It consists of four initial states corresponding to the four possible values used for (x, y) as follows:

 
 
{(isEnd: false) 
(prob: 1) 
(qstate: (q[0]: |0>) (q[1]: |0>)) 
(bits: empty) 
(actions: H(0) CX(0, 1) I(0) CX(0, 1) H(0) 
            M(0) M(1))} 
{(isEnd: false) 
(prob: 1) 
(qstate: (q[0]: |0>) (q[1]: |0>)) 
(bits: empty) 
(actions: H(0) CX(0, 1) X(0) CX(0, 1) H(0) 
            M(0) M(1))} 
{(isEnd: false) 
(prob: 1) 
(qstate: (q[0]: |0>) (q[1]: |0>)) 
(bits: empty) 
(actions: H(0) CX(0, 1) Y(0) CX(0, 1) H(0) 
            M(0) M(1))} 
{(isEnd: false) 
(prob: 1) 
(qstate: (q[0]: |0>) (q[1]: |0>)) 
(bits: empty) 
(actions: H(0) CX(0, 1) Z(0) CX(0, 1) H(0) 
            M(0) M(1))}    

Let us refer to the four initial states as

 
 
   init0 

,

 
 
   init1 

,

 
 
   init2 

, and

  
 
   init3 

, respectively. Initially, for each initial state, the

 
 
   isEnd 

observable component is false, the

 
 
   prob 

observable component is one, the

 
 
   qstate 

is the basic state (saying |00〈.〉), while the

 
 
   actions 

observable component contains the action list describing how Superdense Coding works with respect to the values of classical bits x and y.

 
 
   isGateI    

 
 
   isGateX 

 
 
   isGateY 

 
 
   isGateZ 

 
 
eq {(isEnd: true) (bits: BM) (prob: Prob) OCs} |= 
    isGateI 
= (Prob > 0) implies (BM[0] == 0 and BM[1] == 0) . 
eq {(isEnd: true) (bits: BM) (prob: Prob) OCs} |= 
    isGateX 
= (Prob > 0) implies (BM[0] == 0 and BM[1] == 1) . 
eq {(isEnd: true) (bits: BM) (prob: Prob) OCs} |= 
    isGateY 
= (Prob > 0) implies (BM[0] == 1 and BM[1] == 1) . 
eq {(isEnd: true) (bits: BM) (prob: Prob) OCs} |= 
    isGateZ 
= (Prob > 0) implies (BM[0] == 1 and BM[1] == 0) . 
eq {OCs} |= PROP = false [owise] .    

 
 
   BM    

 
 
   Prob 

 
 
   isGateI    

 
 
   (isEnd: true) 

 
 
   (bits: BM) 

 
 
   (prob: Prob) 

 
 
   BM[0] == 0 and BM[1] == 0 

 
 
   Prob > 0 

 
 
   gateIProp 

  
 
   gateXProp 

 
 
   gateYProp 

 
 
   gateZProp 

 
 
   <> isGateI 

 
 
   <> isGateX 

 
 
   <> isGateY 

 
 
   <> isGateZ 

 
 
   <> 

 
 
   gateIProp    

 
 
   gateXProp 

 
 
   gateYProp 

 
 
   gateZProp 

 
 
   init0 

 
 
   init1 

 
 
   init2 

 
 
   init3 

 
 
red modelCheck(init0, gateIProp) . 
red modelCheck(init1, gateXProp) . 
red modelCheck(init2, gateYProp) . 
red modelCheck(init3, gateZProp) .    

 
 
   gateIProp 

 
 
   gateXProp 

 
 
   gateYProp 

 
 
   gateZProp 

 
 
red modelCheck(init0, gateXProp) . 
red modelCheck(init0, gateYProp) . 
red modelCheck(init0, gateZProp) . 
red modelCheck(init1, gateIProp) . 
red modelCheck(init1, gateYProp) . 
red modelCheck(init1, gateZProp) . 
red modelCheck(init2, gateIProp) . 
red modelCheck(init2, gateXProp) . 
red modelCheck(init2, gateZProp) . 
red modelCheck(init3, gateIProp) . 
red modelCheck(init3, gateXProp) . 
red modelCheck(init3, gateYProp) .    

 
 
   init0 

 
 
   init1 

 
 
   init2 

 
 
   init3 

Quantum teleportation

Specification of quantum teleportation

We can describe the circuit for Quantum Teleportation based on the actions specified in ‘Formal Specification’ as follows:

 
 
H(1) CX(1, 2) CX(0, 1) H(0) M(0) M(1) (c[1] == 1 ? X 
    (2)) (c[0] == 1 ? Z(2))    

Let I_QT be the set of initial states for Quantum Teleportation. It consists of only one initial state as follows:

 
 
{(isEnd: false) 
(prob: 1) 
(qstate: (q[0]: a . |0> + b . |1>) 
           (q[1]: |0>) (q[2]: |0>)) 
(bits: empty) 
(actions: H(1) CX(1, 2) CX(0, 1) H(0) 
            M(0) M(1) 
            c[1] == 1 ? X(2) 
            c[0] == 1 ? Z(2))}    

where

 
 
   a 

and

 
 
   b 

are Maude constants denoting arbitrary scalars such that |a|² + |b|² = 1. Initially, the

 
 
   isEnd 

observable component is false, the

 
 
   prob 

observable component is one, the

 
 
   qstate 

is a symbolic state that is the same as the input state of the protocol, the

  
 
   actions 

observable component contains the action list describing how the protocol works.

 
 
   init    

 
 
   isSuccess 

 
 
eq {(isEnd: true) (qstate: Q) (prob: Prob) OCs} |= 
    isSuccess 
= Prob > 0 implies (qubitAt(Q, 2) ==  qubitAt(qstate( 
    init), 0) and 
   qubitAt(Q, 0) =/=  qubitAt(qstate(init), 0)) . 
eq {OCs} |= PROP = false [owise] .    

 
 
   Q    

 
 
   Prob 

 
 
   isSuccess    

 
 
   (isEnd: true) 

 
 
   (qstate: Q) 

 
 
   (prob: Prob) 

 
 
   qubitAt(Q, 2) == qubitAt(qstate(init), 0) 

 
 
   qubitAt(Q, 0) == qubitAt(qstate(init), 0) 

 
 
   Prob > 0 

 
 
   teleProp  

 
 
   <> isSuccess 

 
 
   teleProp    

 
 
   init 

 
 
red modelCheck(init, teleProp) .    

 
 
   teleProp 

 
 
   Prob > 1/2    

 
 
   isSuccess 

 
 
eq {(isEnd: true) (qstate: Q) (prob: Prob) OCs} |= 
    isSuccess 
= Prob > 0 implies (qubitAt(Q, 2) ==  qubitAt(qstate( 
    init), 0) and 
   qubitAt(Q, 0) =/=  qubitAt(qstate(init), 0) and Prob 
    < 1/2) .    

 
 
   qubitAt(Q, 0) =/= qubitAt(qstate(init), 0)    

 
 
   qubitAt(Q, 0) == qubitAt(qstate(init), 0) 

 
 
   isSuccess 

 
 
   TELEPORT    

 
 
   init 

 
 
   TELEPORT 

 
 
search  in  TELEPORT: init 
=>* {(qstate: Q) (isEnd: true) (prob: P) OCs} 
such  that not ( 
   Prob > 0 implies (qubitAt(Q, 2) ==  qubitAt(qstate( 
    init), 0) and 
   qubitAt(Q, 0) =/=  qubitAt(qstate(init), 0)) 
) .    

 
 
   (isEnd: true)    

 
 
   (qstate: Q) 

 
 
   (prob: Prob) 

 
 
   isSuccess 

Quantum secret sharing

Specification of quantum secret sharing

We can describe the circuit for Quantum Secret Sharing based on the actions specified in ‘Formal Specification’ as follows:

 
 
H(1) CX(1, 2) CX(1, 3) CX(0, 1) H(0) H(2) M(0) M(1) M 
    (2) 
(c[1] == 1 ? X(3)) (c[0] == 1 ? Z(3)) (c[2] == 1 ? Z 
    (3))    

Let I_QSS be the set of initial states for Quantum Secret Sharing. It consists of only one initial state as follows:

 
 
{(isEnd: false) 
(prob: 1) 
(qstate: (q[0]: a . |0> + b . |1>) 
           (q[1]: |0>) (q[2]: |0>) (q[3]: |0>)) 
(bits: empty) 
(actions: 
    H(1) CX(1, 2) CX(1, 3) CX(0, 1) H(0) H(2) 
    M(0) M(1) M(2) 
    c[1] == 1 ? X(3) 
    c[0] == 1 ? Z(3) 
    c[2] == 1 ? Z(3))}    

where

 
 
   a 

and

 
 
   b 

are Maude constants denoting arbitrary scalars such that |a|² + |b|² = 1. Initially, the

 
 
   isEnd 

observable component is false, the

 
 
   prob 

observable component is one, the

 
 
   qstate  

is a symbolic state that is the same as the input state of the protocol, the

 
 
   actions 

observable component contains the action list describing how the protocol works.

 
 
   init    

 
 
   isSuccess 

 
 
eq {(isEnd: true) (qstate: Q) (prob: Prob) OCs} |= 
    isSuccess 
= Prob > 0 implies (qubitAt(Q, 3) ==  qubitAt(qstate( 
    init), 0) or 
                        (-1) . qubitAt(Q, 3) ==  qubitAt( 
    qstate(init), 0)). 
eq {OCs} |= PROP = false [owise] .    

 
 
   Q    

 
 
   Prob 

 
 
   isSuccess    

 
 
   (isEnd: true) 

 
 
   (qstate: Q) 

 
 
   (prob: Prob) 

 
 
   qubitAt(Q, 3) == qubitAt(qstate(init), 0) 

 
 
   qubitAt(Q, 3) == qubitAt(qstate(init), 0) 

 
 
   Prob > 0 

  
 
   (-1). qubitAt(Q, 3) == qubitAt(qstate(init), 0) 

 
 
   qubitAt(Q, 3) == qubitAt(qstate(init), 0) 

 
 
   secretProp 

 
 
   <> isSuccess 

 
 
   secretProp    

 
 
   init 

 
 
red modelCheck(init, secretProp) .    

 
 
   secretProp 

Quantum gate teleportation

Introduction

Quantum Gate Teleportation (QGT) is a generalization of quantum teleportation invented by Gottesman & Chuang (1999) for teleporting two arbitrary states through the controlled-NOT gate with the use of six qubits and four classical bits. This protocol can be regarded as a single technique to reduce resource requirements for quantum computers and unifies known protocols for fault-tolerant quantum computations, demonstrating its importance.

The circuit for Quantum Gate Teleportation² is depicted in Fig. 5. Alice acts on q₀ and q₁, Bob acts on q₂, q₃, q₄, and q₅ as follows:

• First, Alice prepares an arbitrary unknown state |ψ〈.〉 = a|0〈.〉 + b|1〈.〉 at q₀, where a and b are complex numbers such that |a|² + |b|² = 1. Similarly, Bob also prepares an arbitrary unknown state |φ〈.〉 = c|0〈.〉 + d|1〈.〉 at q₅. Initially, q₁, q₂, q₃, and q₄ are in the basic state |0〈.〉.

• Second, we prepare an entangled state shared between Alice and Bob from q₁ to q₄ by applying a sequence of quantum gates as follows. We first apply the H gate on q₁, the CX gate on q₁ and q₂, the H gate on q₃, the CX gate on q₃ and q₄, and finally the CX gate on q₃ and q₂.

• Third, Alice then applies the CX gate on q₁ and q₀ followed by the H gate on q₁. Meanwhile, Bob applies the CX gate on q₅ and q₄ followed by the H gate on q₅.

• Fourth, we measure the qubits q₀, q₁, q₄, and q₅ and immediately obtain four classical outcomes (0 or 1) stored in c₀, c₁, c₄, and c₅, respectively.

• Fifth, we conditionally apply the X gate on q₂ and q₃, the Z gate on q₃, the X gate on q₂, and the Z gate on q₂ and q₃, depending on the four classical bits in c₄, c₅, c₀, and c₁.

At the end, Bob will have the controlled-NOT gate of |φ〈.〉 and |ψ〈.〉 (i.e., CX(|φ〈.〉, |ψ〈.〉) at the indices q₂ and q₃. We would like to verify whether Alice can successfully teleport two arbitrary unknown quantum states through the controlled-NOT gate to Bob at q₂ and q₃ at the end by using our symbolic model checking.

 
 
H(1) CX(1, 2) H(3) CX(3, 4) CX(3, 2) CX(1, 0) H(1) CX 
    (5, 4) H(5) 
M(0) M(1) M(4) M(5) 
(c[4] == 1 ? X(2) X(3)) 
(c[5] == 1 ? Z(3)) 
(c[0] == 1 ? X(2)) 
(c[1] == 1 ? Z(2) Z(3))    

 
 
{(isEnd: false) 
(prob: 1) 
(qstate: (q[0]: a . |0> + b . |1>) 
           (q[1]: |0>) (q[2]: |0>) 
           (q[3]: |0>) (q[4]: |0>) 
           (q[5]: c . |0> + d . |1>)) 
(bits: empty) 
(actions: 
    H(1) CX(1, 2) H(3) CX(3, 4) CX(3, 2) CX(1, 0) H(1) 
    CX(5, 4) H(5) 
    M(0) M(1) M(4) M(5) 
    (c[4] == 1 ? X(2) X(3)) 
    (c[5] == 1 ? Z(3)) 
    (c[0] == 1 ? X(2)) 
    (c[1] == 1 ? Z(2) Z(3))}    

 
 
   a 

 
 
   b 

 
 
   c 

 
 
   d 

  
 
   isEnd 

 
 
   prob 

 
 
   qstate 

 
 
   actions 

 
 
   init    

 
 
   isSuccess 

 
 
eq {(isEnd: true) (qstate: Q) (prob: Prob) OCs} |= 
    isSuccess 
= Prob > 0 implies (qubitAt(Q, 3 2) ==  qubitAt( 
    targetQState, 0 1) or 
                        (-1) . qubitAt(Q, 3 2) ==  qubitAt( 
    targetQState, 0 1)) . 
eq {OCs} |= PROP = false [owise] .    

 
 
   Q    

 
 
   Prob 

 
 
   targetQState 

 
 
eq targetQState = ((q[0]: c . |0> + d . |1>) (q[1]: a 
    . |0> + b . |1>)).CX(0, 1) .    

 
 
   isSuccess 

 
 
   (isEnd: true) 

 
 
   (qstate: Q) 

 
 
   (prob: Prob) 

 
 
   qubitAt(Q, 3 2) == qubitAt(targetQState, 0 1) 

 
 
   (-1) . qubitAt(Q, 3 2) == qubitAt(target 

  
 
   QState, 0 1) 

 
 
   Prob > 0 

 
 
   (-1) . qubitAt(Q, 3 2) == qubitAt(targetQState, 0 1) 

 
 
   qubitAt(Q, 3 2) == qubitAt(targetQState, 0 1) 

 
 
   gateProp 

 
 
   <> isSuccess 

 
 
   gateProp    

 
 
   init 

 
 
red modelCheck(init, gateProp) .    

 
 
   gateProp 

Limitations

In the context of symbolic reasoning for complex numbers, we have extended rational numbers supported in Maude to deal with complex numbers. Our objective is to represent arbitrary complex numbers in a pure quantum state using fresh constants representing arbitrary complex numbers and manipulating them without using any concrete values for real numbers. As a result, our current framework cannot handle any concrete values for real numbers. Nevertheless, we plan to explore the use of float numbers supported in Maude for simulating quantum circuits with concrete values in the future. As shown in Appendix 2, we have specified some basic operations for complex numbers, such as multiplication, division, addition, conjugation, absolute, power, and square roots. Note that the formal specification of complex numbers is not complete in this article. Hence, there may be some cases where symbolic reasoning for complex numbers could not further reduce terms. As part of our future work, we aim to enrich the framework for complex number reasoning as much as possible.

Regarding symbolic reasoning for quantum computation, we only support a limited set of quantum gates, including I, X, Y, Z, H, CX, S, T, CY, CZ, SWAP, CCY, CCZ, and CSWAP gates. Consequently, a restricted set of quantum protocols can be described in our framework. Although we support a universal set of quantum gates, including the Clifford gates (i.e., H, S, and CX) and the phase shift gate T, universal quantum computations could not be handled by our framework at this moment because the symbolic reasoning for complex numbers is not complete. We would like to extend our symbolic reasoning to handle more quantum gates so that a wider range of quantum protocols can be verified using our approach.

Challenges and future prospects

There are some challenges that we need to address in order to use the Maude LTL model checker, a classical model checker, to verify quantum circuits with their desired properties. In addition, this section also outlines future prospects in model checking quantum circuits.

• First, we need to devise a way to specify quantum states, quantum gates, and measurements in a Maude specification to reason about quantum computation. We specified quantum states, quantum gates, and measurements in Dirac notation and used a set of laws from quantum mechanics and basic matrix operations to reason about quantum computation automatically in Maude. Moreover, Maude does not support complex numbers as a built-in type. Therefore, we extended rational numbers, a built-in type in Maude, so as to deal with complex numbers symbolically as described in Appendix A.

• Second, quantum gates can be applied to quantum states in a deterministic way, while quantum measurements are inherently non-deterministic and the states after the measurements will collapse. It is natural to use rewriting logic to describe non-deterministic or concurrent behaviors in Maude in the form of rewrite rules. We specified a binary projective measurement using two rewrite rules corresponding to two non-deterministic choices, as described in ‘Formal Specification’.

• Third, we need to appropriately handle both pure and entangled states in our formal specification and devise a simple notation to conveniently describe the behavior of quantum circuits. We specified a whole quantum state as a collection of qubits associated with indices in quantum circuits, enabling flexible reference to specific parts of a quantum state using indices. The behavior of quantum circuits has been specified as a list of actions, a convenient and sufficient approach for us to concisely describe their behavior.

• Lastly, we need to represent quantum states and quantum gates in order to effectively model check quantum circuits with as many qubits as possible. Using Dirac notation in our specification allows us to avoid many redundancies compared to explicitly using vectors and matrices to represent quantum states and quantum gates, respectively, making our representation more compact than that of Paykin, Rand & Zdancewic (2017). Early work proposed by Gay, Nagarajan & Papanikolaou (2005) could not support the analysis of quantum systems with five qubits, while our approach could handle case studies of up to ten qubits, showing the effectiveness of our approach. However, in order to handle quantum systems with hundreds of qubits in the future, we need to use or come up with advanced techniques to effectively simulate quantum computation(e.g., using decision diagrams for quantum computing proposed by Wille, Hillmich & Burgholzer (2022), Wille, Hillmich & Burgholzer (2023)) or analyze such quantum systems in a modular way.

Last but not least, our approach implemented in Maude can be a first step toward a general framework for specifying and verifying quantum circuits when we can reuse some essential elements in the Kripke structures. For specifying and verifying a quantum circuit, we are supposed to define an initial state, describe the behavior of the quantum circuit in terms of a list of actions, and specify atomic propositions and the labeling function based on which a desired property can be constructed. Given the system specification with the initial state and the desired property, the Maude LTL model checker automatically checks whether the system specification satisfies the desired property reachable from the initial state.