An upper bound on the time required to implement unitary operations

TL;DR

This paper establishes an upper limit on the time required to implement any unitary operation in a quantum system with controllable Hamiltonian elements, depending on system size and coupling strength.

Contribution

It derives a new upper bound on the implementation time for unitaries in quantum systems with control fields, considering system size and coupling constants.

Findings

Derived an explicit upper bound on implementation time.

Numerically investigated the tightness of the bound.

Analyzed a specific energy level system with tight-binding interactions.

Abstract

We derive an upper bound for the time needed to implement a generic unitary transformation in a $d$ dimensional quantum system using $d$ control fields. We show that given the ability to control the diagonal elements of the Hamiltonian, which allows for implementing any unitary transformation under the premise of controllability, the time $T$ needed is upper bounded by $T\leq \frac{\pi d^{2}(d-1)}{2g_{\text{min}}}$ where $g_{\text{min}}$ is the smallest coupling constant present in the system. We study the tightness of the bound by numerically investigating randomly generated systems, with specific focus on a system consisting of $d$ energy levels that interact in a tight-binding like manner.

Equations

$$H_0=\sum _{n,m}{g}_{n,m}|n⟩⟨m|,$$

$$T\le \frac{\pi d^2(d-1)}{2g_{\text{min}}},$$

$$\frac{d}{dt}U(t)=-iH(t)U(t),$$

$$H(t)=\sum _{n\ne m}{g}_{n,m}|n⟩⟨m|+\sum _n{f}_n(t)P_n.$$

$$H_0=\sum _{n\ne m}{g}_{n,m}|n⟩⟨m|,$$

$$H_0$$

$$H_0=\sum _{n>m}|g_{n,m}|B_{n,m},$$

$${\Lambda }_{t/n}=\prod _{v\in V}{v}^{†}\exp \left(-i{H}_0\frac{t}{|V|n}\right)v,$$

$$M(\cdot )=\frac{1}{|V|}\sum _{v\in V}{v}^{†}(\cdot )v.$$

$$M_j(H_0)=H_0-(P_j{H}_0+H_0{P}_j),$$

$$S_{n,m}(\alpha )=\exp (-i\alpha B_{n,m}),$$

$$t_{n,m}\le \frac{|\alpha |+\pi (d-2)}{g_{\text{min}}}.$$

$$t_{1,N}$$

$$=\frac{|\alpha |}{|g_{N-1,N}|}+\pi \sum _{j=1}^{N-2}\frac{1}{|g_{j,j+1}|}.$$

$$H_0=\sum _{\begin{array}{c}i\in V,\\ \alpha \in \{x,y,z\}\end{array}}{\omega }_{\alpha }^{(i)}{\sigma }_{\alpha }^{(i)}+\sum _{\begin{array}{c}(i,j)\in E,\\ \alpha ,\beta \in \{x,y,z\}\end{array}}{g}_{\alpha ,\beta }^{(i,j)}{\sigma }_{\alpha }^{(i)}{\sigma }_{\beta }^{(j)},$$

$$t_{i,j}^{\text{cnot}}\le \frac{\pi }{g_{\text{min}}}\left(\frac{4\text{dist}(i,j)-3}{4}\right).$$

$$U=V_1{V}_2\dots V_k,$$

$$T\le \frac{\pi d^2(d-1)}{2g_{min}}.$$

$$T(U_g)\le \frac{\pi (4n-7)}{4g_{\text{min}}}{N}_{\text{CNOT}}(U_g).$$

$$H_0=J\sum _{j=1}^{d-1}(|j⟩⟨j+1|+|j+1⟩⟨j|),$$

$$t_{1,d}^{\text{swap}}\le \frac{\pi }{2}(2d-3)\sqrt{2(d-1)}.$$

$$\sqrt{2}(d-1)\le t_{1,d}^{\text{swap}}.$$

$$t_{n,m}\le \pi \left(d-\frac{3}{2}\right),$$

$$T\le \frac{\pi }{2}{d}^2(d-1).$$

$$H(t)=J\sum _{j=1}^{d-1}\left(|j⟩⟨j+1|+|j+1⟩⟨j|\right)+\sum _{j=1}^d{f}_j(t)|j⟩⟨j|,$$

$$U_g=\exp \left(-i\frac{\pi }{2}\left(|1⟩⟨d|+|d⟩⟨1|\right)\right),$$

