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

**Build**: Design a quantum circuit that represents the problem you are considering.**Execute**: Run a circuits on a backend, either a system or a simulator.**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¶

Go to IBM Quantum Lab and sign in.

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:

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 n^{th}qubit’s measurement result will be stored in the n^{th}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 and 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.