Geometry-Based Optimization of One-Way Quantum Computation Measurement   Patterns

Maryam Eslamy; Mahboobeh Houshmand; Morteza Saheb Zamani; Mehdi; Sedighi

arXiv:1704.07378·quant-ph·September 26, 2018

Geometry-Based Optimization of One-Way Quantum Computation Measurement Patterns

Maryam Eslamy, Mahboobeh Houshmand, Morteza Saheb Zamani, Mehdi, Sedighi

PDF

TL;DR

This paper introduces a geometry-based optimization scheme for one-way quantum computation patterns that improves efficiency by avoiding complex rewriting rules and focusing on flow and gflow structures.

Contribution

A novel geometry-centric optimization method for 1WQC patterns that enhances speed and simplifies the process by eliminating the need for rewriting rules.

Findings

01

The proposed scheme improves time complexity over previous methods.

02

It effectively finds the maximally delayed gflow order.

03

Optimization is achieved directly from geometries without rewriting rules.

Abstract

In one-way quantum computation (1WQC) model, an initial highly entangled state called a graph state is used to perform universal quantum computations by a sequence of adaptive single-qubit measurements and post-measurement Pauli-X and Pauli-Z corrections. The needed computations are organized as measurement patterns, or simply patterns, in the 1WQC model. The entanglement operations in a pattern can be shown by a graph which together with the set of its input and output qubits is called the geometry of the pattern. Since a one-way quantum computation pattern is based on quantum measurements, which are fundamentally nondeterministic evolutions, there must be conditions over geometries to guarantee determinism. Causal flow is a sufficient and generalized flow (gflow) is a necessary and sufficient condition over geometries to identify a dependency structure for the measurement sequences in…

Figures3

Click any figure to enlarge with its caption.

Tables5

Table 1. Table 1: Description of qubit attributes

Attribute	Description
q.ZList	This list consists of all qubits from which the qubit $q$ receives a $Z$ -correction. This list is empty at first.
q.XList	This list consists of all qubits from which the qubit $q$ receives an $X$ -correction. This list is empty at first.
q.angle	It shows the qubit measurement angle.
q.Level	It shows the qubit level in the maximally delayed gflow order, $≺_{s}$ , and is calculated for non-output qubits in the input geometry with flow.
fg(q)	This parameter is filled according to the input geometry with flow or gflow. If the input geometry has the flow condition, this parameter is used to keep the flow of each qubit in the geometry. For the input geometry with gflow, it contains the gflow of each qubit in the geometry. This parameter is empty for the output qubits in each case.
$f g^{- 1} (q)$	This parameter is filled according to the input geometry with flow or gflow. If the input geometry has the flow condition, this parameter is used to keep the reverse flow of each qubit in the geometry. For example, if $f (v) = q$ , then $f^{- 1} (q) = v$ . It is obtained by modifying the algorithm in [16] which produces the optimal flow over geometries. Otherwise, if it has the gflow condition, this parameter consists of the reverse gflow of each qubit in the geometry. This parameter is empty for the input qubits in each case.
q.NeighborList	This list includes all vertices which are the neighbors of the qubit $q$ in the geometry.
q.NeighborZLis	This list consists of all qubits that are $Z$ -dependency neighborhood of the qubit $q$ . It is the output of the function FindNeighborZQubit.
q.Odd	This parameter shows whether the number of qubits from which the qubit $q$ receives a $Z$ -correction (directly or indirectly) is odd or not. It is initialized as FALSE for the first time and is complemented in each loop.

Table 2. Table 2: Step by step running of the proposed method on sample geometry of Fig. 2

Lable	$f^{- 1} (q)$	angle	NeighborZ	Xlist	Zlist	Level
1	$⊘$	$\frac{π}{9}$	$N_{Z (1)} = {}$	$X_{1} = {}$	$Z_{1} = {}$	1
2	$1$	$\frac{π}{10}$	$N_{Z (2)} = {}$	$X_{2} = {1}$	$Z_{2} = {}$	2
3	$2$	$-$	$N_{Z (3)} = {4, 7, 1}$	$X_{3} = {2}$	$Z_{3} = {4, 7, 1}$	$-$
4	$⊘$	$\frac{5 π}{9}$	$N_{Z (4)} = {}$	$X_{4} = {}$	$Z_{4} = {}$	1
5	$4$	$\frac{π}{2}$	$N_{Z (5)} = {2}$	$X_{5} = {}$	$Z_{5} = {2, 4}$	2
6	$5$	$-$	$N_{Z (6)} = {4, 7}$	$X_{6} = {5, 2, 4}$	$Z_{6} = {4, 7}$	$-$
7	$⊘$	$\frac{π}{11}$	$N_{Z (7)} = {}$	$X_{7} = {}$	$Z_{7} = {}$	1
8	$7$	$\frac{π}{10}$	$N_{Z (8)} = {5, 2}$	$X_{8} = {7}$	$Z_{8} = {5, 4}$	2
9	$8$	$\frac{3 π}{9}$	$N_{Z (9)} = {7}$	$X_{9} = {8, 5, 4}$	$Z_{9} = {7}$	3
10	$9$	$-$	$N_{Z (10)} = {8}$	$X_{10} = {9, 7}$	$Z_{10} = {8, 5, 4}$	$-$

Table 3. Table 3: Step by step running of the proposed method on sample geometry of Fig. 3 .

Lable	$g^{- 1} (q)$	angle	NeighborZ	Xlist	Zlist
1	$⊘$	$θ_{1}$	$N_{Z (1)} = {3, 5, 3, 5}$	$X_{1} = {}$	$Z_{1} = {}$
2	${1, 5, 3}$	$-$	$N_{Z (2)} = {}$	$X_{2} = {5, 3}$	$Z_{2} = {}$
3	$⊘$	$θ_{2}$	$N_{Z (3)} = {1, 5, 5}$	$X_{3} = {}$	$Z_{3} = {1}$
4	${3}$	$-$	$N_{Z (4)} = {}$	$X_{4} = {1, 3}$	$Z_{4} = {}$
5	$⊘$	$θ_{3}$	$N_{Z (5)} = {3, 3}$	$X_{5} = {}$	$Z_{5} = {}$
6	${3, 5}$	$-$	$N_{Z (6)} = {}$	$X_{6} = {1, 5, 3}$	$Z_{6} = {}$

Table 4. Table 4: Some signal shifted patterns extracted by the proposed approach

N	Input circuit	Optimized pattern
1	$𝒱 = \frac{1 + i}{2} [\begin{matrix} 1 & - i \\ - i & 1 \end{matrix}]$	$V : {1, 2, 3}$ $I : {1}$ $O : {3}$
		$C : X_{3}^{s_{2} + s_{1}} Z_{3}^{s_{1}}$
		$M : M_{2}^{0} M_{1}^{- \frac{π}{2}}$
		$E : E_{23} E_{12}$
1	$V^{†} = \frac{1 - i}{2} [\begin{matrix} 1 & i \\ i & 1 \end{matrix}]$	$V = {1, 2, 3, 4, 5}$ , $I = {1}$ , $O = {5}$
		$C : X_{5}^{s_{4} + s_{2} + s_{1}} Z_{5}^{s_{1} + s_{3}} M_{4}^{0} {[M_{3}^{- π}]}^{s_{2} + s_{1}}$
		$M : M_{2}^{- \frac{π}{2}} M_{1}^{0}$
		$E : E_{45} E_{34} E_{23} E_{12}$