$$\sqrt{2}(d-1)\le T.$$

$$H(t)=H_0+\sum _{k=1}^n{f}_k(t)H_k,$$

$$\underset{V\in {\bigcap }_k\text{Stab}(i{H}_k)}{\max }\frac{\Vert [U_g,V]\Vert }{\Vert [H_0,V]\Vert }\le T,$$

$$\frac{\Vert [U_g,V]{\Vert }^2}{\Vert [H_0,V]{\Vert }^2}=\frac{1}{J^2}\cdot \frac{1-\cos ({\theta }_1-{\theta }_d)}{d-1-(\cos ({\theta }_1-{\theta }_2)+\dots +\cos ({\theta }_d-{\theta }_{d-1}))}.$$

$$S(x_1,\cdots ,x_{d-1})\equiv \frac{1-\cos ({\sum }_{i=1}^{d-1}{x}_i)}{1-\frac{1}{d-1}{\sum }_{i=1}^{d-1}\cos (x_i)},$$

Full text

1. Introduction

Controlling quantum systems through external classical fields on a time scale that is below the typical decoherence timescale is crucial for employing quantum mechanical features for future quantum devices. In particular, the length $T$ of the classical pulses, sometimes referred to as the minimum gate time, used to implement a target unitary transformation $U_{g}$ that allows to carry out a specific quantum information task should scale in a reasonable manner with the underlying Hilbert space dimension $d$. While lower bounds on $T$, known as quantum speed limits (for a detailed review we refer to [1], and works cited therein), give inherent limits on how fast unitary operations (states) can be implemented (prepared) through shaped classical fields, such lower bounds do not yield much insights on how much time is at most needed to achieve this task. Thus, an upper bound on $T$ is highly desirable. Such an upper bound should depend on the target unitary transformation, the Hamiltonian describing the quantum system under consideration, the number of controls available to implement the target transformation, and possible constraints, such as energy and bandwidth in the control fields. Clearly, if every matrix element of the Hamiltonian describing a $d$ dimensional quantum system can be controlled instantaneously and arbitrarily, every unitary transformation in the unitary group $\text{U}(d)$ can be implemented instantaneously through $d^{2}$ (unconstrained) classical fields controlling each matrix element. But what if we have only restricted access to the system under consideration? How many controls, and which controls, then allow for implementing every $U_{g}\in\text{U}(d)$ in a time at most $\mathcal{O}(\text{poly}(d))$? Here we show that if the diagonal elements of the Hamiltonian describing a $d$ dimensional quantum system can be generically controlled through classical fields, and if the system is controllable with these fields, the time to implement every unitary operations scales at most as $\mathcal{O}(d^{3})$. We note, however, that for qubit systems consisting of $n$ qubits (i.e., $d=2^{n}$) our upper bound scales exponentially in $n$. This should not be surprising, as the time $T$ to implement a generic unitary transformation scales exponentially in the number of qubits, which can be traced back to the fact that most unitary operations cannot be implemented efficiently, i.e., in a time that scales polynomially in the number of qubits [2]. For further reading regarding time-optimal control and quantum computing we refer to the seminal works [3, 4], while an upper bound on $T$ for qubit systems was developed in [5].

While in this work we mostly focus on networks determined by a set of basis states $\{|{n}\rangle\}$ describing a $d$ dimensional quantum system, we also consider the generalization to networks consisting of qubits. Here the associated graph is not determined by a coupling between two kets, but instead by qubits coupled through an arbitrary two-body interaction term. Based on the number of CNOT gates needed to create a specific unitary transformation [6, 7, 8], we thus also provide an upper bound on $T$ to implement a given $U_{g}$ on a $n$-qubit network using $2n$ local controls.

One way to obtain an upper bound on $T$ is to find a sequence of gates that corresponds to some application of the controls that allows for creating a generic unitary transformation. Upper bounding the corresponding time needed to implement the sequence then yields an upper bound for implementing a generic unitary transformation. This strategy has, for instance, been successfully applied for a $n$-qubit network to characterize the set of gates that can be implemented in a time at most polynomial in the number of qubits using $2n$ local controls [5]. Here we build up on the concepts developed in [5] and show for a $d$ dimensional quantum system described by a Hamiltonian

[TABLE]

that if the associated graph is connected, the set of controls $\mathcal{C}=\{|n\rangle\langle n|\}_{n=1}^{d}$ allows for implementing every $U_{g}\in\text{U}(d)$ in a time which is upper bounded by

