# Improve Quantum Volume via compilation¶

This notebook demonstrates some compiler features that were introduced in [1] (see below). This includes dynamical decoupling, mapping via binary integer programming, and pulse-efficient SU(4) decomposition. These techniques are applicable to improving the fidelity of any circuit. Here we demonstrate their utility in Quantum Volume calculations on an IBM superconducting device.

A custom passmanager has been built for this purpose, to invoke these passes. You can view the code in qv_tools.py.

Essential to this demonstration is faster CNOT gates and improved readout, as also detailed in the paper.

[1] Jurcevic, Petar, Ali Javadi-Abhari, Lev S. Bishop, Isaac Lauer, Daniela F. Bogorin, Markus Brink, Lauren Capelluto et al. “Demonstration of quantum volume 64 on a superconducting quantum computing system.” Quantum Science and Technology 6, no. 2 (2021): 025020.

## I. Identify the device and region on which to measure volume¶

```
# choose a provider and backend you have access to
from qiskit import IBMQ
IBMQ.load_account()
provider = IBMQ.providers()[5]
backend = provider.backend.ibm_hanoi
```

```
from qiskit.transpiler import InstructionDurations, CouplingMap
qubit_subset = [1, 2, 3, 5, 8, 11]
coupling_map = CouplingMap(backend.configuration().coupling_map)
basis_gates = backend.configuration().basis_gates
dt = backend.configuration().dt
instruction_durations = InstructionDurations.from_backend(backend)
```

## II. Load pre-mapped circuits¶

If you do not have access to a full CPLEX license or if you want to
speed up the compilation process, you can load pre-mapped circuits and
set `do_mapping=False`

below. If you are using the same qubit
connecitivity topology, this can be a good way to skip the CPLEX
optimization part of compilation, since the mapping problem is dependent
only on the topology. Setting `do_mapping=True`

will do the entire
compilation flow in Qiskit.

```
do_mapping = False
```

```
from qiskit.circuit import qpy_serialization
with open('qv64_original.qpy', 'rb') as f:
model_circuits = qpy_serialization.load(f)
with open('qv64_bip_line_approx99.qpy', 'rb') as f:
model_circuits_mapped = qpy_serialization.load(f)
```

## III. Build a custom passmanager that will do the desired circuit mapping and optimizations¶

```
from qv_tools import qv_passmanager
pm = qv_passmanager(basis_gates=basis_gates,
coupling_map=coupling_map,
qubit_subset=qubit_subset,
backend_props=backend.properties(),
instruction_durations=instruction_durations,
synthesis_fidelity=.99,
pulse_optimize=True)
```

```
# optional: visualize the passmanager to see the passes invoked
pm.draw()
```

## IV. Demonstrate compilation on a single model circuit¶

```
from qiskit.circuit.library import QuantumVolume
num_qubits = 6
model_circuit = QuantumVolume(num_qubits=num_qubits, seed=15).decompose()
model_circuit.draw('mpl', fold=-1)
```

```
model_circuit_measured = model_circuit.measure_all(inplace=False)
model_circuit_compiled = pm.run(model_circuit_measured)
print(f"num cx: {model_circuit_compiled.count_ops().get('cx', 0)}")
print(f"num sx: {model_circuit_compiled.count_ops().get('sx', 0)}")
print(f"num x: {model_circuit_compiled.count_ops().get('x', 0)}")
print(f"depth: {model_circuit_compiled.depth()}")
print(f"duration: {model_circuit_compiled.duration * dt * 1e6} us")
```

```
# optional: visualize the compiled circuit
model_circuit_compiled.draw('mpl', fold=-1, idle_wires=False)
```

```
# optional: visualize the first 10,000 dt's of events on a timeline
from qiskit.visualization import timeline_drawer
timeline_drawer(model_circuit_compiled, time_range=(0, 10000), show_idle=False)
```

## V. Compile 500 model circuits and plot distribution of resources¶

```
from tqdm import tqdm
model_circuits = [QuantumVolume(num_qubits, seed=i).decompose() for i in range(500)]
model_circuits_measured = [circuit.measure_all(inplace=False) for circuit in model_circuits]
model_circuits_compiled = []
for circuit in tqdm(model_circuits_measured):
model_circuits_compiled.append(pm.run(circuit))
```

```
from qv_tools import plot_resources
plot_resources(model_circuits_compiled, dt)
```

## VI. Run experiments and compute HOPs¶

```
from qiskit.providers.aer import AerSimulator
from qiskit.providers.aer.noise import NoiseModel
fake_backend = AerSimulator()
```

```
shots = 2000
job_exp = backend.run(model_circuits_compiled, shots=shots, rep_delay=0.0005)
job_sim = fake_backend.run(model_circuits_compiled, shots=shots)
```

```
# optional: inquire about job status
print('status: ', job_exp.status())
print('queue position: ', job_exp.queue_position())
print('job id: ', job_exp.job_id())
```

```
from qv_tools import get_ideal_probabilities, get_heavy_strings, hop
hops_exp = []
hops_sim = []
for model_circuit in model_circuits:
ideal_probs = get_ideal_probabilities(model_circuit)
median, heavy_strings = get_heavy_strings(ideal_probs)
counts_exp = job_exp.result().get_counts(model_circuit)
counts_sim = job_sim.result().get_counts(model_circuit)
hops_exp.append(hop(counts_exp, ideal_probs))
hops_sim.append(hop(counts_sim, ideal_probs))
```

```
from qv_tools import plot_hop_accumulative
plot_hop_accumulative(hops_exp)
```

This notebook has been written in a self-contained way, in order to
demonstrate the capabilities of the compiler and the faster gates. The
`qiskit-experiments`

framework includes more bells and whistles for
running quantum volume experiments, as well as other experiments.

```
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
```