2	CNOT	$V : {1, 2, 3, 4}$ $I : {1, 2}$ $O : {1, 4}$
		$C : X_{4}^{s_{3}} Z_{4}^{s_{2}} Z_{1}^{s_{2}}$
		$M : M_{3}^{0} M_{2}^{0}$
		$E : E_{34} E_{23} E_{13}$
2	SWAP	$V : {1, 2, 3, \dots, 8}$ $I : {1, 2}$ $O : {6, 8}$
		$C : X_{8}^{s_{5} + s_{7}} Z_{8}^{s_{1} + s_{4}} X_{6}^{s_{3} + s_{5}} Z_{6}^{s_{2} + s_{4}}$
		$M : M_{7}^{0} M_{5}^{0} M_{4}^{0} M_{3}^{0} M_{1}^{0}$
		$E : E_{78} E_{47} E_{56} E_{45} E_{15} E_{34} E_{23} E_{13}$
2	Bell states circuit [13]	$V = {1, 2, 3, 4, 5}$ , $I = {1, 2}$ , $O = {3, 5}$
		$C : X_{5}^{s_{1} + s_{4}} Z_{5}^{s_{2}} X_{3}^{s_{1}} Z_{3}^{s_{2}}$
		$M : M_{4}^{0} M_{2}^{0} M_{1}^{0}$
		$E : E_{4, 3} E_{2, 4, 5} E_{1, 3}$
3	Toffoli [13]	$V : {1, 2, \dots, 17}$ $I : {1, 2, 3}$ $O : {16, 17, 11}$
		$C : X_{17}^{s_{12} + s_{14} + s_{15}} Z_{17}^{s_{2} + s_{4} + s_{6} + s_{13}} X_{16}^{s_{15}} Z_{16}^{s_{1} + s_{6} + s_{8} + s_{13}}$
		$X_{11}^{s_{4} + s_{6} + s_{8} + s_{10}} Z_{11}^{s_{3} + s_{5} + s_{7} + s_{9}}$
		$M : M_{15}^{0} M_{14}^{0} {[M_{13}^{\frac{π}{4}}]}^{s_{12}} M_{12}^{0} {[M_{10}^{- \frac{π}{4}}]}^{s_{3} + s_{5} + s_{7} + s_{9}} M_{9}^{0}$
		${[M_{8}^{\frac{π}{4}}]}^{s_{3} + s_{5} + s_{7}} M_{7}^{0} {[M_{6}^{- \frac{π}{4}}]}^{s_{3} + s_{5}} M_{5}^{0} {[M_{4}^{\frac{π}{4}}]}^{s_{3}} M_{3}^{0} M_{2}^{- \frac{π}{4}} M_{1}^{- \frac{π}{4}}$
		$E : E_{9, 10} E_{19} E_{89} E_{78} E_{27} E_{67} E_{56} E_{15} E_{45} E_{34} E_{23} E_{14, 17} E_{14, 16}$
		$E_{15, 16} E_{1, 15} E_{13, 14} E_{12, 13} E_{1, 12} E_{2, 12} E_{10, 11}$
2	CNOT with negative control [13]	$V : {1, 2, 3, \dots, 8}$ $I : {1, 2}$ $O : {8, 6}$
		$C : X_{8}^{s_{3} + s_{7}} Z_{8}^{s_{2} + s_{4} + s_{1}} X_{6}^{s_{3} + s_{5}} Z_{6}^{s_{2}}$
		$M : {[M_{7}^{- π}]}^{s_{1} + s_{2} + s_{4}} M_{5}^{0} M_{4}^{0} {[M_{3}^{- π}]}^{s_{1}} M_{2}^{0} M_{1}^{0}$
		$E : E_{78} E_{47} E_{45} E_{25} E_{56} E_{34} E_{13}$
2	Example 2 [11]	$V = {1, 2, 3, \dots, 6}$ , $I = {1, 4}$ , $O = {3, 6}$
		$C : Z_{6}^{s_{1} + s_{4}} X_{6}^{s_{1} + s_{5}} Z_{3}^{s_{1}} X_{3}^{s_{4} + s_{2}}$
		$M : M_{5}^{0} M_{2}^{\frac{π}{2}} M_{4}^{θ_{4}} M_{1}^{θ_{1}}$
		$E : E_{2, 5} E_{2, 4} E_{456} E_{123}$
3	Example 1 [11]	$V = {1, 2, 3, 4, 5, 6, 7, 8}$ , $I = {1, 4, 7}$ , $O = {3, 6, 8}$
		$C : X_{8}^{s_{7} + s_{4} + s_{5}} Z_{6}^{s_{1} + s_{4}} X_{6}^{s_{5} + s_{4} + s_{2}} Z_{3}^{s_{4}} X_{3}^{s_{1} + s_{2} + s_{4}}$
		$M : {[M_{5}^{θ_{5}}]}^{s_{4} + s_{1}} {[M_{2}^{θ_{2}}]}^{s_{1}} M_{7}^{θ_{7}} M_{4}^{θ_{4}} M_{1}^{θ_{1}}$
		$E : E_{7, 8} E_{6, 7} E_{3, 7} E_{5, 7} E_{3, 5} E_{2, 5} E_{4, 5, 6} E_{2, 4} E_{123}$
2	Example 1 [21]	$V = {1, 2, 3, 4, 5}$ , $I = {1, 3, 5}$ , $O = {2, 4, 5}$
		$C : X_{5}^{s_{3} + s_{1}} X_{4}^{s_{3} + s_{1}} X_{2}^{s_{1}}$
		$M_{3}^{θ_{3}} M_{1}^{θ_{1}}$
		$E : E_{1, 5} E_{3, 4} E_{3, 2} E_{1, 4} E_{1, 2}$

Table 5. Table 5: Comparison of the proposed approach to the previous studies

Algorithm	Input	Output	Time Complexity
Proposed algorithm	A geometry with flow	An optimized pattern	$O ({\| V \|}^{2} Δ (G))$
	A geometry with gflow	An optimized pattern	$O ({\| V \|}^{3})$
[12]	A pattern with flow or gflow	An optimized pattern	$O ({\| V \|}^{5})$

Equations51

∣ Φ ⟩ = (∣ 00 ⟩ + ∣ 11 ⟩) /\sqrt 2

∣ Φ ⟩ = (∣ 00 ⟩ + ∣ 11 ⟩) /\sqrt 2

σ_{0} = I = [1001], σ_{1} = X = [0110], σ_{2} = Y = [0 i - i 0], σ_{3} = Z = [10 0 - 1]

σ_{0} = I = [1001], σ_{1} = X = [0110], σ_{2} = Y = [0 i - i 0], σ_{3} = Z = [10 0 - 1]

H = \frac{1}{2} [11 1 - 1]

H = \frac{1}{2} [11 1 - 1]

CNOT = 1000010000010010

CNOT = 1000010000010010

CZ = 100001000010 000 - 1

CZ = 100001000010 000 - 1