[TABLE]

where $g_{\text{min}}=\min_{n\neq m}\{\lvert g_{n,m}\rvert\}$. Thus, fixing a basis to represent the Hamiltonian $H_{0}$ of the quantum system under consideration and controlling the diagonal elements of $H_{0}$ allows for implementing every unitary transformation in a time that is upper bounded by (2), provided the system is fully controllable through the controls used. In fact we show that if the graph associated to (1) is connected, the controls $\mathcal{C}$ generate a fully controllable system and the time $T$ to implement every unitary operation is upper bounded by (2).

The work is organized as follows. We begin in section 2.1 by representing a quantum system described by the Hamiltonian (1) as a weighted and undirected graph. We show in section 2.2 that we can reduce such a graph into a single-edge without a time cost using dynamical decoupling. In section 3.1 we present our first result. Assuming the graph is connected, by propagating single-edge evolutions across a path connecting any pair of vertices, any interaction between a pair of vertices can be created in a time linear in $d$. In section 3.2 we derive our main result (2). The obtained results rely on the assumption that the control fields corresponding to the controls $\mathcal{C}$ are unconstrained, so that every unitary operation $v=\exp(-i\alpha C)$ with $C\in\mathcal{C}$ can be implemented instantaneously. In section 4 we numerically study the tightness of the derived upper bound by considering examples, followed by some econcluding remarks in section 5.

2. Preliminaries

We consider a $d$ dimensional quantum control system evolving on the unitary group $\text{U}(d)$ described by the Schrödinger equation for the time evolution operator

[TABLE]

where we set $\hbar=1$ and the time dependent Hamiltonian is given by

[TABLE]

We refer to

[TABLE]

as the drift Hamiltonian and the set of controls $\mathcal{C}=\{P_{n}\}_{n=1}^{d}$ is given by orthonormal projections $P_{n}=|n\rangle\langle n|$, where $f_{n}(t)$ are the corresponding control fields, which are throughout this work assumed to be unconstrained. Typically, the goal in quantum control is to shape the control fields in such a way that for some time $T$ the solution $U(T)$ to $\eqref{eq:controlsystem}$ is given by a desired unitary transformation $U_{g}$. We call the control system fully controllable if every $U_{g}\in\text{U}(d)$ can be implemented through shaping the control fields. It is well known that the system is fully controllable iff the dynamical Lie algebra [9, 10] generated by the drift Hamiltonian and the set of controls spans the full space, i.e., the algebra $\mathfrak{u}(d)$ consisting of $d\times d$ skew hermitian matrices. However, how much time $T$ does it take to implement a generic unitary transformation? In order to derive the upper bound (2), we start by explaining how $H_{0}$ can be represented as a weighted, undirected graph, and how the controls $\mathcal{C}$ can be used to instantaneously remove vertices from the graph.

2.1. Quantum control systems and graphs

We first note that we can rewrite the drift Hamiltonian as

[TABLE]

where the relative phases $\phi_{n,m}$ can be removed by applying the unitary transformations $v=\exp(-i\alpha C)$ with $C\in\mathcal{C}$, which can be implemented instantaneously assuming that the control fields $f_{n}(t)$ are unconstrained. We remark here that this assumption is a reasonable approximation in the case where the strength of the control fields can be made much larger than the typical energy scales of the systems being considered. Thus, in the case of unconstrained control fields removing the phases does not take time. Using the controls we can therefore map $H_{0}$ given by (5) into the drift Hamiltonian

[TABLE]

without a time cost, where we defined $B_{n,m}=|n\rangle\langle m|+|m\rangle\langle n|$. In order to derive the bound (2) we can hence equivalently work with the drift Hamiltonian given by (7).

The operators $B_{n,m}$ describe interactions between the states $|{n}\rangle$ and $|{m}\rangle$, whereas $\lvert g_{n,m}\rvert$ is the corresponding interaction strength. We can visualize these interactions through a weighted and undirected graph $G(V,E)$. The set of vertices $V$ correspond to the basis states $\{|{n}\rangle\}$ spanning the Hilbert space of the quantum system and are labeled by $n$, the set of edges $E$ labeled by $(n,m)$ describe interactions between vertices $n$ and $m$, and the interaction strength $\lvert g_{n,m}\rvert$ corresponds to the weights. Later on we will also consider qubit graphs in which $V$ and $E$ represent qubits and two-body interactions, respectively.

