First time studying this topic?

Launch the interactive walkthrough to discover each component, including the 3D Q-Sphere Lab & Python in Colab.

Topic 6.3

Quantum Gates: Unitary Operators & Linear Algebra

Understand the mathematical engine of quantum circuits: Unitary 2x2 and 4x4 complex matrices that rotate quantum states.

Learning Objectives

✓Define quantum gates as Unitary square matrices: U * U_dagger = I
✓Understand geometric rotations on the Bloch Sphere: R_x(theta), R_y(theta), R_z(theta)
✓Analyze why quantum logic must be strictly reversible

📖Let's Begin with a Story

In classical computing, the universal building block is the NAND gate. If you plug in two 1s, it outputs 0. If you plug in 0 and 1, it outputs 1. Notice something crucial: two bits enter, but only one bit exits! The other bit was destroyed and vanished as thermal heat. You cannot run a NAND gate backwards: if you see an output of 1, you have no way of knowing whether the input was (0,0), (0,1), or (1,0). Quantum gates are fundamentally different. By the laws of quantum mechanics, information can never be destroyed. Every quantum gate is a reversible geometric rotation in a multi-dimensional sphere. If you rotate an apple 90 degrees clockwise, you can always rotate it 90 degrees counter-clockwise to put it back exactly as it was. That is why all quantum gates are unitary matrices!

Why Should You Learn Quantum Gates: Unitary Operators & Linear Algebra?

🎯 Practical & Engineering Stakes

The core algebra of quantum computing

Every quantum program you will ever write is simply a sequence of unitary matrix multiplications. Mastering their matrix properties unlocks complete fluency in quantum programming.

What Is It?

Simple Explanation

Classical gates are one-way streets (information gets crushed). Quantum gates are two-way roundabouts: - Every gate is a smooth, elegant rotation of the qubit's arrow on the Bloch sphere. - Because it’s a rotation, you can always run it in reverse to undo it. - A single-qubit gate is a 2x2 matrix of numbers. - A two-qubit gate is a 4x4 matrix of numbers.

Technical Explanation

A quantum gate acting on

n

qubits is represented by a unitary matrix

U \in U(2^n)

satisfying

U^\dagger U = U U^\dagger = I_{2^n}

, where

U^\dagger = (U^*)^T

is the conjugate transpose. Unitary matrices preserve inner products

\langle U\phi | U\psi \rangle = \langle \phi | \psi \rangle

, guarantee that probabilities sum to 1, and possess eigenvalues of unit modulus

\lambda = e^{i\theta}

📚 Key Terms

Unitary Matrix

Simple: A square grid of numbers whose reverse is its complex conjugate transpose (U * U_dagger = I).

Technical: A bounded linear operator on complex Hilbert space whose adjoint equals its inverse:

U^\dagger = U^{-1}

Conjugate Transpose ( $U^\dagger$ )

Simple: Flipping rows and columns and changing the sign of all imaginary numbers (i becomes -i).

Technical: The Hermitian adjoint operator

(U^\dagger)_{ij} = \overline{U_{ji}}

$Trace$

Simple: The sum of numbers along the main diagonal of a square matrix.

Technical: The invariant sum of diagonal elements

\text{Tr}(A) = \sum A_{ii}

equal to the sum of eigenvalues.

Q-Sphere Lab: Quantum Gates: Unitary Operators & Linear Algebra

IBM Q-Sphere Model

Interactive 3D state vector exploration, unitary transformation gates, and Born rule collapse for Topic 6.3

Azimuth: 45°Elevation: 25°(Click & drag sphere to orbit)

Q-Sphere Phase Color:

0 π/2 π 3π/2

Quantum Statevector

dim(H) = 2

|ψ⟩ = (1.000 + 0.000i)|0⟩
+ (0.000 + 0.000i)|1⟩

Polar Angle (θ):0.0° (0.000π rad)

Phase Angle (ϕ):0.0° (0.000π rad)

Born Rule Probabilities: P(x) = |⟨x|ψ⟩|²Σ P = 1.00

P(|0⟩) = |α|²100.0%

P(|1⟩) = |β|²0.0%

Quantum Measurement

Apply Single-Qubit Unitary Gates

Presets:

Continuous Polar Angle θ (0° = |0⟩, 180° = |1⟩):0.0°

Continuous Phase Angle ϕ (0° to 360°):0.0°

Recent Operations Log:

#1Initial state: |0⟩

📐 Mathematical Foundation

LaTeX KaTeX

U = \begin{pmatrix} u_{00} & u_{01} \\ u_{10} & u_{11} \end{pmatrix}, \quad U^\dagger = \begin{pmatrix} u_{00}^* & u_{10}^* \\ u_{01}^* & u_{11}^* \end{pmatrix}, \quad U U^\dagger = U^\dagger U = \begin{pmatrix} 1 & 0 \\ 0 & 1 \end{pmatrix} = I