∣ +_{α} ⟩ = \frac{1}{\sqrt 2} (∣ 0 ⟩ + e^{i α} ∣ 1 ⟩) (w i t h o u t co m e 0)

∣ +_{α} ⟩ = \frac{1}{\sqrt 2} (∣ 0 ⟩ + e^{i α} ∣ 1 ⟩) (w i t h o u t co m e 0)

∣ -_{α} ⟩ = \frac{1}{\sqrt 2} (∣ 0 ⟩ - e^{i α} ∣ 1 ⟩) (w i t h o u t co m e 1)

∣ -_{α} ⟩ = \frac{1}{\sqrt 2} (∣ 0 ⟩ - e^{i α} ∣ 1 ⟩) (w i t h o u t co m e 1)

^{t} [M_{i}^{α}]^{s} \equiv M_{i}^{α} X_{i}^{s} Z_{i}^{t} \equiv M_{i}^{((- 1)^{s} + t π)}

^{t} [M_{i}^{α}]^{s} \equiv M_{i}^{α} X_{i}^{s} Z_{i}^{t} \equiv M_{i}^{((- 1)^{s} + t π)}

J (α) = \frac{1}{2} [11 e^{i α} - e^{i α}]

J (α) = \frac{1}{2} [11 e^{i α} - e^{i α}]

J (α) = X_{2}^{s_{1}} M_{1}^{- α} E_{12}

J (α) = X_{2}^{s_{1}} M_{1}^{- α} E_{12}

CZ = E_{12}

CZ = E_{12}

E_{ij} X_{i}^{s} \Rightarrow X_{i}^{s} Z_{i}^{s} E_{ij}

E_{ij} X_{i}^{s} \Rightarrow X_{i}^{s} Z_{i}^{s} E_{ij}

E_{ij} Z_{i}^{s} \Rightarrow Z_{i}^{s} E_{ij}

E_{ij} A_{k \to} \Rightarrow A_{k \to} E_{ij}

A_{k \to} X_{i}^{s} \Rightarrow X_{i}^{s} A_{k \to}

A_{k \to} X_{i}^{s} \Rightarrow X_{i}^{s} A_{k \to}

A_{k \to} Z_{i}^{s} \Rightarrow Z_{i}^{s} A_{k \to}

M_{i}^{0} X_{i}^{s} = M_{i}^{0}

M_{i}^{0} X_{i}^{s} = M_{i}^{0}

M_{i}^{\frac{π}{2}} X_{i}^{s} = M_{i}^{\frac{π}{2}} Z_{i}^{s}

M_{i}^{\frac{π}{2}} X_{i}^{s} = M_{i}^{\frac{π}{2}} Z_{i}^{s}

^{t} [M_{i}^{α}]^{s} \Rightarrow S_{i}^{t} [M_{i}^{α}]^{s}

^{t} [M_{i}^{α}]^{s} \Rightarrow S_{i}^{t} [M_{i}^{α}]^{s}

^{t} [M_{j}^{α}]^{s} S_{i}^{r} \Rightarrow S_{i}^{r}^{t [(r + s_{i}) / s_{i}]} [M_{j}^{α}]^{s [(r + s_{i}) / s_{i}]}

^{t} [M_{j}^{α}]^{s} S_{i}^{r} \Rightarrow S_{i}^{r}^{t [(r + s_{i}) / s_{i}]} [M_{j}^{α}]^{s [(r + s_{i}) / s_{i}]}

X_{j}^{s} S_{i}^{r} \Rightarrow S_{i}^{r} X_{j}^{s [(r + s_{i}) / s_{i}]}

X_{j}^{s} S_{i}^{r} \Rightarrow S_{i}^{r} X_{j}^{s [(r + s_{i}) / s_{i}]}

Z_{j}^{s} S_{i}^{r} \Rightarrow S_{i}^{r} Z_{j}^{s [(r + s_{i}) / s_{i}]}

Z_{j}^{s} S_{i}^{r} \Rightarrow S_{i}^{r} Z_{j}^{s [(r + s_{i}) / s_{i}]}

S_{j}^{s} S_{i}^{r} \Rightarrow S_{i}^{r} S_{j}^{s [(r + s_{i}) / s_{i}]}

S_{j}^{s} S_{i}^{r} \Rightarrow S_{i}^{r} S_{j}^{s [(r + s_{i}) / s_{i}]}

X_{v}^{s_{1} + s_{2} +\cdot\cdot\cdot+ s_{m}} \Leftrightarrow S_{v} = {s_{1}} Δ {s_{2}} Δ...Δ {s_{m}} \forall v \in V

X_{v}^{s_{1} + s_{2} +\cdot\cdot\cdot+ s_{m}} \Leftrightarrow S_{v} = {s_{1}} Δ {s_{2}} Δ...Δ {s_{m}} \forall v \in V

Z_{v}^{t_{1} + t_{2} +\cdot\cdot\cdot+ t_{m}} \Leftrightarrow T_{v} = {t_{1}} Δ {t_{2}} Δ...Δ {t_{m}} \forall v \in V

Z_{v}^{t_{1} + t_{2} +\cdot\cdot\cdot+ t_{m}} \Leftrightarrow T_{v} = {t_{1}} Δ {t_{2}} Δ...Δ {t_{m}} \forall v \in V

Z_{10}^{s_{8} + s_{5} + s_{4}} X_{10}^{s_{7} + s_{9}} Z_{6}^{s_{4} + s_{7}} X_{6}^{s_{5} + s_{2} + s_{4}} Z_{3}^{s_{1} + s_{4} + s_{7}} X_{3}^{s_{2}} [M_{9}^{\frac{3 π}{9}}]^{s_{8} + s_{5} + s_{4}} [M_{8}^{\frac{π}{10}}]^{s_{7}} [M_{2}^{\frac{π}{10}}]^{s_{1}} M_{5}^{\frac{π}{2}} M_{7}^{\frac{π}{11}} M_{4}^{\frac{5 π}{9}} M_{1}^{\frac{π}{9}} E_{910} E_{89} E_{68} E_{78} E_{56} E_{45} E_{38} E_{35} E_{23} E_{12}

Z_{10}^{s_{8} + s_{5} + s_{4}} X_{10}^{s_{7} + s_{9}} Z_{6}^{s_{4} + s_{7}} X_{6}^{s_{5} + s_{2} + s_{4}} Z_{3}^{s_{1} + s_{4} + s_{7}} X_{3}^{s_{2}} [M_{9}^{\frac{3 π}{9}}]^{s_{8} + s_{5} + s_{4}} [M_{8}^{\frac{π}{10}}]^{s_{7}} [M_{2}^{\frac{π}{10}}]^{s_{1}} M_{5}^{\frac{π}{2}} M_{7}^{\frac{π}{11}} M_{4}^{\frac{5 π}{9}} M_{1}^{\frac{π}{9}} E_{910} E_{89} E_{68} E_{78} E_{56} E_{45} E_{38} E_{35} E_{23} E_{12}

X_{6}^{s_{1} + s_{5} + s_{3}} X_{4}^{s_{1} + s_{3}} X_{2}^{s_{5} + s_{3}} M_{5}^{θ_{5}} M_{3}^{θ_{3}} M_{1}^{θ_{1}} E_{36} E_{16} E_{56} E_{45} E_{34} E_{23} E_{12}