For a drift Hamiltonian $H_{0}$ of the form (7) we denote the corresponding graph by $G_{0}(V_{0},E_{0})$. In order to upper bound the time to implement a generic target unitary transformation it is useful to introduce the complete graph $G_{K}(V_{K},E_{K})$ which consists of $|V_{K}|=d$ vertices and $|E_{K}|=\frac{d(d-1)}{2}$ edges.

We proceed by first showing how to remove edges from $G_{0}$ instantaneously, followed by upper bounding the time to connect a generic pair of vertices, i.e., creating a generic $B_{n,m}$ with $(n,m)\in E_{K}$.

2.2. Dynamical decoupling: removing edges without a time cost

Dynamical decoupling allows for removing unwanted interactions of a Hamiltonian $H_{0}$ by rapidly applying a set of unitary transformations $V$ [11, 12] in a Suzuki-Trotter type sequence,

[TABLE]

which converges in the limit of infinitely fast operations $(n\to\infty)$ to a unitary operation $U=\exp(-iM(H_{0})t)$, where the map $M$ is given by

[TABLE]

We remark here that such maps are typically studied in the context of Hamiltonian simulation (see e.g.,[13]), dynamical decoupling (see e.g., [11, 12, 14]), and unital quantum channels with equal weights [2]. We further note that a concatenation $M_{1}(M_{2}(H_{0}))=\tilde{M}(H_{0})$ yields again a map of the form (9), so that $\tilde{M}$ can be obtained by a sequence of the form (8).

Now, taking $V_{j}=\{\mathds{1},v_{j}\}$ where $v_{j}=\exp(-i\pi P_{j})=\mathds{1}-2P_{j}$ we have for $H_{0}$ given by (7),

[TABLE]

so that $M_{j}$ maps the graph $G_{0}$ into a subgraph in which the vertex $j$ is removed. Iteratively removing vertices by constructing concatenations of different $M_{j}$’s therefore allows to map $G_{0}$ into a subgraph containing only a single edge. We conclude that there always exists a set of unitary transformations generated by the controls $\mathcal{C}$ that allows for mapping the natural evolution given by $H_{0}$ into an evolution generated by $|g_{n,m}|B_{n,m}$ without a time cost [15]. Thus, for the control system defined by (4) any unitary operation of the form

[TABLE]

with $(n,m)\in E_{0}$ can be implemented through the controls in a time $t_{n,m}=\alpha/|g_{n,m}|$. We note that within the subspace spanned by $\{|{n}\rangle,|{m}\rangle\}$ the operation $S_{n,m}(\alpha)$ induces oscillations between the states $|{n}\rangle$ and $|{m}\rangle$, and for $\alpha=\pi/2$ the states are swapped. Adopting the terminology used in quantum information, we refer to the corresponding unitary transformation $S_{n,m}(\pi/2)$ as a SWAP gate, noting that here two basis states are swapped rather than qubit states.

3. Results

So far we have shown that unitary operations generated by interactions $B_{n,m}$ of the Hamiltonian (7) can be implemented in a time which is of the order of the inverse energy associacted with the interaction. However, how much time does it take to create interactions that are not present in $H_{0}$? In order to upper bound the time to implement a unitary operation generated by such interactions, we now show how to upper bound the time to create arbitrary interactions.

3.1. Upper bounding the time to create interactions

From now on we assume that $G_{0}$ is connected and upper bound the time to create a generic $S_{n,m}$ with $(n,m)\in E_{K}$, where $E_{K}$ is the set of edges of the complete graph $G_{K}$. We establish the following lemma.

Lemma 1**.**

Let the graph associated to the drift Hamiltonian (7) be connected and denote by $g_{\text{min}}$ the smallest edge weight. Then for the control system (3) a unitary operation $S_{n,m}(\alpha)\in\text{U}(d)$ with $(n,m)\in E_{K}$ of the form (11) can be implemented in a time $t_{n,m}$ which is upper bounded by

[TABLE]

Proof.

