QGeo: A Python Package for Calculating Geodesic Control Functions for Quantum Computing

Abstract

We present a new Python package that uses the formalism of geometric quantum complexity to numerically compute metric-dependent geometric cost and control functions associated with preparing a given unitary transformation on a quantum computer. The numerical procedure we implement is presented and discussed. Analyzed quantum circuits include: the quantum Fourier transform for up to four qubits, a random circuit with depth 100, and a circuit for analyzing the evolution of a fermionic chain with several lattice sites.

1. Introduction

Quantum computers implement unitary transformations on quantum states. In practice, this is done by decomposing a target unitary transformation into a product of elementary unitary transformations called quantum gates such that the target unitary transformation can be expressed as

$$U_{\mathrm{T}}=g_N\dots g_1.$$

(1)

Here the $g_i$s are elementary quantum gates. The set of available elementary gates depends on the specific quantum computer being used. At the hardware level, the implementation of these gates is specialized (for example implementations of elementary gates on superconducting qubits, see [1]), and most mainstream platforms for quantum computation usually have a relatively small set of elementary gates available. For example, the IBM quantum computer Torino can only implement tensor products of: the identity matrix, an X gate, an SX gate, an Rz gate, and a controlled-Z gate [2].

The number of gates required to implement a target unitary is called the gate complexity [3]. Given an elementary gate set, a quantum processor, and a target unitary transformation, the problem of finding an implementation of the target unitary that minimizes the complexity is called the quantum circuit mapping problem, which is known to be difficult [4].

An alternative measure of complexity for a unitary operator is the geodesic quantum complexity [5]. In this approach, the difficulty is associated with preparing a given unitary matrix specified by a metric on the unitary group and then looking for curves of minimal length that connect the identity operator to the target unitary matrix. These minimal length curves are called geodesics and the length of the minimal geodesic is a measure of complexity. This contrasts with other optimal control methods such as the [6] Krotov that optimizes for fidelity in the presence of noise and restricted control sets.

Concretely, the evolution of the quantum state is generated by a Hamiltonian $H\left(t\right)$. This implies a unitary evolution that is given by

$$U\left(t\right)=\mathcal{T}{\mathrm{e}}^{-i{\int }_0^{t}d{t}^{\prime }H\left(t^{\prime }\right)},$$

(2)

$\mathcal{T}$ is the time-ordering operator, which orders operators in descending time order such that operators evaluated at the latest times are on the left. In (A2) it is shown that this is a solution to the Schrödinger equation.

Onto (2) we impose the boundary conditions: $U\left(0\right)=\mathbb{I}$ and $U\left(T\right)=U_{\mathrm{T}}$. This evolution defines a path $\gamma$, in the unitary group, and the length of that path is specified by a phenomenologically motivated real-valued, symmetric, inner product defined by

$$\langle H,J\rangle ={\displaystyle \frac{1}{2^n}}\mathrm{tr}\left(H\mathcal{G}\left(J\right)\right),$$

(3)

where J is another Hamiltonian operator, n is the number of qubits and the map $\mathcal{G}$ is a super-operator defined in Equation (6) that penalizes operations that have weight greater than two. This is a highly idealized proxy for conditions where the implementation of three- or more-qubit gates is difficult. The length of the path is given by (4). The length of the path that minimizes (4) is interpreted as the complexity of the target unitary, with respect to this metric.

$$C\left[\gamma \right]={\int }_0^T{\langle H\left(t\right),H\left(t\right)\rangle }^{1/2}dt.$$

(4)

Paths on which this complexity is stationary are called geodesics. While geodesic paths may not be global minima of the complexity, the global minimum will correspond to a geodesic path. Since its inception, geodesic complexity has been applied across multiple areas, including quantum information and quantum gravity [3,7,8,9,10,11,12,13].

Part of the original motivation for formulating the notion of geodesic quantum complexity was to put lower bounds on the exact gate complexity, and an upper bound on the approximate gate complexity associated with preparing U. To our knowledge, however, it has not been applied to its original purpose of bounding gate complexities of operationally relevant unitary matrices. The purpose of this article it to apply the formalism of geometric complexity to several examples, including the quantum Fourier transform. In Section 2, the problem is defined more concretely and strategy for solving it is discussed. In Section 3, analytic approximations to the problem are discussed. The numerical implementation of the strategy and specific calculations of geodesic complexities are then presented in Section 4.

2. Approach

In this section, we discuss a numerical approach for calculating the geodesic quantum complexity of a given unitary operator, and a particular metric. Essentially, our problem consists of calculating solutions of the Schrödinger-geodesic equation, which is a coupled set of ordinary differential equations that are discussed below. Our solutions are subject to the boundary conditions $U\left(0\right)=\mathbb{I}$, and $U\left(T\right)=U_{\mathrm{T}}$. This is a boundary value problem. A standard tool for numerically solving this kind of problem is shooting [14]. However, because the dimensionality of our problem is very high, shooting is no longer effective and other approaches must be used. We approach this problem as in [15]. To keep this report self-contained we reproduce details of this method here.

The Schrödinger-geodesic equation is derived by Dowling and Nielsen [15] and is given by:

$$\begin{array}{c}\hfill \begin{array}{cc}\hfill \dot{U}\left(t\right)+{\displaystyle \frac{i}{\hslash }}H\left(t\right)U\left(t\right)& =0,\hfill \\ \hfill \dot{H}+i\mathcal{F}\left(\left[H,\mathcal{G}\left(H\right)\right]\right)& =0,\hfill \end{array}\end{array}$$

(5)

Again, subject to the boundary conditions: $U\left(0\right)=\mathbb{I}$, and $U\left(T\right)=U_{\mathrm{T}}$. The solutions of this system of equations will be curves on $SU\left(2^n\right)$. Moreover, solving this system give us the tangent vectors/Hamiltonian H that can then be used in (4) to calculate the complexity of this path. The super-operator $\mathcal{G}$, and its inverse super-operator $\mathcal{F}$ are:

$$\begin{array}{c}\hfill \mathcal{G}=\mathcal{P}+q\mathcal{Q},\\ \hfill \mathcal{F}=\mathcal{P}+q^{-1}\mathcal{Q}.\end{array}$$

(6)

$\mathcal{P}$ is the identity map on generators of one- and two-qubit operations and the zero map on generators of three- and higher-qubit operations. The map $\mathcal{Q}$ is the zero map on one and two qubit operations, and the identity map on three and higher qubit operations. The parameter q is a factor that penalizes operations corresponding to more than two qubits. This is to mimic conditions where operations spanning more than two qubits must be synthesized from two-qubit gates. It is therefore useful for studying algorithms that must be phrased in terms of gates with two or fewer gates from a geometric perspective. $q=4^n$ is a regime of computational interest, which was used in the original iteration of this algorithm because it was observed that complexities and initial values of control functions converged [15].

We set the initial condition in Equation (5) to be $H_0=V_0^i{\sigma }_i$, where $V_0^i$ are real constants, and $i{\sigma }_i$ is a basis for $\mathfrak{su}\left(2^n\right)$. The ${\sigma }_i$ are constructed from taking $n-1$ Kronecker products of the Pauli matrices in $\mathfrak{su}\left(2\right)$.

Solution Strategy

Having stated the problem, we discuss the strategy for constructing a solution to the boundary value problem specified at (5). Given a solution to the problem for a given penalty factor, q, it is possible to construct the solution for, $q+\Delta$ when $\Delta$ is small enough. This is because for this regime, the problem can be linearized, and then analyzed more easily. Using this perturbative approach, a solution to (5) can be constructed for arbitrarily large penalty factor, including the regime where $q\approx 4^n$. The base case for this procedure is the $q=1$ case. As will be discussed later, this case can be solved analytically, and therefore serves as a good starting point. Given a solution to (5) for a given q, $U_q\left(t\right)$, we model the solution at $q+\Delta$ as:

$$U_{q+\Delta }=U_q\left(t\right){\mathrm{e}}^{-i\Delta J\left(t\right)}.$$

(7)

This implies a perturbation to the Hamiltonian that can be found by computing the quantity: $i\dot{U}{U}^{†}$. This is found to be

$$\begin{array}{cc}\hfill i\dot{U}{U}^{†}=H_{q+\Delta }& =H_q+\Delta U_q\left(t\right)\dot{J}\left(t\right)U_q^{†}\left(t\right)+\mathcal{O}\left({\Delta }^2\right)\hfill \\ \hfill & =H_q+\Delta K\left(t\right)+\mathcal{O}\left({\Delta }^2\right).\hfill \end{array}$$

(8)

where we have defined $K\left(t\right)=U_q\left(t\right)\dot{J}\left(t\right)U_q^{†}\left(t\right)$. To constrain that $H_{q+\Delta }$ is still a solution to the geodesic equation, we plug it into (5), and expand to first order in $\Delta$. To first order in $\Delta$, we find the constraint on K:

$$\begin{array}{cc}\hfill 0& =\dot{K}+i\mathcal{F}(\left[K,\mathcal{G}\left(H_q\right)\right]+\left[H_q,\mathcal{G}\left(K\right)\right]+\hfill \\ \hfill & \mathcal{Q}\left(\mathcal{F}\left(\left[\mathcal{G}\left(H_q\right),H_q\right]\right)\right)+\left[H_q,\mathcal{Q}\left(H_q\right)\right])\hfill \\ \hfill & =\dot{K}+i\mathcal{F}\left(\left[K,\mathcal{G}\left(H_q\right)\right]+\left[H_q,\mathcal{G}\left(K\right)\right]\right)+\hfill \\ \hfill & i{\mathcal{F}}^2\left(\left[\mathcal{P}\left(H_q\right),\mathcal{Q}\left(H_q\right)\right]\right).\hfill \end{array}$$

(9)

We used the fact that $\mathcal{P}\mathcal{Q}=0$, ${\mathcal{P}}^2=\mathcal{P}$, ${\mathcal{Q}}^2=\mathcal{Q}$. This is the so called “lifted” Jacobi equation. It is an inhomogeneous linear system, and so its general solution can be written as:

$$K\left(t\right)={\mathcal{K}}_t\left(K\left(0\right)\right)-{\mathcal{K}}_t\left({\int }_0^{t}d\tau {\mathcal{K}}_t^{-1}\left(C\left(\tau \right)\right)\right).$$

(10)

where ${\mathcal{K}}_t$ is a linear operator, which propagates the initial value of $K\left(0\right)$ such that it solves the homogeneous part of the (9), and $C=i{\mathcal{F}}^2\left(\left[\mathcal{P}\left(H_q\right),\mathcal{Q}\left(H_q\right)\right]\right)$ is the inhomogeneous part of (9). By expressing this equation in terms of coordinates, it turns out to be possible to derive an expression for ${\mathcal{K}}_t$. Expressing the homogeneous part of (9), in terms of coordinates we find:

$$\begin{array}{cc}\hfill 0& ={\dot{K}}_{ij}+i{F}_{ij}^{kl}(K_{k\alpha }{G}_{\alpha l}^{\beta \delta }{H}_{\beta \delta }^{\left(q\right)}-G_{k\alpha }^{\beta \delta }{H}_{\beta \delta }^{\left(q\right)}{K}_{\alpha l}\hfill \\ \hfill & +H_{k\alpha }^{\left(q\right)}{G}_{\alpha l}^{\beta \delta }{K}_{\beta \delta }-G_{k\alpha }^{\beta \delta }{K}_{\beta \delta }{H}_{\alpha l}^{\left(q\right)})\hfill \\ \hfill & ={\dot{K}}_{ij}+i{F}_{ij}^{kl}({\delta }_{k\beta }{G}_{\delta l}^{\gamma ϵ}{H}_{\gamma ϵ}^{\left(q\right)}-G_{k\beta }^{\gamma ϵ}{H}_{\gamma ϵ}^{\left(q\right)}{\delta }_{\delta l}+\hfill \\ \hfill & H_{k\alpha }^{\left(q\right)}{G}_{\alpha l}^{\beta \delta }-G_{k\alpha }^{\beta \delta }{H}_{\alpha l}^{\left(q\right)})K_{\beta \delta }\hfill \\ \hfill & ={\dot{K}}_{ij}-i{A}_{ij}^{\beta \delta }{K}_{\beta \delta }.\hfill \end{array}$$

(11)

Here we are using Einstein summation notation, and we have defined the tensor:

$$A_{ij}^{\beta \delta }=-F_{ij}^{kl}\left({\delta }_{k\beta }{G}_{\delta l}^{\gamma ϵ}{H}_{\gamma ϵ}^{\left(q\right)}-G_{k\beta }^{\gamma ϵ}{H}_{\gamma ϵ}^{\left(q\right)}{\delta }_{\delta l}+H_{k\alpha }^{\left(q\right)}{G}_{\alpha l}^{\beta \delta }-G_{k\alpha }^{\beta \delta }{H}_{\alpha l}^{\left(q\right)}\right).$$

(12)

The homogeneous propagator can then be expressed as an ordered exponential:

$$\mathcal{K}{\left(t\right)}_{ijkl}=\mathcal{T}{\left({\mathrm{e}}^{i{\int }_0^{t}dtA\left(t\right)}\right)}_{ijkl},$$

(13)

where we are suppressing indices inside of the time-ordering operator for notational convenience. We can think of this as a normal matrix equation where the first two indices of A correspond to the first index of a matrix and the last two indices of A correspond to the last index of a matrix. From this flattened perspective, A takes the form:

$$\begin{array}{c}\hfill A=F[(\mathbb{I}\otimes L-L^T\otimes \mathbb{I})+(H^T\otimes \mathbb{I}-\mathbb{I}\otimes H)G].\end{array}$$

Note that in the equation above, we have replaced super-operators $\mathcal{F}$ and $\mathcal{G}$ with their matrix representations,