X_{6}^{s_{1} + s_{5} + s_{3}} X_{4}^{s_{1} + s_{3}} X_{2}^{s_{5} + s_{3}} M_{5}^{θ_{5}} M_{3}^{θ_{3}} M_{1}^{θ_{1}} E_{36} E_{16} E_{56} E_{45} E_{34} E_{23} E_{12}

Peer Reviews

No public reviews on file for this paper yet. If you reviewed it on a platform where reviews are public (OpenReview, ICLR, NeurIPS, ICML), you can paste yours below so the community can read it here.

Videos

No videos yet. Explain this paper in a talk, walkthrough, or lecture? Add one.

Full text

Geometry-Based Optimization of One-Way Quantum Computation Measurement Patterns††thanks: This paper is an extended version of the paper presented at ICEE 2016 [1].

Maryam Eslamy

Department of Computer Engineering and Information Technology, Amirkabir University of Technology, Tehran, Iran.

[email protected]

Mahboobeh Houshmand

Department of Computer Engineering, Mashhad Branch, Islamic Azad University, Mashhad, Iran

[email protected]

Morteza Saheb Zamani

Department of Computer Engineering and Information Technology, Amirkabir University of Technology, Tehran, Iran.

[email protected]

Mehdi Sedighi

Department of Computer Engineering and Information Technology, Amirkabir University of Technology, Tehran, Iran.

[email protected]

I. Introduction

Quantum computers which use quantum mechanical phenomena are different from digital electronic computers based on transistors. They are advantageous over the classical computers for solving certain problems such as integer factorization [2] and database search [3] much more quickly.

One-way quantum computation (1WQC) [4], [5] is a more recent model for quantum computation in which a specific highly entangled state called a graph state allows for universal quantum computation by single-qubit measurements and post-measurement Pauli- $X$ and Pauli- $Z$ corrections. The computations are driven by irreversible projective measurements and hence, the model is called “one-way".

1WQC has attracted researchers’ interests as it benefits from two important concepts in quantum mechanics, namely entanglement and measurement. This powerful framework introduces a different quantum computation model from the well-known quantum gate array model which is more similar to classic model of computations by networks of gates. It is also believed to have easier implementations in different quantum technologies [6, 7].

The needed computations in this model are organized as measurement patterns, or simply patterns. The entanglement operations in a pattern can be represented in a graph which together with the set of its input and output qubits is called the geometry of the pattern. Since a pattern is based on quantum measurements, which are fundamentally nondeterministic evolutions, there should be conditions over geometries to guarantee determinism. Causal flow [8] is a sufficient condition and generalized flow (gflow) [9] is a sufficient and necessary one over geometries for identifying a dependency structure for measurement sequences in order to obtain determinism. In 1WQC model [10], three different optimization techniques called standardization, signal shifting and Pauli simplification, which can be done using a set of rewrite rules have been proposed [10, 11].

However in these approaches, there should be a library for storing rewrite rules and automatically applying them is time consuming due to using many ineffective commutation rules which are performed on input pattern separately. To overcome this problem, the key result of this study is to provide an automatic approach to simultaneously perform these optimization techniques on patterns with flow or gflow***In the rest of this paper, whenever we refer to open graphs with gflow, the ones are considered that have gflow but not flow. only based on their geometries instead of using rewriting rules. This results in lower time complexity than the previous technique [12]. Moreover, our method can also calculate the maximally delayed gflow order for geometries with flow.

The remainder of this paper is as follows. The background material is presented in the next section. Section III reviews the related work. In Section IV, the proposed approach is explained. The proof and analysis of the proposed approach are described in Section V and finally, Section VII concludes the paper.

II. Preliminaries

In this section, some basic concepts and notations used in the rest of the paper are introduced and explained.

i. Quantum Circuit Model

Quantum bits or qubits are quantum analogues of classical bits. A qubit is a two-level quantum system whose state is represented by a unit vector in a two-dimensional Hilbert space, $\mathcal{H}_{2}$ , for which an orthonormal basis, denoted by $\{$$\left|0\right\rangle$ , $\left|1\right\rangle$$\}$ , has been fixed. Unlike classical bits, qubits can be a superposition of $\left|0\right\rangle$ and $\left|1\right\rangle$ like $a\left|0\right\rangle+b\left|1\right\rangle$ where $a$ and $b$ are complex numbers such that $|a|^{2}+|b|^{2}=1$ . If the qubit is measured in the $\{$$\left|0\right\rangle$ , $\left|1\right\rangle$$\}$ basis, the classic outcome of 0 is observed with the probability of $|a|^{2}$ and the classic outcome of 1 is observed with the probability of $|b|^{2}$ . If 0 is observed, the state of the qubit after the measurement collapses to $|0\rangle$ and otherwise, it collapses to $|1\rangle$ .

Entanglement is a quantum mechanical phenomenon that plays a key role in many of the applications of quantum computation and quantum information. A multi-qubit quantum state $\left|\psi\right\rangle$ is said to be entangled if it cannot be written as the tensor product $\left|\psi\right\rangle=\left|\phi_{1}\right\rangle\otimes\left|\phi_{2}\right\rangle$ of two pure states. For example, the EPR pair [13] shown below is an entangled quantum state:

[TABLE]

Quantum-circuit model is a well-known model of quantum computations [14], based on the unitary evolution of qubits by networks of gates. Every quantum gate is a linear transformation represented by a unitary matrix, defined on an $n$ -qubit Hilbert space. A matrix $U$ is unitary if $UU^{\dagger}=I$ , where $U^{\dagger}$ is the conjugate transpose of $U$ . Some useful single-qubit gates are the elements of the Pauli set which are defined as follows:

[TABLE]

Hadamard, $H$ is another known single-qubit gate defined as:

[TABLE]

If $U$ is a gate that operates on a single qubit, then controlled-U gate operates on two qubits, i.e., control and target qubits, and U is applied to the target qubit if the control qubit is $\left|1\right\rangle$ and leaves it unchanged otherwise. For example, controlled-X (CNOT) gate performs the X operator on the target qubit if the control qubit is $\left|1\right\rangle$ . Otherwise, the target qubit remains unchanged.

The matrix representation of CNOT gate is

[TABLE]

Similarly, the matrix representation of controlled-Z (CZ) gate is

[TABLE]

ii. Description of 1WQC model

Measurement patterns, or simply patterns, represent computations in the 1WQC model. A pattern is defined as P = (V, I, O, A), where V is the set of qubits, I $\subseteq$ V and O $\subseteq$ V are two possibly overlapping sets representing the pattern inputs and outputs respectively and A is a finite set of operations which act on V and is called command sequence. The set V is called computation space. Using the notations of [10], the following operations can be defined:

1-qubit auxiliary preparation $N_{v}$ prepares a qubit v $\in$ V in the ( $\left|0\right\rangle+\left|1\right\rangle)/\surd{2}$ state, 2. 2.

2-qubit entanglement operation $E_{uv}$ performs a CZ operation on qubits u,v $\in$ V, 3. 3.

1-qubit correction operations $X_{v}$ and $Z_{v}$ apply Pauli X and Z corrections on qubit v, and 4. 4.

1-qubit measurement operation $M_{v}^{\alpha}$ measures the qubit v in the orthonormal basis of:

[TABLE]

where $\alpha\in[0,2\pi]$ is called the angle of measurement. The outcome of a measurement on a qubit v is called $s_{v}$ , which is referred to as classical feedforward of the measurement results. Measurement outcomes can be added modulo 2 and are called signals. A measurement can depend on the other ones through two signals of s and t:

[TABLE]

The one-qubit Pauli correction commands, $X_{v}^{s}$ and $Z_{v}^{s}$ , apply the Pauli X and Z gates to the qubit v if the signal s=1 and do nothing if s=0:

$X_{v}^{1}=X_{v}$

$Z_{v}^{1}=Z_{v}$

$X_{v}^{0}=Z_{v}^{0}=I_{v}$

In this paper, it is assumed that all of the non-input qubits are prepared and hence the preparation commands on these qubits are omitted.

The patterns of $J(\alpha)$ and CZ gates are presented as examples. $J(\alpha)$ plays an important role in 1WQC and is defined as follows:

[TABLE]

The following pattern realizes the $J(\alpha)$ gate:

[TABLE]

where $\{1,2\}$ is the set of qubits, $\{1\}$ is the set of input qubits and $\{2\}$ is the set of output qubits.

In the rest of the paper, whenever the angle $\alpha$ is not important, the $J(\alpha)$ gate is simply referred to as a $J$ gate.

The following pattern implements CZ gate:

[TABLE]

where both $\{1,2\}$ are input and output qubits.

Different criteria may be used to evaluate a pattern. The size and the quantum computation depth of patterns are among the most considered criteria. The size of a pattern refers to the number of qubits involved in it. The quantum computation depth of a pattern or just quantum depth is the maximum number of levels of operations for the execution of the pattern due to the dependencies of measurement and correction commands. For example, the quantum depth of the standard pattern $P=\{\{1,\,2,\,...,5\},\,\{1\},\,\{5\},\,X_{5}^{s_{2}+s_{4}}Z_{5}^{s_{1}+s_{3}}M_{4}^{0}[M_{3}^{\alpha}]^{s_{2}}[M_{2}^{\theta}]^{s_{1}}M_{1}^{\beta}E_{12345}\}$ is 4 due to the dependencies of the qubits $1\to 2\to 3\to 5$ where each arrow shows the dependency of a qubit (e.g., 2) on the other (e.g., 1).

ii.1 Optimization in 1WQC

In [10], some optimization techniques were presented which will be used later in this paper. These techniques are introduced in the following.

Standardization

A pattern is said to be in the standard form if all of the entanglement operations appear first, followed by all of the measurement operations and the correction commands at the end of the command sequence. In other words, a measurement pattern P = (V, I, O, A) in the standard form can be written as CME where C represents the operators which perform all of the X and Z corrections, M is the operator attributed to all of the measurement commands and E represents the operators that perform all of the entanglement commands. To move the entanglement commands to the beginning of the command sequence, the following rewrite rules can be used:

[TABLE]

where A is an arbitrary command and ${\mathop{k}\limits^{\to}}$ represents the qubits acted on by A which do not contain i and j. By using the following commutativity rules, the correction commands can be moved to the end of the pattern:

[TABLE]

The $X_{i}^{s}$ and $Z_{i}^{s}$ correction commands also commute even when they act on the same qubit. This holds because the operators XZ and ZX differ only by a global phase.

Pauli Simplification

If a measurement angle is 0 ( $\frac{\pi}{2}$ ), the measurement is called a Pauli X (Pauli Y) measurement. When there is a Pauli X measurement on a qubit, the X correction dependencies from the qubit can be removed by using Equation 7.

[TABLE]

Similarly, when a Pauli Y measurement is performed on a qubit, the X correction dependencies can be changed to Z correction dependencies according to Equation 8.

[TABLE]

Therefore, there are no X corrections on the qubits whose measurement angles are 0 or $\frac{\pi}{2}$ .

Signal Shifting

All of the Z corrections on the measured qubits can be moved to the end of a pattern. This process is called signal shifting and the rewrite rules used for it are as the following:

[TABLE]

where $s[(r+s_{i})/s_{i}]$ denotes the substitution of $s_{i}$ with $r+s_{i}$ in signal s and $S_{i}^{r}$ is the signal shifting command which is used to move the signal to the left of 1WQC command sequence.

When an input pattern is simplified by these three optimization techniques, it is called an optimized measurement pattern, or simply optimized pattern.

iii. Graph Representation of 1WQC Patterns

In order to automatically manipulate 1WQC patterns, each pattern P graph in the standard form can be represented as a tuple G= (V, I, O, E, M, S, T) [15] where:

•

V is the set of vertices in G and each vertex represents a qubit,

•

I $\subset$ V is the set of input vertices,

•

O $\subset$ V is the set of output vertices,

•

E is the set of edges in G,

•

M is the set that represents measurement angles for the vertices in V,

•

S is the set of $S_{v}$ s. ( $S_{v}$ is the set of vertices that represents X correction dependencies on the vertex v $\in$ V), and

•

T is the set of $T_{v}$ s. ( $T_{v}$ is the set of vertices that represents Z correction dependencies on the vertex v $\in$ V).

The set of all vertices, input and output vertices in G and those in the pattern P are equal. The edges in G represent the entanglement commands of P. The set M contains the measurement angles of P. A vertex v is called X-dependent (Z-dependent) on another vertex w if an X (Z) correction has to be performed on the qubit v which depends on the measurement performed on the qubit w. The X correction signal on the qubit v in a pattern P is calculated by a symmetric difference in G:

[TABLE]

Similarly, the Z correction signal on the qubit v in the pattern P is calculated by a symmetric difference in G:

[TABLE]

A geometry (G,I,O) is an entanglement graph $G$ , together with subsets $I,O\in V$ representing the sets of input and output vertices of a measurement pattern.

iv. Determinism condition in 1WQC

Since a one-way quantum computation pattern is based on quantum measurements, which are fundamentally nondeterministic evolutions. The collection of possible measurement outcomes is called the branch of computation in 1WQC model. Because of the probabilistic nature of quantum measurement, there must be conditions over geometries to guarantee determinism. In this paper, the patterns are called deterministic pattern which satisfy three conditions as follows:

•

Each branch of computation is obtained with the same probability which is called strong determinism.

•

Uniform determinism which means that the pattern is deterministic for all values of its measurement angles.

•

Being deterministic after each single measurement, which is called stepwise determinism.

Flow is a sufficient and generalized flow (gflow) is a sufficient and necessary condition over geometries for the deterministic implementation of measurement patterns over geometries as defined below.

Definition 1.

Flow [8]. An open graph $(G,I,O)$ has a flow iff there exists a map $f:O^{C}\to I^{C}$ and a strict partial order $\prec_{f}$ over $V$ such that all of the following conditions hold for all $i\in O^{C}$ .

•

$i\prec_{f}f(i)$ ,

•

if $j\in N(f(i))$ , then $j=i$ or $i\prec_{f}j$ , where $N(m)$ is the neighbourhood of $m$ ,

•

$i\in N(f(i))$ .

Definition 2.