We relabel the vertices of $G_{0}$ so that the vertices $n$ and $m$ are labeled by $1$ and $N$ and we consider a path connecting the vertices $1$ and $N$ by passing through connected vertices $1,2,\cdots,N$, i.e., $(j,j+1)\in E_{0}$ where $j=1,\cdots N-1$. Using dynamical decoupling we can instantaneously reduce $G_{0}$ to a single edge $(1,2)$, so that the SWAP gate $S_{1,2}(\pi/2)$ can be implemented in a time $t_{1,2}=\frac{\pi}{2\lvert g_{1,2}\rvert}$. Then, iteratively reducing $G_{0}$ to edges $(j,j+1)$ up to $(N-2,N-1)$ allows for successively implementing SWAP gates on adjacent vertices, which permutes the vertices according to $12\cdots N\to 23\cdots(N-1)1N$. This takes $\tau=\frac{\pi}{2}\sum_{j=1}^{N-2}\frac{1}{\lvert g_{j,j+1}\rvert}$ amount of time. We proceed by reducing $G_{0}$ to the single edge $(N-1,N)$ and implement the operation $S_{N-1,N}(\alpha)$, which takes $t_{N-1,N}=\frac{\lvert\alpha\rvert}{\lvert g_{N-1,N}\rvert}$ amount of time. Iteratively restoring the order of the vertices by performing $(N-2)$ SWAP operations so that $S_{1,N}(\alpha)$ is effectively implemented takes time $\tau$. Thus, the gate $S_{1,N}(\alpha)$ can be implemented in a time

[TABLE]

Clearly, $N$ is upper bounded by the total number of vertices present in $G_{0}$, which is given by the dimension $d$ of the quantum system. Introducing the smallest edge weight present in $G_{0}$ as $g_{\text{min}}=\min_{(n,m)\in E_{0}}\{|g_{n,m}|\}$ we find that the time $t_{n,m}$ to implement a generic $S_{n,m}(\alpha)$ with $(n,m)\in E_{K}$ is therefore upper bounded by (12).

∎

We remark here that the sequence of SWAP operations used to obtain (3.1) is not necessarily time optimal. However, minimizing (3.1) over all paths connecting vertices $n$ and $m$ yields the tightest version of the obtained bound.

Instead of associating $G_{0}$ with coupled states described by $B_{n,m}$, we can also consider the case where $G_{0}$ describes a $n$-qubit network (i.e., here qubits represent vertices labeled by $i$ and edges labeled by $(i,j)$ are given by two body interaction terms) described by the drift Hamiltonian

[TABLE]

where $\sigma_{\alpha}^{(i)}$ denote the Pauli spin operators acting only non-trivially on the $i$th qubit, and $\omega_{\alpha}^{(i)}$ and $g_{\alpha,\beta}^{(i,j)}$ are energy splittings and coupling constants, respectively. If each qubit can be addressed with two orthogonal control fields described by the set of controls $\mathcal{C}=\{\sigma_{x}^{(i)},\sigma_{y}^{(i)}\}_{i=1}^{n}$, as shown in [5] the time $t_{i,j}^{\text{cnot}}$ to implement a CNOT gate on qubits $i$ and $j$ is upper bounded by,

[TABLE]

Here $g_{\text{min}}$ is the smallest non-zero coupling constant present in the Hamiltonian (14) and $\text{dist}(i,j)$ denotes the geodesic path distance between two qubits $i$ and $j$ given as the smallest number of edges in a path connecting the two considered qubits, noting that $\text{dist}(i,j)\leq n-1$.

3.2. Upper bounding the time to implement generic unitary operations

In order to understand how to upper bound the evolution time of an arbitrary unitary, we can decompose it into elementary interactions (11) and local controls. In general, the number of terms in such decomposition is hard to characterize [16]. For the special case of decomposing an element of $U\in\text{U}(d)$ we can however use the proof of decompositions of unitaries given in [2], which shows that

[TABLE]

where $k\leq d(d-1)/2,$ and each $V_{k}$ acts nontrivially only on two specific levels $n_{k},m_{k}$ (and is therefore isomorphic to an element of $\text{U}(2)$). By the Euler decomposition, we can furthermore decompose such an element into a gate sequence including rotations around $z$, which can be implemented through the controls $\mathcal{C}$ instantaneously, and into a rotation around $x$, which by Eq. (12) can maximally take a time of $\frac{\pi d}{g_{min}}$. We therefore obtain our final result, which we summarize in the following Theorem.

Theorem 1**.**

Let the graph associated with the drift Hamiltonian (7) be connected and denote by $g_{\text{min}}$ the smallest edge weight. Then for the control system (3) the time $T$ to implement a unitary operation $U_{g}\in\text{U}(d)$ is upper bounded by

