Back to Quantum Computation
Back to notes

# Quantum Minimum Circuit Size Problems

100%

The goal of this notes is to provide an exposition on quantum Minimum Circuit Size Problems CCZZ21 for non-TCS (Theoretical Computer Science) readers. We assume a little familiarity with the basic terminologies and concepts in quantum computation.

## Quantum Circuits

Quantum circuits are a central theoretical model for theorists (and sometimes experimentalists) to study quantum computation. Due to the interdisciplinary nature, people from different background might have different definitions in mind so we will start with some clarifications to make sure the readers are on the same page.

#### Gateset

Gateset refers to the set of allowable quantum gates used in the circuit. Both in theory and practice, there are multiple choices of (universal) gateset. Nonetheless, in the study of quantum circuit complexity, the choice of gateset usually doesn’t matter too much. Specifically, most of the theoretical results hold from one gateset to another with minor parameter overheads.

#### Function type

There are three common objects that can be computed by a quantum circuit: a unitary matrix, a quantum state, or a Boolean function. Note that as these are different types of function, their circuit complexity is in general incomparable and should be discussed separately.

For example, when we say a quantum circuit computes a Boolean function, we mean the following. Given an input $\ket{x}$ for some $x\in\bit^n$, the output value is $1$ if the marginal probability of the first output qubit being $1$ is at least $2/3$ (Both the choice of the first output qubit and that of $2/3$ are without loss of generality).

#### Architecture

Circuit architecture refers to the underlying graph/geometry structure of the circuit. In practice, the architecture has to be “local” in the sense that a gate should connect qubits/wires that are physically close to each other. Common architectures include 1D an 2D circuits or their variants. Not surprisingly, quantum circuit complexity is highly dependent on the underlying architecture of interest.

## Minimum Quantum Circuit Size Problem (MQCSP)

Before defining the Minimum Quantum Circuit Size Problem (MQCSP) and its variants, there is one more important clarifications to make about the input format of the computational problem.

#### Input format

In the classical Minimum Circuit Size Problem (MCSP), the input to this computational problem is the truth table of a Boolean function. In particular, for a Boolean function $f:\bit^n\to\bit$, its truth table $tt(f)\in\bit^{2^n}$ is the collection of its evaluations: $tt(f)=\{f(x)\}_{x\in\bit^n}$. Note that the running time of MCSP is then measured with respect to $N=2^n$ instead of $n$. That is, a polynomial time algorithm for MCSP refers to the existence of an algorithm with running time $\poly(2^n)=2^{O(n)}$.

As for the quantum version(s) of MCSP, there could be several choices of the input format. And one should be careful about which one they are using depending on the context.

• Truth table of a Boolean function: This is the most natural quantum analogue of MCSP and in CCZZ21 they define the Minimum Quantum Circuit Size Problem (MQCSP) in this way.
• An unitary matrix: The input is an unitary matrix and hence the input size is $O(2^n\times2^n)=2^{O(n)}$. This corresponds to the Unitary Minimum Circuit Size Problem (UMCSP) in CCZZ21
• Copies of a quantum state: The algorithm can have an access to arbitrarily many copies of a quantum state. This corresponds to the State Minimum Circuit Size Problem (SMCSP) in CCZZ21 Note that the input size now becomes $n$ (qubits).
• A quantum state vector: The input is the vector that contains all the amplitude of a quantum state. The input size is $2^n$.
• The description of a quantum circuit: The input is the description of a quantum circuit, i.e., specifying how gates connect to each other etc. Namely, the input size is proportional to the size of the circuit.

#### (Informal) Definitions of quantum MCSPs

Now, we are ready to (informally) define the computational problems for studying the minimum quantum circuit size of a function.

First, pick a gateset, a function type, a circuit architecture, and a proper input format. Next, due to the stochastic nature of quantum computation, we have to specify a few extra parameters: the size parameter $s$, ancilla parameter $t$, the completeness parameter $\alpha$, and the soundness parameter $\beta$ with $0<\beta<\alpha\leq1$. The corresponding quantum MCSP is then modeled as a promise decision problem as follows. On an input instance, the algorithm should determine if it is in the Yes case or the No case. Take the Unitary Minimum Circuit Size Problem (UMCSP) as an example, the Yes and No case would be: on input an unitary matrix $U$,

• Yes: there exists a quantum circuit $\mathcal{C}$ using at most $s$ gates and at most $t$ ancilla qubits such that for all $n$-qubit state $\ket{\psi}$, $$\|(\bra{\psi}\otimes I_t)(U^\dagger\otimes I_t)\mathcal{C}\ket{\psi,0^t}\|^2\geq\alpha ,$$ where $\|\cdot\|$ is the $L_2$ norm.

• No: for every quantum circuit $\mathcal{C}$ using at most $s$ gates and at most $t$ ancilla qubits there exists an $n$-qubit state $\ket{\psi}$, $$\|(\bra{\psi}\otimes I_t)(U^\dagger\otimes I_t)\mathcal{C}\ket{\psi,0^t}\|^2\leq\beta \, .$$

Here, the jargon promise refers to the situation that we only care about the input instances which are either Yes or No. The reason of using promise problem is to make the problem platform more flexible to study its complexity while maintaining its relevance to practice.

One can naturally define other variants of quantum MCSPs, however, there are sometimes some (minor) subtlties for rigorous theoretical treatments. See the formal definitions in CCZZ21

#### Hardness and easiness of quantum MCSPs

Quantum MCSPs are believed to be difficult to solve efficiently. And all the known algorithms for both classical and quantum MCSPs are basically straightforward brute-force algorithms. However, it is also not an easy job to rigorously demonstrate their hardness (same for the classical MCSP). Specifically, for classical MCSP, Kabanets and Cai showed that if one can prove the $\NP$-hardness of MCSP using reasonable techniques, then as a corollary they will solve the frontier open problems in circuit complexity and derandomization. In other words, rigorously proving the hardness of MCSP involves breakthrough ideas in computational complexity theory.

But what should we do if we still want some evidences for the hardness of MCSP? Kabanets and Cai also gave a way out for this by using the following template argument:

If MCSP is easy, then you can solve problem X, Y, Z, which are considered to be difficult to solve by experts.

For example, the existence of efficient algorithm for MCSP would imply breakthrough circuit lower bounds, derandomization, and learning algorithms, etc.

In CCZZ21, we generalized these hardness evidences for classical MCSP to three quantum MCSPs: MQCSP (for Boolean functions), UMCSP (for unitary matrices), and SMCSP (for quantum states). That is, if there is an efficient (quantum) algorithm for any of them (under certain reasonable parameter regimes), then as a corollary one will prove breakthrough circuit lower bounds, derandomization, and learning algorithms.

Nonetheless, there’s one special setting of quantum MCSPs (which is not considered in CCZZ21 because it’s not of the form that’s commonly studied in the classical setting) where people can say something rigorously: the input is a quantum circuit that computes an unitary matrix. In this case, we know that the corresponding MCSP is $\QMA$-hrad because determining if a quantum circuit is close to an identity matrix is $\QMA$-hard.

To summarize, in general quantum and classical MCSPs are believed to be hard to solve but how to formally prove the hardness itself is hard. In most situations, the best complexity-theorists can do is to provide evidence for the hardness of MCSPs by showing its easiness implies some breakthrough results. Hence, if you believe those breakthrough results are difficult to solve, then designing efficient algorithms for MCSPs should also be difficult.