What does it mean?

Unitary Condition for Quantum Gates: Unlike classical gates that destroy information (like AND or OR), all quantum gates are reversible unitary transformations. Multiplying gate U by its conjugate transpose U† yields the Identity matrix I, preserving state vector length and total probability with zero information loss.

Understanding the Symbols

Symbol / Term	Meaning	Beginner Interpretation
$U$	Unitary quantum gate matrix	A $2 \times 2$ complex matrix that rotates the quantum state vector
$U^\dagger$	Hermitian adjoint (dagger)	Transpose rows and columns, then take complex conjugate (i → -i)
$U U^\dagger = I$	Unitarity condition	Guarantee that the operation is 100% reversible with zero information loss
$I = [[1, 0], [0, 1]]$	Identity matrix	The do-nothing base matrix that leaves state vectors unchanged

📊 Numerical Example

Testing the unitarity of the Phase Gate S = [[1, 0], [0, i]]:

Step 1: Write S matrix: S = [[1, 0], [0, i]] Step 2: Compute S† (transpose and conjugate i → -i): S† = [[1, 0], [0, -i]] Step 3: Multiply S × S†: S × S† = [[1×1 + 0×0, 1×0 + 0×(-i)], [0×1 + i×0, 0×0 + i×(-i)]] = [[1, 0], [0, -i^2]] Recall i^2 = -1, so -i^2 = -(-1) = 1: = [[1, 0], [0, 1]] = I ✓

Result: The S gate satisfies S S† = I, confirming it is a mathematically valid reversible quantum gate.

⚙️ How Does It Work?

Matrix-Vector Product

Apply gate U to input state vector |psi>: |psi'> = U * |psi>.

Norm Preservation

Verify that length of output vector remains strictly equal to 1.0.

Inversion

To undo the gate, apply U_dagger: U_dagger * |psi'> = |psi>.

🌍 Where Is It Used?

Quantum Circuit Compilation (Qiskit Transpiler)

Problem: Physical quantum computers only support 2 or 3 native microwave pulses.

Solution: The transpiler decomposes arbitrary high-level unitary matrices into equivalent products of physical hardware basis gates.

🎯 Try It Yourself

Why MUST all quantum gates be represented by Unitary matrices?

Interactive activity component

🐍 Python Hands-On: Exploring Single-Qubit Unitary Matrices in Qiskit

Construct single-qubit quantum gates (X, Y, Z, H, S, T) in Qiskit and compute their exact 2x2 complex unitary matrices.

Open Colab

1Install Required Packages

For Google Colab or Jupyter notebooks, run this shell command to install the required dependencies:

Terminal / Notebook Install Commandbash

!pip install qiskit numpy

Packages:

qiskitnumpy

2Import Libraries

Import Statementspython

1 from qiskit import QuantumCircuit
2 from qiskit.quantum_info import Operator
3 import numpy as np

from qiskit import QuantumCircuit → Circuit module

from qiskit.quantum_info import Operator → Operator matrix extractor

import numpy as np → NumPy for formatting

3Demonstration Code & Logic

Python Execution Codepython

1 gate_names = ['X (NOT)', 'Y', 'Z (Phase)', 'H (Hadamard)', 'S (pi/2)', 'T (pi/4)']
2 print('=== Fundamental Single-Qubit Gate Matrices in Qiskit ===\n')
3 for name in gate_names:
4     qc = QuantumCircuit(1)
5     if 'X' in name: qc.x(0)
6     elif 'Y' in name: qc.y(0)
7     elif 'Z' in name: qc.z(0)
8     elif 'H' in name: qc.h(0)
9     elif 'S' in name: qc.s(0)
10     elif 'T' in name: qc.t(0)
11     matrix = Operator(qc).data
12     print(f'{name} Unitary Matrix:')
13     print(np.round(matrix, 3))
14     print()

Step-by-Step Code Breakdown:

gate_names = ['X (NOT)', 'Y', 'Z (Phase)', 'H (Hadamard)', 'S (pi/2)', 'T (pi/4)']

List of gates

print('=== Fundamental Single-Qubit Gate Matrices in Qiskit ===\n')

Header

for name in gate_names:

Loop gates

qc = QuantumCircuit(1)

Create 1-qubit circuit

if 'X' in name: qc.x(0)

Apply X

elif 'Y' in name: qc.y(0)

Apply Y

elif 'Z' in name: qc.z(0)

Apply Z

elif 'H' in name: qc.h(0)

Apply H

elif 'S' in name: qc.s(0)

Apply S

elif 'T' in name: qc.t(0)

Apply T

matrix = Operator(qc).data

Extract matrix

print(f'{name} Unitary Matrix:')

Print name

