Building Quantum Circuits with Qiskit

1. The Anatomy of a Quantum Circuit in Qiskit

The fundamental object for building circuits in Qiskit is the QuantumCircuit class. Think of it as the canvas on which you'll place your qubits and gates.

To get started, you need to import this class from the qiskit library and create an instance of it. When creating a circuit, you specify the number of quantum bits (qubits) and, optionally, the number of classical bits you need. Classical bits are necessary to store the results of measurements, a topic we'll dive into in the next lesson.

# Import the QuantumCircuit class
from qiskit import QuantumCircuit




# Create a quantum circuit with 2 qubits and 2 classical bits
qc = QuantumCircuit(2, 2)

The video below gives a quick demonstration of creating a QuantumCircuit object.

Once you have your QuantumCircuit object, you can visualize it using the .draw() method.

# Draw the empty circuit
qc.draw("mpl") 

This will produce a diagram showing your qubits (labeled q0, q1, etc.) and classical bits (labeled c0, c1, etc.) as horizontal wires. By default, all qubits are initialized in the $|0⟩$ state.

2. Applying Single-Qubit Gates

With our circuit canvas ready, we can start adding gates. In Qiskit, gates are methods of the QuantumCircuit object. You call the method corresponding to the gate you want and specify the index of the qubit to apply it to. Remember that qubit indexing starts at 0.

Let's apply some of the fundamental single-qubit gates we covered in Module 2.

As you can see from the reading, the syntax is very intuitive:

• X gate (NOT): qc.x(qubit_index)
• Hadamard gate: qc.h(qubit_index)
• Z gate: qc.z(qubit_index)
• S and T phase gates: qc.s(qubit_index) and qc.t(qubit_index)

3. Applying Multi-Qubit Gates

Multi-qubit gates are just as easy to apply. The most important two-qubit gate is the Controlled-NOT (CNOT or CX) gate. Its application method requires two arguments: the control qubit index and the target qubit index.

The CNOT gate acts like a conditional switch: if the control qubit is in the state $|1⟩$, it applies an X gate (a "NOT") to the target qubit. If the control is $|0⟩$, it does nothing.

Other common multi-qubit gates you might encounter include:

• SWAP gate: qc.swap(qubit1, qubit2)
• Toffoli gate (CCX): qc.ccx(control1, control2, target)

4. Constructing a Bell State

Now, let's combine a single-qubit gate and a multi-qubit gate to create one of the most important states in quantum computing: a Bell state. This state is the simplest example of quantum entanglement.

To create the Bell state $|{\Phi }^{+}⟩=\frac{1}{\sqrt{2}}(|00⟩+|11⟩)$, we follow a simple two-step recipe:

1. Start with two qubits in the $|00⟩$ state.
2. Apply a Hadamard gate to the first qubit (q0).
3. Apply a CNOT gate with the first qubit (q0) as control and the second qubit (q1) as target.

The following video walks through this exact process.

Here is the complete code to build and draw the Bell state circuit:

# Create a 2-qubit circuit
qc_bell = QuantumCircuit(2)




# 1. Apply Hadamard gate to q0
qc_bell.h(0)




# 2. Apply CNOT gate with q0 as control and q1 as target
qc_bell.cx(0, 1)




# Draw the circuit
qc_bell.draw("mpl")

The output will be a circuit diagram showing an H gate on the top wire followed by a CNOT gate connecting the top and bottom wires.

5. Scaling Up: The GHZ State

The principles you've just learned scale to any number of qubits. A great example is the Greenberger-Horne-Zeilinger (GHZ) state, which is an entangled state of three or more qubits. For three qubits, the state is $\frac{1}{\sqrt{2}}(|000⟩+|111⟩)$.

The recipe is a natural extension of the Bell state:

1. Apply a Hadamard gate to q0.
2. Apply a CNOT from q0 to q1.
3. Apply a CNOT from q0 to q2. (Or from q1 to q2 for a "ladder" structure).

In practice, we often write functions to generate circuits programmatically. The next video shows how to create a function that can build a GHZ circuit for any number of qubits. This is a powerful technique and a common practice in quantum programming.

6. Practice: Building a Quantum Half-Adder

To solidify your understanding, let's build a slightly more complex and practical circuit: a quantum half-adder. This circuit takes two input bits, A and B, and computes their sum (S) and a carry bit (C), just like in classical computing.

We will need four qubits:

• q0: Input A
• q1: Input B
• q2: Output Sum (S)
• q3: Output Carry (C)

The logic is as follows:

• Sum (S): S = A XOR B. This can be implemented with two CNOT gates: cx(A, S) and cx(B, S).
• Carry (C): C = A AND B. This is implemented with a Toffoli (CCX) gate: ccx(A, B, C).

Let's build it. Follow the code in the reading below.

This exercise demonstrates how to assemble a complete quantum circuit that performs a recognizable computational task, applying both single- and multi-qubit gates in a structured way.

Conclusion

In this lesson, you've taken your first major step into quantum programming. You've learned how to translate the abstract concept of a quantum circuit into concrete Qiskit code. This is the foundational skill upon which all quantum algorithms are built.

Key Takeaways:

• The QuantumCircuit class is the canvas for building quantum circuits.
• You create a circuit by instantiating this class, specifying the number of qubits and classical bits.
• Single-qubit gates are applied using methods like qc.h(qubit_index) and qc.x(qubit_index).
• Multi-qubit gates, like CNOT, are applied with methods like qc.cx(control, target).
• You can combine these gates to construct meaningful circuits, such as those for generating Bell and GHZ states, or even for performing simple arithmetic like a half-adder.
• The .draw("mpl") method provides an essential visualization of your circuit's structure.

Preview of the Next Lesson:
You can now build quantum circuits, but what do they do? A circuit diagram is just a plan. The next step is to execute that plan and see the result. In our next lesson, you will learn how to use Qiskit's Aer simulator to run your circuits and find out the quantum state they produce.