Generalised flow (gflow) [9]. An open graph $(G,I,O)$ has a gflow iff there exists a map $g:O^{C}\to P^{I^{C}}\backslash\{\emptyset\}$ (the set of all non-empty subsets of vertices in $I^{C}$ ) and a strict partial order $\prec_{g}$ over $V$ such that all of the following conditions hold for all $i\in O^{C}$ .

•

if $j\in g(i)$ then $i\prec_{g}j$ ,

•

if $j\in Odd(g(i))$ , then $j=i$ or $i\prec_{g}j$ , where $Odd(K)=\{k,\left|{N(k)\cap K}\right|=1\,\,\bmod\,\,2\}$ ,

•

$i\in Odd(g(i))$ .

In this definition, $Odd(K)$ is the set of vertices which have an odd number of connections with the members in the set $K$ . $G(i)$ contains all of the correcting set for the qubit $i$ and it should be noted that flow is a special case of gflow.

As shown in Fig. 3, the longest path from input to output qubits over those directed edges in the graph defines the depth of the gflow. According to this definition, there is a special type of gflow with minimal depth called maximally delayed gflow [11, 16], or simply optimal gflow. In [16], it is proven that there is no gflow of the same graph which is more delayed. In other words, the maximally delayed gflow is unique for the input graph with flow. We refer the reader to [11, 16] to find more details about the maximally delayed gflow.

III. Related work

Raussendorf and Briegel [17] first proved the universality of 1WQC by translating quantum circuits containing arbitrary single-qubit rotations and CNOT gates to patterns. A calculus for 1WQC was presented in [10]. In that paper, the optimization techniques, standardization, signal shifting and Pauli simplifications were presented. In [18], an approach for parallelizing quantum circuits was proposed. This approach takes a circuit solely consisting of CZ and J gates and produces the corresponding pattern after performing the mentioned optimizations. Then it translates the optimized 1WQC patterns back to quantum circuits to parallelize the initial quantum circuits. This algorithm was modified in [11] by introducing a set of rewrite rules to remove the qubits added during the transformation. It leads to a lower depth when an optimized pattern is translated back to a quantum circuit. Moreover, a new theoretical link is shown between maximally delayed generalized flow (the gflow with the minimal depth) and signal shifting. In [19], by modifying the approach in [18], an automatic method was presented to translate quantum circuits consisting of CNOT and any single-qubit gates to optimized 1WQC patterns.

After flow was introduced in [8] as a sufficient condition to implement a deterministic pattern, in [16], an $O(n^{2})$ algorithm was proposed to find an optimal flow (flow of minimal depth) in geometries with $n$ vertices. In [20], an algorithm of order $O(k^{2}n)$ has been described to produce a flow in geometries with $n$ vertices and $k$ output vertices. In [9], a weaker version of flow called generalized flow (gflow) has been introduced to be a sufficient and necessary condition for determinism. In [16] a polynomial time algorithm which finds an optimal gflow of an input geometry with $n$ vertices running with $O(n^{4})$ has been proposed.

IV. Proposed Approach

In this section, the proposed approach is explained which takes an arbitrary geometry with flow or gflow as an input and produces an optimized pattern as an output without using rewriting rules. Before starting the main algorithm, we perform a preprocessing phase which determines whether the input geometry has the flow or gflow condition. If the input geometry has flow, it is considered as a geometry with flow. Otherwise, it is dealt with under the case of geometries with gflow (as gflow is a weaker version of flow). The proposed approach slightly differs for geometries with flow or gflow.

The optimized patten is obtained by considering the interactions between the qubits of the underlying input geometry and their neighbors. It obtains the $XList$ and $ZList$ (the lists that consist of all qubits from which a qubit receives an $X$ -correction and a $Z$ -correction respectively) for all qubits in the standard pattern after signal shifting and Pauli simplification. This new method can also calculate the maximally delayed gflow order for the input geometry with flow.

The proposed approach uses a graph structure to represent geometries in which each vertex shows a qubit and each edge represents an entanglement operation between two qubits. Moreover, the input and output qubits are determined in sets $I$ and $O$ , respectively. In this structure, a qubit is an object and has the attributes as shown in Table 1.

QList which is filled according to $\prec_{f}$ obtained by the optimal flow [16] or $\prec_{g}$ obtained by the gflow order over the input geometry consists of all qubits in it. The qubits are arranged in different levels with respect to their orders in the optimal flow or the gflow order and output qubits are put at the end of this list. XDependencyList and ZDependencyList are two lists that consist of qubits that can be potentially put in $XList$ and $ZList$ of the qubit at hand, $q$ , respectively. The qubits in these two lists are added to the final $XList$ and $ZList$ lists of the qubit $q$ if their Odd attribute is TRUE. The main method includes four algorithms as explained in the following.

Algorithm FindNeighborZQubit (QList)

This algorithm finds $Z$ -dependency neighborhood [11] of all qubits in the input geometry. $Z$ -dependency neighborhood is defined as: $N_{Z}(j)=\left\{k\in O^{C}|f(k)\in N(j)\setminus{f(j)}\right\}$ . It contains the set of qubits from which $j$ receives a $Z$ -correction. This definition has only been used for geometryies with flow, hence we extend it for geometries with $gflow$ . New definition of $Z$ - $dependency$ neighborhood set which is used for all geometries with $flow$ or $gflow$ is defined as: $N_{Z}(j)$ = $\left\{k\in O^{C}|fg(k)\in N(j)\,where\,k\neq j\right\}$ . The importance of this new definition is explained in the following sections, when we calculate XDependencyList and ZDependencyList to determine $XList$ and $ZList$ for each qubit. Algorithm 1 shows the pseudo code to create this set.

Algorithm FindXList( $q$ )

This algorithm finds all qubits from which $q$ receives an $X$ -correction. The input to this algorithm is the qubit $q$ and its output is XList(q). This algorithm can also calculate the level of qubit $q$ in maximally delayed generalised flow order for the input geometry with optimal flow order. Algorithm 2 presents its pseudocode.

According to the input geometry condition and by using the concept of flow [8] or gflow [9], at first, for each qubit in $fg^{-1}(q)$ set, one qubit is selected and its Odd property is complemented. Then, it is added to XDependencyList. After that, for each qubit belonging to the ZList of the selected qubit, its Odd property is complemented. Moreover, it is added to XDependencyList if it has not been previously included.

After these steps, if there is a qubit in XDependencyList whose Odd property is TRUE, then it is added to q.Xlist. This means that the number of $X$ -corrections from the mentioned qubit to the qubit $q$ is odd. To determine the level of qubit $q$ in maximally delayed generalised flow order in the input geometry with flow order, if $q$ is an input qubit, then q.Level is set to zero. Otherwise, the maximum qubit level which belongs to the XDependencyList is first calculated and then q.Level is set to the maximum value of level plus one. After that, all variables are initialized to their default values and XDependencyList is cleared. Finally, according to the Pauli simplification and Pauli correction commands ii, if q.angle is equal to $\frac{\pi}{2}$ or 0, then q.Xlist is cleared.

Algorithm FindZList( $q$ )