print(np.round(matrix, 3))

Print rounded matrix

print()

Spacing

📋 Complete Script (All-in-One)

Click "Copy for Colab", open Google Colab, paste into a single cell, and run.

Google Colab Notebook Scriptpython

1 # =========================================================
2 # Exploring Single-Qubit Unitary Matrices in Qiskit
3 # Prepared for Google Colab (Run with Shift + Enter)
4 # =========================================================
5  
6 # Step 1: Install required packages
7 !pip install qiskit numpy
8  
9 # Step 2: Import libraries
10 from qiskit import QuantumCircuit
11 from qiskit.quantum_info import Operator
12 import numpy as np
13  
14 # Step 3: Run Demonstration
15 gate_names = ['X (NOT)', 'Y', 'Z (Phase)', 'H (Hadamard)', 'S (pi/2)', 'T (pi/4)']
16 print('=== Fundamental Single-Qubit Gate Matrices in Qiskit ===\n')
17 for name in gate_names:
18     qc = QuantumCircuit(1)
19     if 'X' in name: qc.x(0)
20     elif 'Y' in name: qc.y(0)
21     elif 'Z' in name: qc.z(0)
22     elif 'H' in name: qc.h(0)
23     elif 'S' in name: qc.s(0)
24     elif 'T' in name: qc.t(0)
25     matrix = Operator(qc).data
26     print(f'{name} Unitary Matrix:')
27     print(np.round(matrix, 3))
28     print()

⚡ How to Run in Google Colab (3 Quick Steps)

Click "Copy for Google Colab" above.
Click Open New Google Colab Notebook (opens in a new tab).
Click on the first empty code cell, press Ctrl + V (or Cmd + V) to paste, then press Shift + Enter to execute!

Launch Blank Colab Notebook

🔄 Algorithmic Execution Flow

Instantiate Circuits

Create circuits applying individual single-qubit gates.

→

Extract Unitaries

Use Qiskit Operator to compute the exact 2x2 complex matrix representation.

→

Inspect Transformations

Display matrices demonstrating rotational actions on the Bloch sphere.

📥 Input / Initial State

Single-qubit circuits with X, Y, Z, H, S, and T gates.

📤 Expected Output

2x2 unitary matrices for each gate:
X: [[0, 1], [1, 0]]
Z: [[1, 0], [0, -1]]
H: [[0.707, 0.707], [0.707, -0.707]]
S: [[1, 0], [0, 1j]]

💡 What Does This Demonstration Show?

Every single-qubit gate corresponds to a 2x2 complex unitary matrix that preserves vector norms, rotating the state vector across the continuous Bloch sphere.

Course Learning Resource • Slide DeckLesson 810 Slides

Lesson 8: Two Qubits and Entanglement

Hadamard, CNOT, Bell-state intuition, and correlated quantum circuits.

Author: Dr. Syed Muzamil Basha• FDP Approved Curriculum

Open in New Tab

📝 Learning Check

Test your understanding with these questions. Remember, this is for learning, not examination!

Question 1: What is the matrix dimension of a quantum gate that acts on 2 qubits simultaneously (e.g. CNOT)?

Question 2: Why must all quantum gates be represented as unitary matrices?

Question 3: What is a universal gate set in quantum computing?

Question 4: What is the dimension of a single-qubit gate matrix?

Question 5: What property distinguishes quantum gates from classical logic gates?

Previous: Quantum Registers & Multi-Qubit State Vectors Next: The Pauli-X Gate: The Quantum NOT Gate

1	from qiskit import QuantumCircuit
2	from qiskit.quantum_info import Operator
3	import numpy as np

1	# =========================================================
2	# Exploring Single-Qubit Unitary Matrices in Qiskit
3	# Prepared for Google Colab (Run with Shift + Enter)
4	# =========================================================
5
6	# Step 1: Install required packages
7	!pip install qiskit numpy
8
9	# Step 2: Import libraries
10	from qiskit import QuantumCircuit
11	from qiskit.quantum_info import Operator
12	import numpy as np
13
14	# Step 3: Run Demonstration
15	gate_names = ['X (NOT)', 'Y', 'Z (Phase)', 'H (Hadamard)', 'S (pi/2)', 'T (pi/4)']
16	print('=== Fundamental Single-Qubit Gate Matrices in Qiskit ===\n')
17	for name in gate_names:
18	qc = QuantumCircuit(1)
19	if 'X' in name: qc.x(0)
20	elif 'Y' in name: qc.y(0)
21	elif 'Z' in name: qc.z(0)
22	elif 'H' in name: qc.h(0)
23	elif 'S' in name: qc.s(0)
24	elif 'T' in name: qc.t(0)
25	matrix = Operator(qc).data
26	print(f'{name} Unitary Matrix:')
27	print(np.round(matrix, 3))
28	print()