Quantum Volume Estimation

Quantum Volume (QV) is a single-number metric that can be measured using a concrete protocol on near-term quantum computers of modest size. The QV method quantifies the largest random circuit of equal width and depth that the computer successfully implements. The quantum volume protocol is strongly related to gate error rate and is influenced by underlying qubit connectivity and gate parallelism. This protocol is based on the performance of random model circuits with a fixed but generic form.

Tags: Certification protocol, Quantum Volume estimation protocol

Assumptions

The transpiler is free to use all available tricks and hardware resources to implement the model circuit.
The transpiler should make an honest attempt to implement the model circuit, and not merely choose a relatively simple operation far from the model circuit that nevertheless produces the heavy outputs for it.

Outline

The quantum volume protocol is strongly related to gate error rate and is influenced by underlying qubit connectivity and gate parallelism. This protocol is based on the performance of random model circuits with a fixed but generic form.

A model circuit is consists of $d$ layers of random permutations of the $m$ different qubit labels, followed by random two-qubit gates. When the circuit width m is odd, one of the qubits is idle in each layer. Each two-qubit gate used in the previous step is sampled from the Haar measure on SU(4).

Heavy output generation problem is used to define if the model circuit mentioned above is fully implemented in practice. From the outputs of all the implementations of the model circuit, we get an ideal output distribution. From this, we get the set of output probabilities and we can obtain the median of this set. The heavy outputs are the outputs for which the output probability will be greater than the median of the set of probabilities. The heavy output generation problem is to produce a set of output strings such that more than two-thirds are heavy.

To evaluate heavy output generation, we implement model circuits using the gate set provided by the target system, using the available hardware. For this purpose, a quantum circuit-to-circuit transpiler is used, which finds an implementation of the model circuit, where the approximation error.

This method to compute the quantum volume of a device consists of the following steps:

The Quantum transpiler tries to implement the model circuit such that the approximation error is limited. From here, we get the distribution for the implementation of the model circuit, which we use to calculate the probability of sampling a heavy output.
The heavy outputs are also computed using the ideal output distribution of the model circuit.
The probability of observing a heavy output by implementing a randomly selected depth $d$ model circuit is also computed using the probability of sampling a heavy output computed in the step above.
We define the achievable depth $d(m)$ to be the largest $d$ such that we are confident that the probability of observing a heavy output is greater than $2/3$ (as the heavy output generation problem is to produce a set of output strings such that more than two-thirds are heavy.)
The data of achievable depth is gathered by sweeping over values of width $m$ and depth $d$ of the model circuit.
Using all the data gathered, the quantum volume is computed. The quantum volume treats the width and depth of a model circuit with equal importance and measures the largest square shaped (i.e., $m=d$ ) model circuit a quantum computer can implement successfully on average.

Notation

$U$ : Model circuit
$U'$ : Implementation of the model circuit by the quantum transpiler
$m$ : width of the model circuit
$d$ : depth of the model circuit
$F_{avg}(U,U')$ : Average fidelity between $U$ and $U'$
$\epsilon$ : approximation error
$d(m)$ : Achievable depth, which is the largest $d$ such that we are confident that the probability of observing a heavy output is greater than $2/3$
$V_{Q}$ : Quantum Volume
$H_{U}$ : Set of heavy outputs for a model circuit $U$
$x$ : Outcome of executing $U'$ , which is a observable bit string, $x\in \{0,1\}^{m}$
$p_{U}(x)$ : Ideal output distribution for $U$ . $p_{U}(x)=|\langle x|U|0\rangle |^{2}$
$p_{med}$ : median of the set of probabilities
$n_{c}$ : Number of repetitions, $n_{c}>100$
$n_{s}$ : Number of repetitions

Hardware Requirements

Quantum Computing device with a gate set
Measurement device

Properties

Figure of merit: Quantum Volume
Quantum computing systems with high-fidelity operations, high connectivity, large calibrated gate sets, and circuit rewriting tool chains are expected to have higher quantum volumes
The protocol can be implemented with any universal programmable quantum computing device. Quantum volume is architecture-independent, and can be applied to any system that is capable of running quantum circuits.
The method used to compute the heavy outputs from the ideal output distribution of the model circuit scales exponentially with the width $m$ .
Ideally, the probability of observing a heavy output would be estimated using all of the qubits of a large device, but NISQ devices have appreciable error rates, so we begin with small model circuits and progress to larger ones.
The quantum volume treats the width and depth of a model circuit with equal importance and measures the largest square shaped (i.e., $m=d$ ) model circuit a quantum computer can implement successfully on average.
Given a model circuit $U$ , a circuit-to-circuit transpiler finds an implementation $U'$ for the target system such that $1-F_{avg}(U,U')\leq \epsilon \ll 1$

Protocol Description

Function: ComputeHeavyOutputs $(U,m)$

Input: $U,m$

Output: $H_{U}$

Obtain $p_{U}(x)$ for $x\in \{0,1\}^{m}$
Sort in ascending order $p_{0}\leq p_{1}...\leq p_{2^{m}-1}$
$p_{med}=(p_{2^{m-1}}+p_{2^{m-1}-1})/2$
$H_{U}=\{x\in \{0,1\}^{m}$ such that $p_{U}(x)>p_{med}\}$

Function: ComputeQuantumVolume

Output: Figure of merit: Quantum Volume, $V_{Q}$

For $i=1,2,...,m$ $i=1,2,...,m$ :
- For $j=1,2,...,d$ $j=1,2,...,d$ :
  - $d(m)=0$
  - $n_{h}=0$
  - For $k=1,2,...,n_{c}$ $k=1,2,...,n_{c}$ :
    - Pick random model circuit $U$
    - $H_{U}=$ ComputeHeavyOutputs $(U,m)$
    - Compile $U'$
    - For $l=1,2,...,n_{s}$ $l=1,2,...,n_{s}$ :
      - Get output $x$
      - If $x\in H_{U}$ then $n_{h}=n_{h}+1$
  - If ${\frac {n_{h}-2{\sqrt {n_{h}(n_{s}-n_{h}/n_{c})}}}{n_{c}n_{S}}}>{\frac {2}{3}}$ ${\frac {n_{h}-2{\sqrt {n_{h}(n_{s}-n_{h}/n_{c})}}}{n_{c}n_{S}}}>{\frac {2}{3}}$
    - $d(m)=$ max $(d(m),d)$
    - Store data $(m,d(m))$
Calculate $V_{Q}$ from stored data, where log $_{2}V_{Q}$ = argmax $_{m}$ min $(m,d(m))$