Low rank approximation in simulations of quantum algorithms

A quantum algorithm is often expressed by a unitary transformation $U$ applied to a quantum state $|\psi 〉$. On a quantum computer, $|\psi 〉$ can be efficiently encoded by $n$ qubits, effectively representing $2^n$ amplitudes simultaneously, and $U$ is implemented as a sequence of one or two-qubit gates that are themselves 2 × 2 or 4 × 4 unitary transformations. To simulate a quantum algorithm on a classical computer, we can simply represent $|\psi 〉$ as a vector in ${ℂ}^{2^n}$, and $U$ as a ${ℂ}^{2^n\times 2^n}$ matrix, and perform a matrix–vector multiplication $U|\psi 〉$. However, for even a moderately large $n$, e.g., $n=50$, the amount of memory required to store $U$ and $|\psi 〉$ explicitly far exceeds what is available on many of today’s powerful supercomputers, thereby making the simulation infeasible [1], [2], [3], [4]. Fortunately, for many quantum algorithms, both $|\psi 〉$ and $U$ have structures. In particular, $|\psi 〉$ may have a low-rank tensor structure, and the quantum circuit representation of $U$ gives a decomposition of $U$ that can be written as $U=U^{\left(1\right)}{U}^{\left(2\right)}\cdots U^{\left(D\right)},$where $U^{\left(i\right)}$ is a linear combination of Kronecker products of 2 × 2 matrices, many of which are identities, and $D$ is the depth of the circuit which is typically bounded by a (low-degree) polynomial of $n$. As a result, if the low rank structure of $|\psi 〉$ can be preserved in the successive multiplication of $U^{\left(i\right)}$’s with the input, we may be able to simulate the quantum algorithm efficiently for a relatively large $n$.

When $|\psi 〉$ is viewed as an order $n$ tensor, there are several ways to represent it efficiently. One of them is known as a canonical polyadic (CP) decomposition [5], [6] written as $|\psi 〉=\sum _{i_1,\dots ,i_n\in \{0,1\}}\sum _{k=1}^R{A}_{i_{1}k}^{\left(1\right)}{A}_{i_{2}k}^{\left(2\right)}\cdots A_{i_{n}k}^{\left(n\right)}|i_1{i}_2\dots i_n〉,$where $A^{\left(i\right)}\in {ℂ}^{2\times R}$ and $R$ is known as the rank of the CP decomposition. The second representation is known as matrix product state (MPS) [7] in the physics literature or tensor train (TT) [8] in the numerical linear algebra literature, which is a special tensor networks representation of a high dimensional tensor  [9]. In this representation, the quantum state can be written as $|\psi 〉=\sum _{i_1,\dots ,i_n\in \{0,1\}}\sum _{k_1,\dots ,k_{n-1}}{\mathcal{A}}_{i_1{k}_0{k}_1}^{\left(1\right)}{\mathcal{A}}_{i_2{k}_1{k}_2}^{\left(2\right)}\cdots {\mathcal{A}}_{i_n{k}_{n-1}{k}_n}^{\left(n\right)}|i_1{i}_2\dots i_n〉,$where ${\mathcal{A}}^{\left(j\right)}$ is a tensor of dimension $2\times R_{j-1}\times R_j$, with $R_0=R_n=1$. The rank of an MPS is often defined to be the maximum of $R_j$ for $j\in \{1,2,\dots ,n-1\}$. The memory requirements for CP and MPS representations of $|\psi 〉$ are $\mathcal{O}\left(Rn\right)$ and $\mathcal{O}\left(R^{2}n\right)$, respectively. When $R$ is relatively small, such requirement is much less than the $\mathcal{O}\left(2^n\right)$ requirement for storing $|\psi 〉$ as an vector, which allows us to simulate a quantum algorithm with a relatively large $n$ on a classical computer that stores and manipulates $|\psi 〉$ in these compact forms.

For several quantum algorithms, the rank of the CP or MPS representation of the input $|\psi 〉$ is low. However, when $U^{\left(i\right)}$’s are successively applied to $|\psi 〉$, the rank of the intermediate tensors (the tensor representation of the intermediate states) can start to increase. When the rank of an intermediate tensor becomes too high, we may not be able to continue the simulation for a large $n$. One way to overcome this difficulty is to perform rank reductions on intermediate tensors when their ranks exceed a threshold. When a CP decomposition is used to represent $|\psi 〉$, we can take, for example, (1.2) as the input and use the alternating least squares (ALS) [10], [11] algorithm to obtain an alternative CP decomposition that has a smaller $R$. The rank reduction of an MPS can be achieved by performing a sequence of truncated singular value decomposition (SVD).

Performing rank reduction on intermediate tensors can introduce truncation error. For some quantum algorithms, this error is zero or small, thus not affecting the final outcome of the quantum algorithm. For other algorithms, the truncation error can be large, which results in significant deviation of the computed result from the exact solution. For a specific quantum algorithm, understanding whether the intermediate tensors can be accurately approximated through low rank truncation is valuable for assessing the difficulty of simulating the algorithm on a classical computer. We attempt to investigate such difficulty for a few well known quantum algorithms in this paper both analytically and numerically.