$$\begin{array}{c}\hfill F={\displaystyle \frac{1}{2^n}}\sum _{\beta }{\displaystyle \frac{1}{g\left(\beta \right)}}{\sigma }^{\beta }\otimes {\sigma }^{\beta },\\ \hfill G={\displaystyle \frac{1}{2^n}}\sum _{\beta }g\left(\beta \right){\sigma }^{\beta }\otimes {\sigma }^{\beta },\\ \hfill g\left(\beta \right)=\left\{\begin{array}{cc}1\hfill & \mathrm{if}\beta \le 2,\hfill \\ q\hfill & \mathrm{else}.\hfill \end{array}\right.\end{array}$$

(14)

This matrix representation is an eigen-decomposition of the relevant super-operators. We require that the lifted Jacobi field has boundary conditions $J\left(0\right)=J\left(T\right)=0$, so the boundaries of the geodesic stay fixed. To accomplish this observe the relationship:

$$\begin{array}{cc}\hfill J\left(T\right)& ={\int }_0^{T}dt\dot{J}\left(t\right)\hfill \\ \hfill & ={\int }_0^{T}dt{U}^{†}K\left(t\right)U\hfill \\ \hfill & ={\int }_0^{T}dt{U}^{†}{\mathcal{K}}_t\left(K\left(0\right)\right)U-{\int }_0^{T}dt{U}^{†}\left(-{\mathcal{K}}_t\left({\int }_0^{t}d\tau {\mathcal{K}}_t^{-1}\left(C\left(\tau \right)\right)\right)\right)U\hfill \\ \hfill & ={\mathcal{J}}_T\left(\dot{J}\left(0\right)\right)-{\int }_0^{T}dt{U}^{†}\left(-{\mathcal{K}}_t\left({\int }_0^{t}d\tau {\mathcal{K}}_t^{-1}\left(C\left(\tau \right)\right)\right)\right)U.\hfill \end{array}$$

(15)

where we have identified $\dot{J}\left(0\right)=K\left(0\right)$. $J\left(0\right)$ is set to zero here as an initial condition for K. Because we need $J\left(T\right)=0$, we set it to zero in the above equation, and solve for $\dot{J}\left(0\right)$. The result is:

$$\dot{J}\left(0\right)={\mathcal{J}}_T^{-1}\left({\int }_0^{T}dt{U}^{†}\left(-{\mathcal{K}}_t\left({\int }_0^{t}d\tau {\mathcal{K}}_t^{-1}\left(C\left(\tau \right)\right)\right)\right)U\right).$$

(16)

This gives us a way to update our initial Hamiltonian from q to $q+\Delta$ because according to (8):

$$\dot{J}\left(0\right)={\displaystyle \frac{\partial H_q\left(0\right)}{\partial q}}\approx {\displaystyle \frac{H_{q+\Delta }\left(0\right)-H_q\left(0\right)}{\Delta }}.$$

(17)

The right-hand side (RHS) of (16) simplifies and finally, a calculation shows:

$${\displaystyle \frac{d{H}_q\left(0\right)}{dq}}=\left\{\begin{array}{cc}{\mathcal{J}}_T^{-1}\left({\int }_0^{T}dt{U}^{†}\left(t\right)it[\mathcal{P}\left(H\right),\mathcal{Q}\left(H\right)]U\left(t\right)\right),\hfill & \mathrm{q}=1,\hfill \\ ({\mathcal{J}}_T^{-1}\left(L\left(0\right)\right)T-L\left(0\right))/q(q-1),\hfill & \mathrm{q}>1,\hfill \end{array}\right.$$

(18)

where $L\left(0\right)=\mathcal{G}\left(H\right(0\left)\right)$. The base case for this update rule is given when $q=1$. In this case it is especially easy to calculate solutions to (5) because the metric and its inverse are identity operators on the Lie algebra. Concretely for this case we have:

$$\begin{array}{c}\hfill \begin{array}{cc}\hfill \dot{U}\left(t\right)+{\displaystyle \frac{i}{\hslash }}H\left(t\right)U\left(t\right)& =0\hfill \\ \hfill \dot{H}& =0,\hfill \end{array}\end{array}$$

(19)

which is still subject to the boundary condition: $U\left(0\right)=\mathbb{I}$, and $U\left(T\right)=U_{\mathrm{T}}$. In this case, the Hamiltonian is a constant and its initial value is given by $H_1\left(0\right)={\displaystyle \frac{i}{T}}\log \left(U_T\right)$. A derivation of this solution will be presented in the analytical section. Given this initial Hamiltonian and the update rule given at (18) it is possible to construct solutions that hit the target unitary for arbitrarily large penalty factors.

3. Analytic Approximations

In this section, we consider analytic solutions and approximations to our problem. Analytic solutions and approximations give context for our full numerical solutions. In the 1- and 2-qubit cases, $\mathfrak{su}\left(2\right)$ and $\mathfrak{su}\left(4\right)$, the geodesic equation simplifies to $\dot{\widehat{H}}=0$ because $\mathcal{G}$ is the identity operator on traceless 2-qubit operations. This gives us analytic values on the complexities that we can then compare to our numerical solutions.

When $\dot{\widehat{H}}=0$, we have the solution on the interval $\left[0,T\right]$

$$U\left(t\right)={\mathrm{e}}^{-i\widehat{H}t}\mathbb{I},$$

(20)

where we are imposing the boundary conditions: $U\left(0\right)=\mathbb{I}$, and $U\left(T\right)=U_{\mathrm{T}}$. The boundary condition at time T fixes the Hamiltonian in this case:

$$\widehat{H}={\displaystyle \frac{i}{T}}\log \left(U_T\right).$$

(21)

Here we are computing logarithms of matrices by first diagonalizing the matrix and taking the logarithm of the eigenvalues. Because $U_T$ is a unitary matrix, the eigenvalues are complex phases. When we take logarithms, we compute the phase such that they are on the principal branch, i.e., they take values between $\left(-\pi ,\pi \right]$. Any other branch choice introduces some spurious cost. To mitigate unitary drift, eigenvalues are normalized to have absolute value one, ensuring that small numerical errors in the eigenvalues do not affect the logarithm. This uniquely determines the Hamiltonian despite the ambiguity associated with the logarithm. From here, plugging into (3) and (4), we find the approximate complexity to be

$$C\approx \sqrt{-{\displaystyle \frac{1}{2^n}}\mathrm{tr}\left(\log \left(U_T\right)\mathcal{G}\left(\log \left(U_T\right)\right)\right)}.$$

(22)

This is the complexity associated with a straight line path from the identity operator to the target unitary. For one and two qubits it is an exact value of the complexity and for high numbers of qubits it serves as an approximation to which we can compare our exact answers.

3.1. One Qubit

In the case of one qubit, the Lie algebra is $su\left(2\right)$, with three dimensions spanned by ${\sigma }_x,{\sigma }_y$ and ${\sigma }_z$. General elements in this algebra are given by $H=V^i{\sigma }_i$, and the inner product simplifies to:

$$\begin{array}{cc}\hfill \langle H,J\rangle & ={\displaystyle \frac{1}{2}}tr\left(H\mathcal{G}\left(J\right)\right)\hfill \\ \hfill & =H^i{J}^j{\displaystyle \frac{1}{2}}tr\left({\sigma }_i{\sigma }_j\right)\hfill \\ \hfill & =g_{ij}{H}^i{J}^j.\hfill \end{array}$$

(23)

where we have defined

$$\begin{array}{c}\hfill g_{ij}=\left[\begin{array}{ccc}1& 0& 0\\ 0& 1& 0\\ 0& 0& 1\end{array}\right].\end{array}$$

(24)

This is the normal inner product one uses on Euclidean space. In the following, we consider the target unitary matrix, which corresponds to the quantum Fourier transform on one qubit:

$$\begin{array}{c}\hfill U_T={\displaystyle \frac{-i}{\sqrt{2}}}\left[\begin{array}{cc}1& 1\\ 1& -1\end{array}\right].\end{array}$$

(25)

To construct a geodesic that hits this target, we first compute the matrix logarithm to obtain the Hamiltonian. This is most easily done using computer algebra and the result is:

$$\begin{array}{c}\hfill H={\displaystyle \frac{\pi }{2\sqrt{2}}}\left[\begin{array}{cc}1& 1\\ 1& -1\end{array}\right].\end{array}$$

(26)

Now to obtain the geodesic connecting the identity and target, we need to solve the Shrödinger equation: $\dot{U}=-iHU$. Because the Hamiltonian is a constant here, this can be done using the matrix exponential: $U={\mathrm{e}}^{-iHt}$. Computing this quantity and simplifying, we find:

$$\begin{array}{c}\hfill U\left(t\right)=\left[\begin{array}{cc}\alpha \left(t\right)-\beta \left(t\right)& -\beta \left(t\right)\\ -\beta \left(t\right)& \alpha \left(t\right)+\beta \left(t\right)\end{array}\right]\\ \hfill \alpha \left(t\right)=cos\left({\displaystyle \frac{\pi }{2}}t\right)\beta \left(t\right)={\displaystyle \frac{i}{\sqrt{2}}}sin\left({\displaystyle \frac{\pi }{2}}t\right).\end{array}$$

(27)

Finally, it is possible to compute the complexity. It is given by $C=\sqrt{{\displaystyle \frac{1}{2}}tr\left(HH\right)}={\displaystyle \frac{\pi }{2\sqrt{2}}}$.

3.2. Two Qubits

In the case of two qubits, the Lie algebra we work with is $su\left(4\right)$ and it is spanned by Kronecker products of at most two Pauli matrices. This space is 15-dimensional and the different basis elements are shown in (A7), and because no three-qubit operations are allowed at this stage, the super-operator $\mathcal{G}$ is still an identity operation on traceless unitary matrices. Because of this, the metric tensor is given by:

$$g_{ij}={\delta }_{ij}.$$

(28)

where ${\delta }_{ij}$ is the normal Kronecker delta, corresponding to a Euclidean inner product on this 15-dimensional space.

We consider now the following target unitary matrix, which corresponds to the two-qubit quantum Fourier transform:

$$\begin{array}{c}\hfill U_T={\displaystyle \frac{1}{\sqrt{2^n}}}\left[\begin{array}{cccc}1& 1& 1& 1\\ 1& \omega & {\omega }^2& {\omega }^3\\ 1& {\omega }^2& 1& {\omega }^2\\ 1& {\omega }^3& {\omega }^2& 1\end{array}\right].\end{array}$$

(29)

where we have defined the variable:

$$\begin{array}{c}\hfill \omega =e^{\pi i/2}.\end{array}$$

(30)

As in the previous section, we then compute the Hamiltonian using matrix logarithms, and use that Hamiltonian in a matrix exponential to construct the geodesic path to the target unitary matrix. Up to a global phase, we find that path is given by:

$$\begin{array}{c}\hfill U\left(t\right)={\displaystyle \frac{1}{4}}{\omega }^{-\frac{3}{4}t}\left[\begin{array}{cccc}\alpha & \gamma & \gamma & \gamma \\ \gamma & \beta & \delta & ϵ\\ \gamma & \delta & \alpha & \delta \\ \gamma & ϵ& \delta & \beta \end{array}\right],\\ \hfill \alpha ={\omega }^{2t}+3,\beta ={\left(1+{\omega }^t\right)}^2,\gamma =1-{\omega }^{2t},\\ \hfill \delta ={\omega }^{2t}-1,ϵ={\left({\omega }^t-1\right)}^2.\end{array}$$

(31)

Again, we can compute the complexity according to $C=\sqrt{{\displaystyle \frac{1}{4}}tr\left(HH\right)}={\displaystyle \frac{\sqrt{11}\pi }{16}}$.

For the gate set mentioned earlier: $G=\left\{X,S_x,Rz\left(\theta \right),C_z\right\}$ the complexities can be computed analytically and the results are:

$$\begin{array}{cc}\hfill C\left(X\right)& ={\displaystyle \frac{\pi }{2}},\hfill \\ \hfill C\left(S_x\right)& ={\displaystyle \frac{\pi }{4}},\hfill \\ \hfill C\left(R_z\left(\theta \right)\right)& =\mathrm{abs}\left(\mathrm{atan}2\left(sin\left(\theta \right),cos\left(\theta \right)\right)\right),\hfill \\ \hfill C\left(CZ\right)& ={\displaystyle \frac{\sqrt{3}\pi }{4}}.\hfill \end{array}$$

(32)

These gate results will be used later on in order to create a point of comparison by transpiling circuits into the gate set G, and then the complexity of each gate is computed using these analytic formulas and summed. This is the gate-sum complexity and in Section 5 it is used to benchmark the geodesic compilation of full circuits.

3.3. Several Qubits

When we have more than two qubits, the solution to the geodesic equation is no longer a constant Hamiltonian; this makes the unitary evolution determined by Schrödinger’s Equation (19) much more difficult to calculate analytically. As a first approximation, in this section, we consider paths in the unitary group corresponding to constant Hamiltonians that hit the target. These paths are not geodesic and so do not minimize the complexity, but they do put upper bounds on the complexity that can be used to give our numerical solutions context. Here we call paths with a constant Hamiltonian simple.

Our procedure for doing this is the same as the two previous subsections. Starting with the target unitary matrix, we first compute the Hamiltonian using matrix logarithms. After that, the path in the unitary group is found by computing the Matrix exponential: $U={\mathrm{e}}^{-iHt}$. Finally, the complexity is computed according to the formula $C\approx {\langle H,H\rangle }^{1/2}$. We have computed this simple-path complexity for the quantum Fourier transform for up to 10 qubits. The results are shown in the Figure 1, which also contains numerically computed geodesic complexities for up to four qubits and the corresponding gate-sum complexities.

4. Numerical Analysis

In this section we discuss the details associated with creating a numerical program that can compute quantum computational geodesics.

To make unitary matrices that correspond to quantum circuits we use a package in qiskit that has built-in functionality to do this. For example, constructing the N-qubit quantum Fourier transform matrix representation can be accomplished with the commands:

This procedure is quite general and can be used to construct the matrix representation of any qiskit circuit object. Once the target unitary operator has been obtained we then compute the Hamiltonian $H_0$ for the desired unitary at time $T=1$ in the case where $q=1$, taking a matrix logarithm as suggested by (A3). To compute matrix logarithms, we developed our own code to have tighter controls over ambiguities associated with logarithms. In this way, we compute logarithms using the code:

This logarithm works by first diagonalizing the unitary matrix and then taking the log of the eigenvalues such that they are on the principal branch, i.e., they take values between $\left(-\pi ,\pi \right]$. The basis is then changed to the original one and the log of the matrix is returned.

Generally, all functions we use are decorated with the @njit operator such that functions are precompiled and run much faster at runtime.

Because we are only considering target unitaries that can be generated by elements of the Lie algebra $su\left(2^n\right)$, we substract the zero-point energy of the Hamiltonian. This amounts to a constant shift of the energy levels of the Hamiltonian, which does not affect its dynamics. This is accomplished by: $H^{\prime }=H_0-{\displaystyle \frac{1}{2^n}}tr\left(H_0\right)\mathbb{I}$, where $H_0$ is specified according to (21) and the complex unitary log function specified earlier is used. This effectively makes the Hamiltonian traceless. Generally, we remove global phases of circuits because they are not observables. Using the chosen metric, the cost of a global phase is not defined.

At this stage we need to compute the RHS of (18). To begin we develop a numerical implementation of the super-operators: $\mathcal{F}$ and, $\mathcal{G}$. This can be done by implementing the super-operators $\mathcal{P}$, and $\mathcal{Q}$ numerically. Generally, the operators $\mathcal{P}$ and $\mathcal{Q}$ operate on objects of the form $V^i{\sigma }_i$, where $V^i$ are real coefficients and ${\sigma }_i$ is a Pauli string. For three qubits, all Pauli strings are shown in (A8). From there the coefficient can be obtained from $V^i={\displaystyle \frac{1}{2^n}}tr\left(V^j{\sigma }_j{\sigma }_i\right)$, one can then count the number of Pauli matrices in a given Pauli string, which is associated with $V^i$. This is the weight of the Pauli string. For example, $\mathcal{P}\left(V^i{\sigma }_i\right)={\sum }_i{w}_i{V}^i{\sigma }_i$, where $w_i$ goes to zero if the weight is greater than 2 and one otherwise. In Python code this is implemented by:

Once the super-operators $\mathcal{P}$, and $\mathcal{Q}$ have been implemented we need to solve for the time evolution of the Hamiltonian and $U\left(t\right)$, essentially, numerically finding solutions to (5). We do this using the scipy.integrate.solve_ivp function with the “RK45” method. We solve over the range $t\in \left[0,1\right]$, and we record the solution value at $N_t$ linearly spaced points along this interval. These points will be used later on for computing the integrals in (18). During the solution however, solve_ivp may take as many steps as it needs to satisfy the default tolerance values for rtol and atol, which are ${10}^{-3}$ and ${10}^{-4}$ respectively. Besides the usual failure modes associated with solve_ivp, an extra condition has been implemented to check if the Jacobi propagator is well conditioned. If the condition number is above a threshold of ${10}^{12}$ the solver exits and stops running.

Numerically now, we must calculate the Jacobi propagator. Again, this object is defined as

$${\mathcal{J}}_T\left(\dot{J}\left(0\right)\right)={\int }_0^{T}dt{U}^{†}{\mathcal{K}}_t\left(\dot{J}\left(0\right)\right)U.$$

(33)

Expressing this in terms of coordinates we find:

$${\mathcal{J}}_T^{ij\gamma \delta }{\dot{J}}_{\gamma \delta }\left(0\right)=\left({\int }_0^{T}dt{U}_{i\alpha }^{†}{\mathcal{K}}_t^{\alpha \beta \gamma \delta }{U}_{\beta j}\right){\dot{J}}_{\gamma \delta }\left(0\right).$$

(34)

The K propagator can be computed according to (13). We find it is most efficient to compute the ordered matrix exponential using a product:

$${\mathcal{K}}_t^{\alpha \beta \gamma \delta }=\prod _{i=1}^{i=t_f}{\mathrm{e}}^{i\Delta t_{i}A\left(t_i\right)}.$$

(35)

where values for A are determined from our solutions for H, and U, which have been recorded on $N_t$ linearly spaced points on $\left[0,1\right]$. Numerically, we implement (35) directly as written. Concretely, A is calculated from (12). It is understood that operators evaluated at later times are placed towards the left. Putting all of this together, we then compute ${\mathcal{J}}_T^{ij\gamma \delta }=\left({\int }_0^{T}dt{U}_{i\alpha }^{†}{\mathcal{K}}_t^{\alpha \beta \gamma \delta }{U}_{\beta j}\right)$. In Python, this can be done with one line:

In all cases we numerically compute integrals with the trapezoid method. To obtain the inverse Jacobi propagator we reshape this tensor into a matrix and then invert it. Using this technique, we are able to evaluate (18) and we use solve_ivp to solve it as a differential equation. A flowchart summarizing the continuation scheme discussed above is shown in Figure A1.

4.1. Results

In this section we consider two numerical examples, and discuss our results. As a first numerical example, we consider the three- and four-qubit quantum Fourier transform. As a second example, we consider a randomly generated three-qubit quantum circuit with a depth of 100 gates. The randomly generated circuit can be seen in Figure A2. The three- and four-qubit quantum Fourier transform can be seen in Figure A3 and Figure A5.

Following the procedure outlined in the previous sections, we compute the complexity of the three-qubit quantum Fourier transform. The complexity as a function of the penalty parameter can be seen in Figure 2. As the penalty parameter is increased the complexity increases also but reaches an asymptote close to $C=1.95$. As a point of comparison we have also computed the complexity of the three-qubit QFT by first transpiling to the gate set $G=\left\{X,S_x,Rz\left(\theta \right),C_z\right\}$ and using precomputed values of the complexity for these elementary gates to compute a baseline complexity. We call this the gate-sum complexity. The gate-sum complexity for the the three-qubit QFT has been numerically computed and is: $C_{\mathrm{gatesum}}=33.6$. The cost improvement gained by using a geometric compilation on the whole circuit instead of each individual gate and summing is $17.2$. The transpilation step for calculating the gate-sum complexity is done with the qiskit transpile function with optimization level $=3$ and seed $=1$. The transpiled three-qubit QFT is shown in Figure A4.

The initial Pauli coefficients for our Hamiltonian as a function of the penalty factor can be seen in Figure 3. In this figure, Pauli strings with weight higher than two are shown in red and labeled “Q”. We notice that as the penalty factor increases these penalized generators have shrinking amplitudes indicating that they are in fact being penalized by the algorithm. Moreover we note that the initial coefficients seem to be reaching steady-state values indicating our cutoff value for q is a reasonable one.

After having found the correct initial coefficients for our Hamiltonian, the geodesic equation can then be solved to obtain the time-dependent Hamiltonian coefficients. For this particular example the time-dependent coefficients can be found below in Figure 4. Geometrically these coefficients are interpreted as tangent vectors; from a quantum control perspective they are interpreted as control functions.

A concrete implementation of these coefficients on a quantum computer would require a quantum processor that is well modeled by the metric used here, or an adaptation of the code base to a metric that integrates more physical details of existing processors. A physical realization of such a procedure is beyond the scope of this report and we reserve it for later.

We have also repeated this analysis for the four-qubit quantum Fourier transform, which is shown in Figure A5. A transpilation of this circuit for the gate set G is shown in Figure A6. We find the complexity to be $3.29$ and the control functions are shown in Figure 5. The gate-sum complexity of the transpiled circuit is 65.1. The gate-sum cost is a factor of 19.8 more than the geodesic compilation.

As a final step, we verify that the geodesic evolution of our unitary matrix indeed hits the target unitary. This can be checked by computing the rms deviation of our time-dependent unitary with the target unitary. That is, we compute $\left|\right|U\left(t\right)-U_{\mathrm{Target}}\left|\right|=\sqrt{\frac{1}{4^n}\left(U^{†}\left(t\right)-U_{\mathrm{Target}}^{†}\right)\left(U\left(t\right)-U_{\mathrm{Target}}\right)}$ for $t\in \left[0,1\right]$. Finally, we then plot this error function as a function of time. This plot can be seen below in Figure 6. We notice that the rms deviation approaches zero as time goes to 1, indicating that we are indeed hitting the target.

As a second example, we compute the complexity of a randomly generated quantum circuit with 3 qubits and a depth of 100, which can be seen in Figure A2. The circuit is composed of gates drawn from the gate set G. Gates and target qubits are drawn from this gate set with a uniform probability distribution specified by the numpy choice function. The seed for the choice function was set to be one. Our computation of the complexity of this quantum circuit as a function of the penalty factor can be seen below in Figure 7. We notice that the complexity is increasing with increasing penalty factor and reaches an asymptote close to $C=2.48$. Because this circuit is already expressed in terms of gates from G, no transpilation is needed and the gate-sum complexity is easy to compute. The gate-sum complexity of this circuit is found to be $C_{\mathrm{RAND}}=127.5$. So despite the perceived complexity of the circuit shown in Figure 7, it can actually be implemented with a $98\%$ cost reduction by compiling the whole circuit into geodesic control functions instead of compiling each gate independently. The saturation of the cost close to this low value is due to the dimension of the Hilbert space being only $2^3$ for this three-qubit system.

After having determined the initial values of the Hamiltonian for this randomly generated circuit, we then time-evolve the Hamiltonian to obtain its time evolution. The time evolution of the Hamiltonian coefficients can be seen in Figure 8. These coefficients are considerably more complicated-looking than the ones found in the case of the quantum Fourier transform, and have a larger amplitude, resulting in a complexity that is larger.

Convergence testing for this circuit was performed and it was found that the results did not change appreciably when the hyperparameters $Nq$, $N_t$, rtol and atol were varied. $N_q$ was varied from 100 to 200 and $N_t$ was varied from 101 to 201. Over this section of the parameter space, the obtained value of the complexity varied by less than a quarter of a percent (see Figure A8). Additionally, rtol and atol were decreased by an order of magnitude, from ${10}^{-3}$ to ${10}^{-4}$ and ${10}^{-6}$ to ${10}^{-7}$ respectively. It was found that the complexity did not change appreciably under this parameter shift.

Finally, we compute the RMS deviation of our time-dependent unitary with the target unitary. The time-dependent RMS deviation can be seen below in Figure 9. Again, we are able to hit the target.

4.2. Fermion Chain Evolution

As a final example of our implementation of this algorithm, we calculate the quantum complexity of parts of a quantum circuit, which is used to calculate the evolution of a Hubbard model on a fermion chain. QGeo can only process a small number of qubits. However, we can use our method to reduce the depth of a large circuit if the circuit can be built by combining smaller circuits. As an example, let us consider a fermionic chain. In the case of non-interacting fermions, this chain is described by the Hamiltonian:

$$H_{\mathrm{Fermion}}=h\sum _i\left(c_i^{†}{c}_{i+1}+c_{i+1}^{†}{c}_i\right).$$

(36)

Using the Jordan–Wigner transformation it is possible to express this Hamiltonian in terms of Pauli matrices acting at different sites, allowing for an implementation on a quantum computer. This transformation is given by:

$$\begin{array}{c}\hfill c_j^{†}={\displaystyle \frac{1}{2}}\left({\sigma }_j^x-i{\sigma }_j^y\right)\prod _{i<j}{\sigma }_i^z,\\ \hfill c_j={\displaystyle \frac{1}{2}}\left({\sigma }_j^x+i{\sigma }_j^y\right)\prod _{i<j}{\sigma }_i^z.\end{array}$$

(37)

we can represent the Hamiltonian in terms of Pauli operators

$$H_{\mathrm{Fermion}}={\displaystyle \frac{h}{2}}\sum _i\left({\sigma }_i^x{\sigma }_{i+1}^x+{\sigma }_i^y{\sigma }_{i+1}^y\right).$$

(38)

The time-evolution operator $U\left(T\right)=e^{-iHT}$ can be approximated using Trotter–Suzuki decimation

$$U\left(T\right)\approx \prod _{t=1}^{T/\mathrm{dt}}\left(\prod _i{e}^{-i\frac{h\mathrm{dt}}{2}{\sigma }_i^x{\sigma }_{i+1}^x}{e}^{-i\frac{h\mathrm{dt}}{2}{\sigma }_i^y{\sigma }_{i+1}^y}\right),$$

(39)

where the error in the approximation is $\mathcal{O}\left({\mathrm{dt}}^2\right)$. The evolution operator can be written in terms of commonly used quantum gates

$$U\left(T\right)\approx \prod _{t=1}^{T/\mathrm{dt}}\left(\prod _i{R}_{i,i+1}^{xx}\left(h\mathrm{dt}\right)R_{i,i+1}^{yy}\left(h\mathrm{dt}\right)\right).$$

(40)

The order of the products in Equation (40) can be rearranged without incurring error greater than $\mathcal{O}\left({\mathrm{dt}}^2\right)$. Circuits typically perform better if the gates are rearranged as

$$\begin{array}{cc}\hfill U\left(T\right)\approx \prod _{t=1}^{T/\mathrm{dt}}(& \prod _{i\mathrm{odd}}{R}_{i,i+1}^{xx}\left(h\mathrm{dt}\right)R_{i,i+1}^{yy}\left(h\mathrm{dt}\right)\hfill \\ \hfill \times & \prod _{i\mathrm{even}}{R}_{i,i+1}^{xx}\left(h\mathrm{dt}\right)R_{i,i+1}^{yy}\left(h\mathrm{dt}\right)).\hfill \end{array}$$

(41)

Figure 10a shows the corresponding quantum circuit. The circuit can be constructed out of two basic blocks shaded blue and yellow. By transpiling to the gate set, G, each $R^{xx}$ and $R^{yy}$ gate can be constructed using two CZ gates and several single-qubit gates. The transpilation of $R^{xx}$ is shown below in Figure A7. By using the analytic results from (32) it is possible to compute the gate-sum complexity analytically. We have $C_{\mathrm{gate}-\mathrm{sum}}\left(R^{xx}\left(\theta \right)\right)=6\pi +{\displaystyle \frac{\sqrt{3}}{2}}\pi +\left|\mathrm{atan}2\left(sin\left(\theta \right),cos\left(\theta \right)\right)\right|$. Because each block in the Trotterized circuit consists of three $R^{xx}$ gates and $R^{yy}$ gates, the gate-sum complexity of the whole block is $6\times C_{\mathrm{gate}-\mathrm{sum}}\left(R^{xx}\left(\theta \right)\right)$. For $\theta ={\displaystyle \frac{1}{2}}$, the gate-sum complexity of the block therefore evaluates to $C_{\mathrm{gate}-\mathrm{sum}}^{\mathrm{Block}}(\theta ={\displaystyle \frac{1}{2}})=36\pi +3\sqrt{3}\pi +3\approx 132.4$. However, from Figure 10b,c we see that when compiled with QGeo the entire block has a cost of only $0.77$. This is much lower than the calculated gate-sum complexity, highlighting inefficiencies for the naive implementation with respect to this metric. QGeo has the capability to detect such inefficiencies. The complexity of each block is reduced to only $0.6\%$ of the gate-sum complexity. This reduction carries over to the the full circuit. Thus, by building the circuit out of the reduced blocks, we are able to time-evolve fermionic chains for many more Trotter steps than would otherwise be possible in a time-constrained environment. Finally, in Figure 10d,e we see that the error from using the reduced block goes to zero.

5. Conclusions

In conclusion, we have developed a modern Python implementation of a method specified in [5,15] for determining geodesic control functions of quantum algorithms, called QGeo. Numerical methods must be used because analytic methods that can analyze geodesic complexities for circuits with more than two qubits are not available. Nevertheless, analytic methods are useful for obtaining complexities of one- and two-qubit gates, which can give context to the full numerical solutions. This implementation has been used to determine whether more efficient versions of quantum algorithms are available. Efficiency gains are quantified by comparing the geometric cost of the whole circuit with respect to the chosen metric, and the sum of the geometric costs of all gates in the circuit. In the case of the quantum Fourier transform, this Python package has shown cost reductions are available that can reduce complexities by about an order of magnitude compared with the textbook implementation. For quantum simulation of a fermionic chain, QGeo has been used to determine that more efficient implementations of Trotter blocks exist, which have a cost that is $99.4\%$ lower than the gate-sum complexity of the original implementation of the circuit. Therefore, while it is prohibitive to assess circuits with more than six qubits using QGeo, it is still possible to analyze and optimize circuits that have many more qubits, provided that they have a block type structure. In the case of the randomly generated circuit, our procedure was able find an implementation of the circuit that lowered the associated cost by two orders of magnitude.

These cost reductions can be realized at the abstract level where the metric used here is reasonable, however physical realizations are a current limitation. How one can implement an actual geodesic algorithm on an existing quantum processor is still not known. However, using the control functions obtained by QGeo and mapping them to existing quantum processors may be possible using more detailed knowledge of the actual processor architecture. This would however require modifications to the super-operator, $\mathcal{G}$, to reflect characteristics of a given processor. These characteristics may include processor topology, error rates, practicality of pulses, robustness to noise, of pulses’ availability of single- and two-qubit Pauli strings, and mappings from RF pulses to Pauli strings. For example, processor topology could be implemented by penalizing Pauli strings corresponding to links outside the topology in the same way that three-qubit operations are penalized. This would likely lead to higher values of circuit complexities.

Extensions of QGeo that have better scaling properties to more qubits may be possible. This is because the space of tangent vectors with weight less than three only scales quadratically, whereas the full tangent space scales exponentially. This extension would require constrained optimization where tangent vectors are constrained to be on the space of two or fewer weight Pauli strings. However, a realization of better scaling is beyond the scope of this report and we reserve it for future work.