How to run an approximate simulation, and why

Question

I'm looking at the Qiskit getting started documentation, https://qiskit.org/documentation/getting_started.html. They create a quantum circuit and run an approximate simulation on it 1000 times:

1. Why bother with an approximate solution when you can get an exact solution? In this case, you can simulate everything with matrices and get this result: $$ \begin{bmatrix}{1 \over {\sqrt 2}} \\ 0 \\ 0 \\ {1 \over {\sqrt 2}}\end{bmatrix} $$

From this you know the exact probabilities of each output: 00 occurs $1 \over 2$ the time, 11 occurs $1 \over 2$ the time. Is an exact simulator available in Qiskit?

2. How does an approximate simulator work? For instance, after passing through the Hadamard gate, we have the qubit

$$ \begin{bmatrix} {1 \over {\sqrt 2}} \\ {1 \over {\sqrt 2}} \end{bmatrix} $$

At that point, does the simulator immediately collapse the qubit to $|0\rangle$ or $|1\rangle$ to avoid potential superpositions? Or would that not be sufficient, and an approximate simulator is more complicated?

Answer 1

Why bother with an approximate solution when you can get an exact solution?

The reason to have an 'approximate' simulation rather than an exact simulation (and result) is that it more closely resembles our understanding of and interaction with a real quantum computer.

In a real quantum computer, the state of the qubits before measurement is indeed the exact superposition, but retrieving information from this system will always be done through measurements, and those measurements cannot give the full system state - they will only give one bit of information per measurement. Repeated experiments + measurements then allows us to approximate the exact state we believe the system to be in.

Is an exact simulator available in Qiskit?

Qiskit can indeed handle exact simulations - there is the 'statevector_simulator' which will do this; you can retrieve it with aer.get_backend('statevector_simulator'). Note that this does not allow for density matrix simulations, so the methods to simulate noise and error are severely limited. The statevector can then be retrieved from the results object using the .get_statevector() method. See also this webpage from IBM/qiskit.

How does an approximate simulator work?

The simulations do not collapse the superpositions before the actual measurements - if the superpositions were collapsed in an intermediary state of the circuit, there can be no simulations of all things that make a quantum computer 'quantum' - entanglement, interference etc.

For simplicity, if we assume the measurement to take place at the very end of the circuit, just before the measurement the entire state of the system is known (which would be a $2^{n} \times 2^{n}$ density matrix; however you can use various insights and tricks to reduce the memory usage. It will always be exponential though.)

A measurement is then a random draw from the distribution of possible measurement outcomes, weighted to their probabilities. For a statevector, this is of course the $|\alpha|$'s and $|\beta|$'s. For density matrices, it is a bit more intricate as you use projection matrices.

Answer 2

Here's how you can use statevector_simulator to get an exact answer:

import numpy as np
from qiskit import QuantumCircuit, execute, Aer
from qiskit.visualization import plot_histogram

# Use Aer's statevector_simulator
simulator = Aer.get_backend("statevector_simulator")

# Create a Quantum Circuit acting on the q register
circuit = QuantumCircuit(2, 2)

# Add a H gate on qubit 0
circuit.h(0)

# Add a CX (CNOT) gate on control qubit 0 and target qubit 1
circuit.cx(0, 1)

# Execute the circuit on the qasm simulator
job = execute(circuit, simulator)

# Grab results from the job
result = job.result()

out_state = result.get_statevector()
print([abs(q ** 2) for q in out_state])

Running this prints:

[0.5000000000000001, 0.0, 0.0, 0.4999999999999999]

So 00 occurred 50% of the time, and 11 occurred 50% of the time. The minor error is due to floating point rounding.