[TABLE]

Remarkably, in contrast to the upper bound obtained in [5], the derived bound (16) is independent of the target unitary transformation $U_{g}$ as well as the accuracy of implementing $U_{g}$.

If we consider again a $n$-qubit network described by the drift Hamiltonian (14) and denote by $N_{\text{CNOT}}(U_{g})$ the number of CNOT gates needed to create a specific gate $U_{g}\in\text{SU}(2^{n})$ by locally controlling each qubit, according to (15) the time $T(U_{g})$ needed to create $U_{g}$ is then upper bounded by

[TABLE]

However, note that for creating every $U_{g}\in\text{SU}(2^{n})$, the number of CNOT gates needed must scale exponentially in $n$, whereas the prefactors have been successively improved in the last decade [6, 7, 8].

4. Tightness of the Bounds

In order to analyze the tightness of the obtained bounds, we compare the bounds (12) and (16) to previously derived lower bounds [17], as well as to minimum gate times obtained from numerical gate optimization using the GRAPE algorithm [18], which is included in the Python package QuTip [19]. Similar to the method utilized in [17], a population binary search algorithm is run over $T$ until the gate error is smaller than $10^{-4}$.

4.1. d-level System

We first consider a quantum system consisting of $d$ energy levels interacting in a tight-binding like manner described by the drift Hamiltonian

[TABLE]

where $J$ is the coupling strength chosen to be $J=1/\sqrt{2(d-1)}$ so that $\|H_{0}\|=1$ with $\|\cdot\|$ being the Hilbert Schmidt norm. We assume that the energy levels $|{j}\rangle$ can be controlled arbitrarily so that the set of controls is given by $\mathcal{C}=\{|{j}\rangle\langle{j}|\}_{j=1}^{d}$. The goal is to implement a SWAP operation (i.e., $U_{g}=S_{1,d}(\pi/2)$ ) between the first and the $d$th level. According to Lemma (1), the time $t_{1,d}^{\text{swap}}$ needed to implement $U_{g}$ is upper bounded by

[TABLE]

Based on the results in [17] with further details found in Appendix (A) we can also lower bound $t_{1,d}^{\text{swap}}$ by

[TABLE]

In figure 1 we plot the upper bound (black curve) and the lower bound (blue curve), as well as the minimum time $T$ needed to implement the SWAP operation $S_{1,d}(\pi/2)$ obtained from numerical gate optimization using GRAPE (green curve) as a function of the number of levels $d$.

First we observe that the time obtained from numerical optimization lies between the upper and lower bounds, as expected. Furthermore, due to the fact that the upper bound in this system scales as $d^{3/2}$ while the lower bound scales as $d$, in terms of assessing the tightness of the bound with regard to scaling, the scaling of the upper bound deviates from the true scaling by at most $d^{1/2}$, which is sub-linear.

4.2. Random graphs

We proceed by considering random drift Hamiltonians that correspond to random connected graphs. Throughout this section the couplings $|g_{n,m}|$ are chosen to be uniformly random in the interval $[1,2]$ so that $g_{\text{min}}=1$ and we study the validity of the bounds (12) and (16) for quantum systems of dimension $d\in[2,6]$, noting that for a fixed $d\in[2,6]$ we have $\{1,2,6,21,112\}$ distinct connected graph.

4.2.1. Single edge operations

We begin by studying the tightness of the bound (12) by considering random single edge operations $S_{n,m}(\alpha)$ by picking $\alpha$ uniformly random in $[-\frac{\pi}{2},\frac{\pi}{2}]$ and 10 random edges amongst all $\binom{d}{2}$ of the complete graph. According to (12) for $g_{\text{min}}=1$ the time $t_{n,m}$ to implement such a random $S_{n,m}$ is then upper bounded by

[TABLE]

which is shown as a function of $d$ (black curve) in figure 2. The green and the orange curves correspond to the times to implement $S_{n,m}$ obtained from numerical gate optimization, where we plotted the average (green) taken over 10 randomly chosen $S_{n,m}$ and the number of different distinct connected graphs for $d\in[2,6]$ (i.e., the average was taken over $\{10,20,60,20,1120\}$ different runs), whereas the orange curve shows the maximum value.

