Code your first quantum circuit

Learn to code your first quantum circuit in Quantum Lab, without downloading anything to your computer. While you can benefit from having some familiarity with Python and linear algebra, you can get a sense of the big picture without those prerequisites.

Note

If you already have some familiarity with Python or Jupyter notebooks, try the getting-started notebook instead.

Overview

Quantum circuits are the foundation of quantum computing. They are made up of quantum gates. When you run a quantum circuit, the gates manipulate qubits in the quantum computer.

To code any quantum circuit in Quantum Lab, you follow three high-level steps:

  1. Build: Design a quantum circuit that represents the problem you are considering.

  2. Execute: Run a circuits on a backend, either a system or a simulator.

  3. Analyze: Calculate summary statistics and visualize the results of your circuit jobs.

The following instructions guide you through building a circuit with example code in a Jupyter Notebook environment, executing your program, and analyzing the results.

Before you begin: Create a new notebook in Quantum Lab

  1. Go to IBM Quantum Lab and sign in.

  2. Click New Notebook +. The first cell in your new notebook imports Qiskit into your Jupyter Notebook environment.

Imported packages and functions

These lines are added to every new notebook in IBM Quantum Lab. Do not add them to your notebook.

The import lines import the basic elements (packages and functions) needed for your program. The following imports are the default imports for any new notebook in Quantum Lab, so they do not appear as a code snippet.

%matplotlib inline
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from iqx import CircuitVisualizer
# Loading your IBM Q account(s)
provider = IBMQ.load_account()

The imports used are:

  • QuantumCircuit: Holds all your quantum operations; the instructions for the quantum system

  • execute: Runs your circuit

  • Aer: Handles simulator backends

  • qiskit.visualization: Enables data visualization, such as plot_histogram

  • CircuitVisualizer: (Not imported by default) Enables circuit visualization that looks like Quantum Composer

Each code cell in the notebook must be run sequentially, starting with the first cell that imports Qiskit. To run a cell in a notebook, click Run or press Shift + Enter/Return.

Build a circuit

Copy this code into an empty cell in your notebook, then run it:

# Build
#------

# 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)

# Map the quantum measurement to the classical bits
circuit.measure([0,1], [0,1])

# END
Explanation

First, initialize two qubits in the zero state and two classical bits in the zero state in the quantum circuit called circuit:

circuit = QuantumCircuit(2, 2)

Next, add gates that manipulate the qubits in your circuit to form a Bell state:

|\psi\rangle = \left(|00\rangle+|11\rangle\right)/\sqrt{2}.

In this state, there is a 50% chance of finding both qubits to have the value 0 and a 50% chance of finding both qubits to have the value 1.

Gates:

  • QuantumCircuit.h(0): A Hadamard gate (H) on qubit 0, which puts it into a superposition state.

  • QuantumCircuit.cx(0, 1): A controlled-NOT operation (CX) on control qubit 0 and target qubit 1, putting the qubits in an entangled state.

  • QuantumCircuit.measure([0,1], [0,1]): The first argument indexes the qubits; the second argument indexes the classical bits. The nth qubit’s measurement result will be stored in the nth classical bit.

circuit.h(0)
circuit.cx(0, 1)
circuit.measure([0,1], [0,1])

Execute the experiment

Copy this code into an empty cell in your notebook, then run it:

# Execute
#--------

# Use Aer's qasm_simulator
simulator = Aer.get_backend('qasm_simulator')

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

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

# Return counts
counts = result.get_counts(circuit)
print("\nTotal count for 00 and 11 are:",counts)

# END
Explanation

You can run the experiment on either physical quantum systems or simulators. For this tutorial we are using a simulator, which is faster and uses fewer compute resources. Because of this, users will often verify their experiment on a simulator before sending it to an actual quantum system.

The following code calls Qiskit Aer, a high-performance simulator that provides several backends to achieve different simulation goals. In this tutorial, we use the qasm_simulator. Each run of this circuit will yield either the bit string '00' or '11'.

The shots argument specifies how many times to run the circuit. The default number of shots is 1024.

simulator = Aer.get_backend('qasm_simulator')
job = execute(circuit, simulator, shots=1000)

Once you have a result object, you can access the counts via the method get_counts(circuit). This gives you the aggregate outcomes of your experiment.

As expected, the output bit string is '00' approximately 50 percent of the time. This simulator does not model noise. Any deviation from 50 percent is due to the small sample size.

result = job.result()
counts = result.get_counts(circuit)
print("\nTotal count for 00 and 11 are:",counts)

Analyze the experiment

3a. Visualize the circuit

Copy this code into an empty cell in your notebook, then run it:

# Visualize
#----------

# Import draw_circuit, then use it to draw the circuit
from ibm_quantum_widgets import draw_circuit
draw_circuit(circuit)

# Analyze
#--------

# Plot a histogram
plot_histogram(counts)

# END
Explanation

There are several different tools you can use to visualize a circuit in one of the various styles used in textbooks and research articles. The following visualizations use a single-shot statevector simulator.

In this circuit, the qubits are ordered with qubit zero at the top and qubit one below it. The circuit is read from left to right, representing the passage of time.

To visualize a circuit with the IBM Quantum Composer look and feel, use the draw_circuit function.

from ibm_quantum_widgets import draw_circuit
      draw_circuit(circuit)

Note: The following gates in Qiskit do not belong to qelib1.inc and are not supported by the CircuitComposer widget or draw_circuit function. - ms(theta, qubits) - r(theta, phi, qubit) - rcccx(control_qubit1, control_qubit2, control_qubit3, target_qubit) - ryy(theta, qubit1, qubit2) - rzx(self, theta, qubit1, qubit2) - iswap(self, qubit1, qubit2) - mcu1(self, lam, control_qubits, target_qubit) - dcx(self, qubit1, qubit2)

To visualize a circuit that uses one of these gates, use QuantumCircuit.draw() by calling circuit.draw() instead.

circuit.draw()

3b. Plot a histogram

Copy this code into an empty cell in your notebook, then run it:

 # Plot a histogram
 plot_histogram(counts)

# END
Explanation

Qiskit provides many visualizations, including the function plot_histogram, to view your results.

plot_histogram(counts)

The probabilities (relative frequencies) of observing the |00\rangle and |11\rangle states are computed by taking the respective counts and dividing by the total number of shots.

Next steps

Now that you have learned the basics, return to the Quantum Lab landing page and create your own notebooks with cloud-based access to Qiskit, or explore the Qiskit tutorials in Quantum Lab, starting with the introductory notebook.

You can also continue your quantum journey with the Qiskit textbook, Learn Quantum Computation using Qiskit.