This algorithm takes the qubit $q$ as an input and its output is the list of qubits for which $Z$ -correction to $q$ exists. This list is shown by ZList(q). By applying the principle of signal shifting [10], it must check the qubits in q.NeighborZList. When the selected qubit angle $q.angle$ is equal to $\frac{\pi}{2}$ , it must also check the qubits in $fg^{-1}(q))$ in addition to q.NeighborZList according to the principle of Pauli simplification [10] converting $X$ -correction command to $Z$ -correction one. The rest of this algorithm is fundamentally similar to FindXList(q).

The pseudocode of this procedure is shown in Algorithm 3.

Algorithm OptimizitionGeometry(QList)

This algorithm produces the optimized pattern for a given arbitrary geometry with flow or gflow. In this algorithm, initially, ZList and XList are calculated for all qubits in QList. The $XList$ as well as measurement commands are printed for all qubits. The $ZList$ s are only printed for the output qubits as the $Z$ -corrections on the non-output qubits are moved to the end of the pattern by applying signal shifting. Its pseudocode is shown in Algorithm 4.

Fig. 1 summarizes the proposed approach. Detection of flow or gflow conditions for input geometry is done in the preprocessing phase which is not included in the pseudo code.

In the following, we will run this approach on two arbitrary geometries to optimize them. The first geometry has the optimal flow order and the second one has gflow.

Example 1 In the first example, we apply the proposed approach to a sample geometry with optimal flow order is shown in Fig. 2. The partial order of this optimal flow is given below.

$1\prec_{f}2,4\prec_{f}5,7\prec_{f}8\prec_{f}9$

The step by step results of applying the proposed method are shown in Table 2.

The output pattern is printed as follows.

[TABLE]

Example 2

In the second example, the new approach is run on a sample geometry with gflow [21] and shown as Fig. 3. The partial order of this gflow is given below.

$1\prec 3,5$

Algorithm 4 is applied to this geometry with gflow to optimize it. The results are given in Table 3.

The output pattern is printed as follows.

[TABLE]

V. Proof and analysis

In this section, the correctness of the proposed algorithm is proved. Moreover, its time complexity is analysed.

i. Validation of the proposed algorithm

Proposition 1. The proposed approach produces the optimized pattern on an arbitrary geometry with flow or gflow.

Proof: The proof is done by induction.

a) Base case: The empty pattern, i.e., the pattern with no commands, is optimized.

Proof (a): The base case is trivially correct.

b) Inductive step: Assume that the proposed algorithm generates the optimized pattern for the qubits in the level $k$ of the optimal flow order [16] or of the gflow order, $k\geq 1$ . Now, it is proved that it produces the optimized pattern for the qubits in the level $k+1$ .

Proof (b):

It is proved that the proposed approach can generate $XList$ and $ZList$ of qubits in the level $k+1$ properly. Consider a qubit $q$ in the level $k+1$ . In order to compute the XList of $q$ , the qubits that can potentially belong to this list, i.e., XDependencyList should be considered. By the concept of flow [8] or gflow [9], depending on the input geometry, the $X$ -correction for $q$ is $p=f^{-1}(q)$ or $p=g^{-1}(q)$ respectively and should be included in XDependencyList. By the principal of signal shifting [10], the qubits in the ZList of $p$ should also be added to this list. Then, the qubits in the XDependencyList of $q$ should be included in the XList of this qubit if an odd number of them exists. These steps are performed by FindXList(q). As mentioned in [11], there is a new connection between maximally delayed gflow and signal shifting. Therefore this function can also calculate maximally delayed gflow order for the qubits of an arbitrary geometry with flow order. According to the Pauli simplification commands, there is no XList set for a qubit with the angle is equal to $\frac{\pi}{2}$ or 0. Therefore this set is cleared for it at the end of this algorithm.

In order to compute the ZList of $q$ , the qubits that can potentially belong to this list, i.e., ZDependencyList should be created with respect to $q.angle$ . By using the definition of NeighborZ [11], if $q.angle$ is not equal to $\frac{\pi}{2}$ , the NeighborZ of these qubits and their ZList qubits are the ones that belong to this list where $ZList$ qubits should be parts of a pattern which are optimized in the level $k$ or less than it. If this angle is equal to $\frac{\pi}{2}$ , according to the Pauli simplification commands, the set $fg^{-1}(q)$ and their $ZList$ are included in addition to its NeighborZ and their ZList qubits to calculate q.ZList. According to this technique, the X-correction is converted to Z-correction for a qubit with the angle equal to $\frac{\pi}{2}$ and then the Z-correction is deleted by signal shifting technique. This is true by the inductive condition. The qubits in ZDependencyList should be added to the ZList of $q$ if an odd number of this exists. These steps are done by FindZList(q).

As mentioned in [11], there is a structural link between signal shifting optimisation and maximally delayed gflow in geometries with flow. It means when the input and output sizes of the geometries with flow are equal, signal shifted flow is indeed the maximally delayed gflow, or simply optimal gflow. In the proposed approach, a new procedure is presented that performs signal shifting optimization accurately, so according to the previous theorem in [11], the new method can calculate maximally delayed gflow for geometries with flow correctly.

ii. Time complexity analysis

The time complexity of the algorithms that are used in the proposed method to perform optimization techniques are calculated in the following. The time complexity of each function is calculated for both geometries with flow or gflow separately.

•

Preprocessing phase:

An $O(|V|^{2})$ -algorithm [16] is performed to check whether the input geometry has a flow. Otherwise, the input geometry is considered with gflow.

•

FindNeighborZQubit(QList):

The time complexity of this function for geometries with flow is similar to that of the geometries with gflow. There are two nested loops in this algorithm. The number of iterations in the outer loop is equal to the number of vertices in the geometry, i.e., $O(|V|)$ . The inner loop repeats as many times as the number of neighbors of a qubit which is at most equal to $\Delta(G)$ where $\Delta(G)$ is the largest degree in the graph. Therefore, the total time complexity is equal to:

$O(|V|)*O(\Delta(G))=O(|V|\Delta(G))$

•

FindXList (q):

First, the time complexity is analyzed for geometries with flow and then it is explained for the ones with gflow.

The operations in this algorithm are as follows:

FindXlist(q) consists of two nested loops. The outer loop executes ones because there is one qubit belonging to $fg^{-1}(q)$ . The reverse flow of each qubit consists of one qubit. The inner loop which is iterated by the number of qubits in ZDependency(q). This list consists of all qubits in the geometry in the worst case. Hence, the time complexity of these nested loops is $O(|V|)$ .

There is another loop in this algorithm which has the runtime of $O(|V|)$ . The total time complexity is as shown in the following:

$O(|V|)+O(|V|)=O(|V|)$

For the geometries with gflow, the number of qubits in $fg^{-1}(q)$ are equal to all qubits belonging to the input geometry in the worst case. Therefore the outer loop takes $O(V)$ time . The inner loop runs in $O(|V|)$ as mentioned for the input geometry with flow. Finally the total runtime is equal to $O(|V|^{2})$ .

There is another loop in this method which has the runtime of $O(V)$ . The total time complexity is as the following:

$O(V^{2})+O(V)=O(V^{2})$

•

FindZlist (q):

First this function is analyzed for geometries with flow. There are two nested loops for the qubit with angle equal to $\frac{\pi}{2}$ . The outer and inner loops are performed in $O(\Delta(G)+1)$ and $O(|V|)$ , respectively. As a result, the total time complexity is $O(\Delta(G)|V|)$ .