From figure 2 we see that the upper bound is indeed above the maximum amongst random GRAPE runs. As expected, while the average over random single-edge operations tends to be lower than the upper bound, the maximum remains relatively close to the bound (21). Remarkably, all three data sets are linear in $d$, showing that the upper bound captures the scaling of the minimum time reasonably well.

4.2.2. General Behavior

Finally, we test the tightness of the upper bound (16) for the time $T$ to implement generic unitary operations $U_{g}\in\text{U}(d)$. For $g_{\text{min}}=1$ we have,

[TABLE]

As in the single-edge operation case, for each dimension $d$ we run the trials on every distinctly homeomorphic connected graph. We construct random unitary operations $U_{g}=\exp(-iH)$ by picking a random hermitian matrix $H$.

From the results in figure 3 we again note that the upper bound is indeed above the maximum amongst random GRAPE runs. Furthermore, we can see a ”similar” polynomial scaling for the maximum and the average times.

5. Conclusions

We have derived an upper bound for the time $T$ to implement a generic unitary transformation on a quantum system in which the diagonal element (in a given basis) can be controlled arbitrarily. This was achieved by first describing the considered system as an undirected and connected graph, followed by showing that edges of the graph can be removed without a time cost using a decoupling sequence generated by the controlled diagonal elements. Afterwards we showed in Lemma 1 that the time to implement unitary operations generated by generic edges of the complete graph scales at most linearly in the dimension of the system. Consequently, every unitary transformation can be implemented in a time at most $\mathcal{O}(d^{3})$, which was summarized in Theorem 1. It is interesting to note that the corresponding upper bound on $T$ given in (16) is independent of the target unitary transformation and the accuracy the unitary transformation is implemented.

Based on the results in [5] we also derived an upper bound for the time to create a unitary transformation in a qubit network in which each qubit can be locally controlled in terms of the number of CNOT gates needed to create the unitary transformation.

By considering examples we numerically studied the tightness of the obtained bounds and found that the bounds capture the system size dependence of $T$ remarkably well.

One of the key assumptions in this works was to assume that the control fields are unconstrained so that interactions can be removed instantaneously through a decoupling sequence. Recently, however, it was shown [20] that under some assumptions on the drift Hamiltonian even limited control fields can yield a desirable scaling of the minimum time for implementing unitary transformations. It would be interesting to combine the approaches used in [20] with the results obtained here to characterize the number and the type of controls needed to efficiently control quantum systems.

Acknowledgements – J.L. acknowledges financial support from the Program in Plasma Science and Technology at Princeton University. C. A. acknowledges funding from the DOE (DE-FG02-02ER15344) and H. R. acknowledges funding from the NSF (grant CHE-1763198).

Appendix A A Lower Bound for the d-level system

Using the results obtained in [17] we show here that for the controlled d-Level system described by

[TABLE]

where $J=\frac{1}{\sqrt{2(d-1)}}$, the time $T$ to implement a SWAP operation

[TABLE]

between the 1st and the $d$th levels is lower bounded by

[TABLE]

From [17] we have that in general for a control system of the form

[TABLE]

evolving on the unitary group $\text{U}(d)$ the time $T$ to implement a generic $U_{g}\in\text{U}(d)$ is lower bounded by

[TABLE]

valid for any unitarily invariant norm where $\text{Stab}(iH_{k})$ denotes the stabilizer of $iH_{k}$ defined as $\text{Stab}(x)=\{U\in\text{U}(d)\,|\,U^{\dagger}xU=x\}$ for some $x\in\mathfrak{u}(d)$.

For the d-level control system the intersection of the stabilizers is given by $V=\text{diag}(e^{i\theta_{1}},\ldots,e^{i\theta_{d}})$ so that using the Hilbert Schmidt norm defined as $\|A\|=\sqrt{\text{Tr}\{A^{\dagger}A\}}$ yields

[TABLE]

By defining $x_{i}\equiv\theta_{i}-\theta_{i+1}$ and

[TABLE]

the maximization in (27) is then equivalent to maximizing $S(x_{1},\cdots,x_{d-1})$ over all $x_{i}$. We claim that this quantity is maximized when $x_{i}=0$ for all $i$, which implies that $V$ is given by the identity (up to a global phase). To see this we set $x_{i}=x$ for all $i$ and take the limit,

[TABLE]

which is indeed the maximum. We therefore have $2(d-1)^{2}\leq T^{2}$, which yields the desired result (25).