When the qubit angle is not equal to $\frac{\pi}{2}$ , the outer loop has the runtime of $O(\Delta(G))$ and the inner one is performed in $O(|V|)$ . Therefore, the total time complexity is $O(\Delta(G)|V|)$ . For calculating the ZList of output qubits, there is a loop which runs as many times as the number of qubits in ZDependencyList and is done in $O(|V|)$ in the worst case. Therefore, the total runtime is as follows:

$O(\Delta(G)|V|)+O(\Delta(G)|V|)+O(V)=O(\Delta(G)|V|)$

For geometries with gflow, each of the outer and the inner loops are performed in $O(|V|)$ . Therefore, the total time complexity is $O(|V|^{2}))$ .

The rest for this case is the same as the previous one and takes $O(V)$ time. The total time is as follows:

$O(|V|^{2})+O(|V|^{2})+O(V)=O(|V|^{2})$

•

OptimizitionGeometry(QList):

Total time complexity of this procedure for geometries with flow is as follows:

$O(|V|\Delta(G)|V|)=O(|V|^{2}\Delta(G))$

For input graph with gflow, total time complexity of this procedure is shown as follows:

$O(|V||V|^{2})=O(|V|^{3})$

The time complexity of the proposed approach is compared to the previous studies in Table 5.

As this table shows, the proposed approach for optimizing patterns has a lower time complexity than [12]. This method can be applied to valid patterns with flow or gflow. In [12] the time complexity is only calculated for performing standardization, so we complete this procedure to find the time complexity for signal shifting and pauli simplification algorithms as well. As mentioned in [12], after applying the standardization technique, we have at most $O(|V|^{2})$ entanglement commands at the beginning, $O(|V|)$ measurement commands and finally $O(|V|^{3})$ correction commands in the standard pattern. The real complexity of the signal shifting algorithm comes from creating at most $O(|V|)$ signals (Equation 9), each of which has to be commuted by at most $O(|V|^{3})$ measurement and correction commands. Therefore, this algorithm has $O(|V|^{4})$ time complexity in the worst case. For Pauli simplification, in the worst case, for each measurement command with the angle ( $\frac{\pi}{2}$ ) according to Equation 8, there are $O(|V|)$ $Z$ -corrections. Then we can remove them through signal shifting optimization. Hence, the algorithm has a worst case complexity of $O(|V|^{4})$ time. To sum up, after performing optimization techniques, the overall time complexity is computed as $O(|V|^{5})$ .

If the proposed approach is run on geometries with flow, it takes $O(|V|^{2}\Delta(G))$ . $\Delta(G)$ in a graph is at most of $O(|V|)$ where the worst case is not typical in geometries with flow. Therefore, in the worst case, the proposed approach leads to $O(|V|^{3})$ for geometries with flow. Finally, the proposed approach can simplify an arbitrary geometry with flow or gflow with a lower time complexity than the previous study [12].

One point that needs to be mentioned is that the proposed method, when applied to geometries with flow, can also find the maximally delayed gflow. According to Fig. 1, if an input arbitrary geometry has the optimal flow order, then we can also find the maximally delayed gflow for it. The time complexity for the first step is $O(|V|^{2})$ [16] and for the second one is $O(|V|^{2}\Delta(G))$ . Therefore, for the whole procedure, it takes $O(|V|^{2}\Delta(G))$ which has a lower time complexity than [16] working on arbitrary geometries. As mentioned before in the worst case it takes $O(|V|^{3})$ . This is the same as the time complexity in [11] which can only be applied to geometries with flow to find the maximally delayed gflow. Although the time complexity is not improved in this case, the proposed approach also optimizes the input geometry with flow or gflow as well as finding the maximally delayed gflow for geometries with flow.

It should be noted that the class of patterns with flow is an interesting class of patterns, as it is universal for quantum computing and more importantly, the translation from circuits to the patterns in [18] always leads to a pattern with flow [18].

VI. Experimental Results

The proposed algorithm was implemented in C++ on a work station with 4GB RAM and Core 5 Due 2.3GHz CPU. Several examples from the literature, whose measurement patterns in the optimized form have been manually extracted, were used and the same results were obtained. Some examples of the optimized patterns extracted by the proposed approach are shown in Table 4 where $N$ shows the number of qubits in the input geometry.

VII. Conclusion

In this paper, an algorithm was proposed which takes a geometry with flow or gflow as an input and all of the optimization techniques are applied to it simultaneously without using rewrite rules. These techniques are performed only by checking the neighbors of each vertex in the input geometry. The correctness of the proposed approach was proved and its time complexity analysis showed that it can optimize patterns with flow or gflow with a lower time complexity than the previous approach in [12].

We could also find the order of non-output qubits in the maximally delayed gflow order for geometries with flow by improving the time complexity compared to the existing methods in [16]. Finding a new connection between two optimal gflow order of a given geometry and signal shifting remains as an interesting open question. If this becomes true then we will conclude that the proposed approach can also calculate an optimal gflow order for any geometry with a time complexity lower than previous approaches.

Bibliography21

The reference list from the paper itself. Each links out to its DOI / PubMed record.

1[1] M. Eslamy, M. Houshmand, M. Saheb Zamani, and M. Sedighi. Geometry-based signal shifting of one-way quantum computation measurement patterns. In 24th Iranian Conference on Electrical Engineering (ICEE 2016) , 2016.
2[2] P. W. Shor. Polynomial-time algorithms for prime factorization and discrete logarithms on a quantum computer. SIAM Journal on Computing , 26:1484–1509, 1997.
3[3] L. K. Grover. A fast quantum mechanical algorithm for database search. ACM Symposium on Theory of Computing , pages 212–219, 1996.
4[4] D. Browne and H. J. Briegel. One-way quantum computation - a tutorial introduction. 2006. http://arxiv.org/abs/quant-ph/0603226.
5[5] R. Raussendorf and H. J. Briegel. A one-way quantum computer. Physical Review Letters , 86(22):5188–5191, May 2001.
6[6] P. Walther, K. J. Resch, T. Rudolph, and E. Schenck. Experimental one-way quantum computing. Nature , 434:169–176, 2005.
7[7] H. J. Briegel, D. E. Browne, W. D¨ur, R. Raussendorf, and M. Van den Nest. Measurement-based quantum computation. Nature Physics .
8[8] V. Danos and E. Kashefi. Determinism in the one-way model. Phys. Rev. A , 74(5):052310, 2006.

TL;DR

Contribution

Findings

Abstract

Peer Reviews

Videos

Geometry-Based Optimization of One-Way Quantum Computation Measurement Patterns††thanks: This paper is an extended version of the paper presented at ICEE 2016 [1].

I. Introduction

II. Preliminaries

i. Quantum Circuit Model

ii. Description of 1WQC model

ii.1 Optimization in 1WQC

Standardization

Pauli Simplification

Signal Shifting

iii. Graph Representation of 1WQC Patterns

iv. Determinism condition in 1WQC

Definition 1**.**

Definition 2**.**

III. Related work

IV. Proposed Approach

V. Proof and analysis

i. Validation of the proposed algorithm

ii. Time complexity analysis

VI. Experimental Results

VII. Conclusion

Definition 1.

Definition 2.