Welcome to the Quantum Jargon Decoder

Quantum computing, quantum information, and quantum cryptography are revolutionizing how we think about computation, communication, and security. But the field is drowning in jargon.

Qubits. Superposition. Entanglement. Decoherence. T1 times. Surface codes. NISQ. QKD.

If you’ve ever felt lost reading a quantum computing paper, tutorial, or press release, you’re not alone. This glossary exists to help you decode the quantum world.

Who is this for?

• Newcomers taking their first steps into quantum computing
• Software developers exploring quantum programming
• Researchers from adjacent fields entering the quantum space
• Students studying quantum information theory
• Anyone who wants to refresh their memory on a specific term
• Professionals trying to cut through the hype and understand what’s real

How to use this guide

Each term includes:

• A one-liner summary for quick reference
• A detailed explanation for deeper understanding
• Cross-references to related concepts
• Practical context on why the term matters

Start with the Introduction to Quantum Jargon if you’re completely new, or jump directly to any term that’s puzzling you.

A note on rigor

This is an informal glossary. We prioritize clarity and intuition over mathematical precision. When a concept requires deep mathematical treatment, we’ll point you to the right resources. The goal is to give you a working understanding, not to replace a textbook.

Contribute

Spot an error? Have a term to add? Think an explanation could be clearer? This is an open project and contributions are welcome. Every page has an “Edit” link that takes you directly to the source.

“The quantum world is strange, but the jargon doesn’t have to be.”

Time to decode it.

The Quantum Computing Stack

Before diving into individual terms, it helps to understand how quantum computing is organized. Like classical computing, quantum computing has “layers” or a “stack” that builds from physics up to applications.

The Layers

1. Physical Layer (The Hardware)

At the bottom is actual quantum hardware. This includes:

• Qubits: The physical quantum systems that store information (superconducting circuits, trapped ions, photons, etc.)
• Control systems: Lasers, microwave pulses, and electronics that manipulate qubits
• Cooling systems: Dilution refrigerators that keep superconducting qubits near absolute zero

Key terms: Superconducting Qubit, Trapped Ion, Photonic Qubit

2. Quantum Gate Layer

Above the physics, we have quantum operations:

• Gates: The quantum equivalent of logic gates (AND, OR, NOT in classical computing)
• Circuits: Sequences of gates that perform computations
• Measurement: Reading out the result of a computation

Key terms: Quantum Gate, Hadamard Gate, CNOT Gate, Quantum Circuit

3. Error Correction Layer

Quantum systems are noisy. This layer deals with that:

• Error detection: Finding when errors occur
• Error correction: Fixing errors without destroying quantum information
• Logical qubits: Error-protected qubits built from many physical qubits

Key terms: Quantum Error Correction, Surface Code, Logical Qubit, Fault Tolerance

4. Algorithm Layer

This is where computation happens:

• Quantum algorithms: Procedures that leverage quantum effects for computational advantage
• Variational methods: Hybrid quantum-classical approaches for near-term devices

Key terms: Shor’s Algorithm, Grover’s Algorithm, VQE, QAOA

5. Application Layer

At the top, real-world problems:

• Cryptography: Secure communication, key distribution
• Chemistry: Molecular simulation, drug discovery
• Optimization: Supply chain, finance, logistics
• Machine learning: Quantum-enhanced AI

Key terms: Quantum Key Distribution, Quantum Simulation, Quantum Machine Learning

Where Are We Today?

As of 2024-2025, we’re in the NISQ era (Noisy Intermediate-Scale Quantum). This means:

• We have quantum computers with 50-1000+ qubits
• These qubits are “noisy” (error-prone) and lack full error correction
• We’re exploring what useful tasks these imperfect machines can do
• Full fault-tolerant quantum computing is still years away

Key terms: NISQ, Quantum Advantage, Fault-Tolerant Quantum Computing

The Path Forward

Today: NISQ devices (noisy, limited)
       ↓
Next:  Early fault-tolerant systems (100s of logical qubits)
       ↓
Goal:  Large-scale fault-tolerant quantum computers (millions of qubits)

Understanding this stack helps contextualize every term you’ll encounter. When someone mentions “T1 times,” you know that’s about physical hardware. When they discuss “logical qubits,” that’s the error correction layer. When they’re excited about “quantum advantage,” that’s about the algorithm/application layers proving real value.

Next: From Classical to Quantum - Understanding what makes quantum different.

From Classical to Quantum

What makes quantum computing fundamentally different from classical computing? This section breaks down the core concepts that separate the two worlds.

Classical Bits vs. Quantum Bits

Classical Bit

A classical bit is simple: it’s either 0 or 1. Period.

Classical bit: 0  OR  1

Every computer you’ve ever used processes information this way. Billions of transistors switching between two states.

Quantum Bit (Qubit)

A qubit can be 0, 1, or both at the same time.

Qubit: α|0⟩ + β|1⟩

This “both at the same time” is called superposition. The numbers α and β are complex numbers called amplitudes that describe the probability of measuring 0 or 1.

Important: When you measure a qubit, you get a definite answer (0 or 1). The superposition “collapses.” You can’t peek at the superposition directly.

The Three Pillars of Quantum Computing

1. Superposition

A qubit in superposition isn’t undecided. It’s genuinely in multiple states simultaneously. This allows quantum computers to explore many possibilities at once.

$$|\psi ⟩=\frac{1}{\sqrt{2}}|0⟩+\frac{1}{\sqrt{2}}|1⟩$$

This qubit has equal probability of being measured as 0 or 1.

Why it matters: With $n$ qubits, you can represent $2^n$ states simultaneously. 50 qubits can represent more states than a classical supercomputer can track individually.

2. Entanglement

When qubits become entangled, their states become correlated in ways impossible classically. Measure one, and you instantly know something about the other, regardless of distance.

The most famous entangled state is the Bell state:

$$|{\Phi }^{+}⟩=\frac{1}{\sqrt{2}}(|00⟩+|11⟩)$$

Both qubits are in superposition, but they’re perfectly correlated: if you measure the first as 0, the second will also be 0. Measure 1, and the second is 1.

Why it matters: Entanglement is a resource for quantum computation and communication. It enables quantum teleportation, superdense coding, and is essential for quantum speedups.

3. Interference

Quantum states can interfere with each other, like waves in water. Amplitudes can add (constructive interference) or cancel (destructive interference).

Why it matters: Quantum algorithms are designed to make wrong answers interfere destructively and right answers interfere constructively. This is how you extract useful results from quantum computation.

How Quantum Computation Works

A quantum computation follows this pattern:

1. INITIALIZE: Prepare qubits in a known state (usually |0⟩)
2. SUPERPOSE: Put qubits into superposition (using Hadamard gates, etc.)
3. ENTANGLE: Create correlations between qubits (using CNOT gates, etc.)
4. COMPUTE: Apply quantum gates that cause interference
5. MEASURE: Read out the final answer

The art of quantum algorithm design is arranging steps 2-4 so that interference amplifies correct answers and suppresses wrong ones.

What Quantum Computers Are NOT

Common myths:

NOT exponentially parallel classical computers: You can’t just run all possible inputs simultaneously and read all outputs. Measurement gives you ONE result.

NOT instantaneous: Quantum operations take time, and quantum algorithms have complexity like classical ones.

NOT universally faster: Only specific problems have known quantum speedups. For many tasks, classical computers are just as good or better.

NOT breaking physics: Entanglement doesn’t enable faster-than-light communication. You need classical communication to use quantum correlations.

When Quantum Computers Help

Quantum computers excel at specific problem types:

*With caveats about input/output

Key Intuition

Think of quantum computing like this:

Classical computing is like reading a book page by page.

Quantum computing is like having a book where all pages exist in superposition, and through careful manipulation, you can make the page you’re looking for “pop out” with high probability.

The challenge? Designing that “careful manipulation.” Most of the pages you don’t want need to interfere destructively, while the answer constructively builds up. This is genuinely hard, which is why useful quantum algorithms are rare and precious.

Now you have the conceptual foundation. Head to the Acronyms for quick reference, or dive into specific definitions to explore further.

Acronyms

A list of common acronyms you’ll encounter in quantum computing, quantum information, and quantum cryptography.

B

• BB84: Bennett-Brassard 1984 (QKD protocol) - see BB84 Protocol

C

• CNOT: Controlled-NOT (gate) - see CNOT Gate
• CZ: Controlled-Z (gate)

E

• E91: Ekert 1991 (QKD protocol) - see E91 Protocol
• EPR: Einstein-Podolsky-Rosen (paradox/pair)

F

• FTQC: Fault-Tolerant Quantum Computing - see Fault-Tolerant Quantum Computing

G

• GHZ: Greenberger-Horne-Zeilinger (state)

N

• NISQ: Noisy Intermediate-Scale Quantum - see NISQ

P

• PQC:
  • Post-Quantum Cryptography - see Post-Quantum Cryptography
  • Parameterized Quantum Circuit - see Parameterized Quantum Circuit

Q

• QAOA: Quantum Approximate Optimization Algorithm - see QAOA
• QC: Quantum Computing/Computer
• QEC: Quantum Error Correction - see Quantum Error Correction
• QFT: Quantum Fourier Transform - see Quantum Fourier Transform
• QKD: Quantum Key Distribution - see Quantum Key Distribution
• QML: Quantum Machine Learning - see Quantum Machine Learning
• QNN: Quantum Neural Network - see Quantum Neural Network
• QPE: Quantum Phase Estimation - see Quantum Phase Estimation
• QPU: Quantum Processing Unit
• QRNG: Quantum Random Number Generator - see Quantum Random Number Generator

R

• RSA: Rivest-Shamir-Adleman (cryptosystem)

V

• VQA: Variational Quantum Algorithm - see Variational Quantum Algorithm
• VQE: Variational Quantum Eigensolver - see VQE

Common Notation

• |ψ⟩: Ket notation for a quantum state (pronounced “ket psi”)
• ⟨ψ|: Bra notation (pronounced “bra psi”)
• ⟨ψ|φ⟩: Inner product (pronounced “bra-ket” or “bracket”)
• |0⟩, |1⟩: Computational basis states
• |+⟩, |−⟩: Hadamard basis states, $|+⟩=\frac{1}{\sqrt{2}}(|0⟩+|1⟩)$
• ⊗: Tensor product (combining quantum systems)
• †: Dagger (Hermitian conjugate)
• I: Identity operator
• ρ: Density matrix
• H: Hadamard gate (or Hamiltonian, depending on context)
• X, Y, Z: Pauli matrices/gates
• T₁, T₂: Relaxation and dephasing times

Missing an acronym? Contribute to add it!

Qubit

The quantum analog of a classical bit, and the basic unit of quantum information.

A qubit (quantum bit) is a two-level quantum system that serves as the basic unit of information in quantum computing. Unlike a classical bit, which is definitively 0 or 1, a qubit can exist in a superposition of both states simultaneously.

Mathematical Description

A qubit’s state is described as:

$$|\psi ⟩=\alpha |0⟩+\beta |1⟩$$

where:

• $|0⟩$ and $|1⟩$ are the computational basis states
• $\alpha$ and $\beta$ are complex amplitudes
• $|\alpha {|}^2+|\beta {|}^2=1$ (normalization condition)

When measured, the qubit collapses to $|0⟩$ with probability $|\alpha {|}^2$ or to $|1⟩$ with probability $|\beta {|}^2$.

Physical Implementations

Qubits can be realized in many physical systems:

Key Properties

1. Superposition: A qubit can be in a combination of $|0⟩$ and $|1⟩$
2. Measurement collapse: Observing a qubit forces it into a definite state
3. No-cloning: You cannot copy an unknown qubit state (see No-Cloning Theorem)
4. Entanglement: Qubits can become correlated with other qubits (see Entanglement)

Visualization

The Bloch sphere provides a geometric visualization of a qubit’s state. Any pure qubit state corresponds to a point on the surface of a unit sphere:

• $|0⟩$ is at the north pole
• $|1⟩$ is at the south pole
• Superposition states lie elsewhere on the sphere

Why It Matters

The qubit is the foundation of everything in quantum computing. Understanding qubits is essential for understanding:

• Quantum gates (operations on qubits)
• Quantum circuits (sequences of gates)
• Quantum algorithms (computational procedures)

See also: Superposition, Bloch Sphere, Quantum State, Logical Qubit, Physical Qubit

Superposition

A quantum system existing in multiple states simultaneously until measured.

Superposition is perhaps the most famous feature of quantum mechanics. A quantum system in superposition is not in one definite state but rather in a combination of multiple possible states at once.

The Concept

Consider a qubit. Classically, a bit is either 0 or 1. A qubit in superposition is both 0 and 1 simultaneously:

$$|\psi ⟩=\alpha |0⟩+\beta |1⟩$$

This is not the same as:

• Being 0 or 1 but we don’t know which (that’s classical uncertainty)
• Switching rapidly between 0 and 1
• Being “kind of” 0 and “kind of” 1

Superposition is genuinely being in multiple states at once, a distinctly quantum phenomenon with no classical analog.

Measurement and Collapse

When you measure a qubit in superposition, you get a definite result:

• $|0⟩$ with probability $|\alpha {|}^2$
• $|1⟩$ with probability $|\beta {|}^2$

After measurement, the superposition is destroyed. The qubit is now in the measured state. This is called wavefunction collapse or state collapse.

Creating Superposition

The most common way to create superposition is with the Hadamard gate:

$$H|0⟩=\frac{1}{\sqrt{2}}(|0⟩+|1⟩)=|+⟩$$

This takes a qubit in state $|0⟩$ and puts it in an equal superposition.

Multi-Qubit Superposition

With $n$ qubits, you can create superposition over $2^n$ states:

$$|\psi ⟩=\sum _{x=0}^{2^n-1}{\alpha }_x|x⟩$$

For example, 3 qubits can be in superposition over 8 states (000, 001, 010, 011, 100, 101, 110, 111) simultaneously.

This is often called quantum parallelism, but be careful! You can’t simply “read out” all $2^n$ values. Measurement gives you just one result.

Why It Matters

Superposition is essential for:

• Quantum parallelism: Processing multiple possibilities simultaneously
• Quantum interference: Making wrong answers cancel out (see Interference)
• Quantum speedups: Algorithms like Grover’s exploit superposition

Common Misconception

Superposition ≠ randomness. A qubit in state $|0⟩$ is not in superposition. It will definitely measure as 0. A qubit in superposition has specific amplitudes that determine measurement probabilities and can interfere with other amplitudes.

See also: Qubit, Hadamard Gate, Measurement, Quantum Parallelism

Entanglement

A quantum correlation between particles where the state of one instantly relates to the state of another, regardless of distance.

Entanglement is one of the most profound features of quantum mechanics. When particles become entangled, their quantum states become correlated in ways that have no classical explanation. Einstein famously called it “spooky action at a distance.”

The Basic Idea

Consider two qubits in this state (a Bell state):

$$|{\Phi }^{+}⟩=\frac{1}{\sqrt{2}}(|00⟩+|11⟩)$$

This state says: “Both qubits are in superposition, but they’re perfectly correlated.”

• Measure the first qubit as 0 → the second qubit is definitely 0
• Measure the first qubit as 1 → the second qubit is definitely 1

The correlation is instant and works regardless of how far apart the qubits are separated.

What Entanglement Is NOT

• NOT faster-than-light communication: You can’t send information using entanglement alone. The measurement results are random, and you can’t control what you get.
• NOT the same as classical correlation: If I put one red ball and one blue ball in separate boxes and ship them apart, opening one tells me the other’s color. But quantum entanglement is different. Bell’s theorem proves this mathematically.

Creating Entanglement

The standard way to entangle two qubits:

1. Start with $|00⟩$
2. Apply Hadamard to the first qubit: $\frac{1}{\sqrt{2}}(|0⟩+|1⟩)|0⟩$
3. Apply CNOT with first qubit as control: $\frac{1}{\sqrt{2}}(|00⟩+|11⟩)$

Types of Entangled States

Bell States (2 qubits):

• $|{\Phi }^{+}⟩=\frac{1}{\sqrt{2}}(|00⟩+|11⟩)$
• $|{\Phi }^{-}⟩=\frac{1}{\sqrt{2}}(|00⟩-|11⟩)$
• $|{\Psi }^{+}⟩=\frac{1}{\sqrt{2}}(|01⟩+|10⟩)$
• $|{\Psi }^{-}⟩=\frac{1}{\sqrt{2}}(|01⟩-|10⟩)$

GHZ State (3+ qubits): $$|GHZ⟩=\frac{1}{\sqrt{2}}(|000⟩+|111⟩)$$

W State (3 qubits): $$|W⟩=\frac{1}{\sqrt{3}}(|001⟩+|010⟩+|100⟩)$$

Why It Matters

Entanglement is a resource for quantum computing and communication:

Measuring Entanglement

How do you know if a state is entangled? A pure state of two systems is entangled if it cannot be written as a product state $|{\psi }_A⟩\otimes |{\psi }_B⟩$. For mixed states, various entanglement measures exist (concurrence, negativity, entanglement entropy).

See also: Bell State, Bell Inequality, Quantum Teleportation, CNOT Gate

Quantum State

The complete mathematical description of a quantum system, containing all information needed to predict measurement outcomes.

A quantum state is the mathematical object that fully describes a quantum system. It encodes everything you can know about the system and determines the probabilities of all possible measurement outcomes.

Pure States

The simplest quantum states are pure states, represented as vectors in Hilbert space using bra-ket notation:

$$|\psi ⟩=\alpha |0⟩+\beta |1⟩$$

A pure state represents a system with no classical uncertainty. Any uncertainty is purely quantum mechanical (superposition).

Properties of Pure States

• Represented by a vector $|\psi ⟩$ (a “ket”)
• Normalized: $⟨\psi |\psi ⟩=1$
• Can be visualized on the Bloch sphere (for single qubits)

Mixed States

When there is classical uncertainty (e.g., the system might be in state $|{\psi }_1⟩$ with probability $p_1$ or $|{\psi }_2⟩$ with probability $p_2$), we use mixed states represented by density matrices:

$$\rho =\sum _i{p}_i|{\psi }_i⟩⟨{\psi }_i|$$

Mixed states arise from:

• Classical uncertainty about preparation
• Decoherence (interaction with environment)
• Tracing out part of an entangled system

State Space

For a single qubit, the state space is 2-dimensional. For $n$ qubits, the state space is $2^n$-dimensional. This exponential growth is both the promise and challenge of quantum computing:

Common States

Single-qubit basis states:

• $|0⟩$ and $|1⟩$: computational basis
• $|+⟩=\frac{1}{\sqrt{2}}(|0⟩+|1⟩)$ and $|-⟩=\frac{1}{\sqrt{2}}(|0⟩-|1⟩)$: Hadamard basis

Multi-qubit states:

• $|00⟩,|01⟩,|10⟩,|11⟩$: 2-qubit computational basis
• Bell states: maximally entangled 2-qubit states

State Evolution

Quantum states evolve in two ways:

1. Unitary evolution: Applying quantum gates $$|{\psi }^{\prime }⟩=U|\psi ⟩$$

2. Measurement: Collapsing to an eigenstate $$|\psi ⟩\stackrel{\text{measure}}{\to }|k⟩\text{ with probability }|⟨k|\psi ⟩{|}^2$$

Describing States

Multiple equivalent ways to describe quantum states:

See also: Pure State, Mixed State, Density Matrix, Bloch Sphere, Hilbert Space

Bloch Sphere

A geometric representation of a single qubit’s state as a point on (or inside) a unit sphere.

The Bloch sphere is the standard way to visualize single-qubit states. Every pure state of a qubit corresponds to a unique point on the surface of a unit sphere, making it invaluable for building intuition about quantum operations.

The Geometry

A general single-qubit pure state can be written as:

$$|\psi ⟩=\cos \frac{\theta }{2}|0⟩+e^{i\varphi }\sin \frac{\theta }{2}|1⟩$$

where:

• $\theta$ (theta): angle from the north pole (0 to π)
• $\varphi$ (phi): azimuthal angle around the equator (0 to 2π)

These angles define a point on the sphere:

• North pole ($\theta =0$): $|0⟩$
• South pole ($\theta =\pi$): $|1⟩$
• Equator ($\theta =\pi /2$): Equal superposition states like $|+⟩$, $|-⟩$, $|i⟩$, $|-i⟩$

Key Points on the Sphere

Gates as Rotations

Single-qubit gates correspond to rotations on the Bloch sphere:

• Pauli X: 180° rotation around X-axis (bit flip: $|0⟩\leftrightarrow |1⟩$)
• Pauli Y: 180° rotation around Y-axis
• Pauli Z: 180° rotation around Z-axis (phase flip)
• Hadamard: 180° rotation around the axis halfway between X and Z
• Phase gates: Rotations around Z-axis by various angles

Any single-qubit gate is a rotation on the Bloch sphere, and any rotation can be decomposed into rotations around X, Y, and Z axes.

Mixed States

For mixed states, points lie inside the sphere:

• Pure states: surface of the sphere (radius = 1)
• Mixed states: inside the sphere (radius < 1)
• Maximally mixed state ($\rho =I/2$): center of the sphere

The radius indicates the “purity” of the state.

Limitations

The Bloch sphere only works for single qubits. For multiple qubits, the state space is too high-dimensional to visualize this way. There’s no simple “Bloch sphere” for 2 or more qubits.

Why It Matters

The Bloch sphere is essential for:

• Building intuition about qubit states and gates
• Visualizing quantum operations
• Understanding errors (how states drift on the sphere)
• Teaching quantum computing concepts

See also: Qubit, Quantum State, Pauli Gates, Mixed State

Measurement

The process of extracting classical information from a quantum system, which fundamentally disturbs the quantum state.

Measurement is how we get information out of a quantum computer. It’s also one of the most counterintuitive aspects of quantum mechanics: measuring a quantum system fundamentally changes it.

The Measurement Process

When you measure a qubit in the computational basis:

1. Before: Qubit is in state $|\psi ⟩=\alpha |0⟩+\beta |1⟩$
2. Measurement: You observe either 0 or 1
3. After: Qubit “collapses” to the observed state ($|0⟩$ or $|1⟩$)

The probabilities are given by the Born rule:

• Probability of 0: $|\alpha {|}^2$
• Probability of 1: $|\beta {|}^2$

Key Properties

Probabilistic

Even if you know the exact quantum state, you can only predict measurement probabilities, not definite outcomes (unless the state is already an eigenstate of the measurement).

Irreversible

Measurement destroys the superposition. You cannot “undo” a measurement to recover the original state.

Basis-Dependent

You can measure in different bases:

• Computational basis (Z): Measures $|0⟩$ vs $|1⟩$
• Hadamard basis (X): Measures $|+⟩$ vs $|-⟩$
• Y basis: Measures $|i⟩$ vs $|-i⟩$

The same state gives different results in different bases.

Types of Measurement

Projective Measurement

The standard quantum measurement, described by projection operators. For computational basis:

• $P_0=|0⟩⟨0|$
• $P_1=|1⟩⟨1|$

POVM (Positive Operator-Valued Measure)

A generalization that allows for more measurement outcomes than basis states. Used in quantum information theory and quantum cryptography.

Weak Measurement

Partial measurement that disturbs the state less but provides less information. Useful for studying quantum systems without fully collapsing them.

Mid-Circuit Measurement

Modern quantum computers support measuring qubits in the middle of a circuit (not just at the end). This enables:

• Classical feedforward: Conditioning later operations on measurement results
• Quantum error correction: Measuring syndromes without destroying logical information
• Repeat-until-success protocols: Retrying until desired outcome occurs

Measurement in Practice

In real quantum hardware, measurement is often the slowest and noisiest operation:

• Superconducting qubits: ~1 μs readout time
• Trapped ions: ~100 μs readout time

Measurement errors (misreading 0 as 1 or vice versa) are a significant source of noise.

Why It Matters

• Measurement is how we extract answers from quantum computations
• The measurement problem is at the heart of quantum mechanics interpretation debates
• Understanding measurement is important for designing algorithms and error correction

See also: Born Rule, Quantum State, Superposition, Quantum Circuit

Born Rule

The fundamental rule that connects quantum amplitudes to measurement probabilities: probability equals amplitude squared.

The Born rule is the bridge between the abstract mathematics of quantum mechanics and experimental observations. It tells us how to calculate the probability of getting a particular measurement outcome.

The Rule

For a quantum state $|\psi ⟩$, the probability of measuring outcome $|k⟩$ is:

$$P(k)=|⟨k|\psi ⟩{|}^2$$

In other words: probability = |amplitude|²

Example

Consider a qubit in state: $$|\psi ⟩=\frac{1}{\sqrt{3}}|0⟩+\sqrt{\frac{2}{3}}|1⟩$$

The measurement probabilities are:

• $P(0)=|1/\sqrt{3}{|}^2=1/3\approx 33\%$
• $P(1)=|\sqrt{2/3}{|}^2=2/3\approx 67\%$

Note that probabilities sum to 1 (which is why we need the normalization condition).

Why Squared?

The Born rule is a postulate of quantum mechanics. It’s not derived from deeper principles. Some interpretations (like many-worlds) attempt to derive it, but we accept it because it matches experimental results with extraordinary precision.

The squaring is key:

• Amplitudes can be negative or complex
• Probabilities must be non-negative
• The absolute value squared ensures non-negative probabilities

For Density Matrices

For mixed states described by density matrix $\rho$:

$$P(k)=⟨k|\rho |k⟩=\text{Tr}(|k⟩⟨k|\rho )$$

Why It Matters

The Born rule is:

• The only way to connect quantum theory to experiment
• Why quantum amplitudes interfering can affect measurement outcomes
• Fundamental to understanding why quantum algorithms work

See also: Measurement, Quantum State, Superposition

Bra-Ket Notation

The standard mathematical notation for quantum states, invented by Dirac, using angle brackets and vertical bars.

Bra-ket notation (also called Dirac notation) is the standard language for writing quantum states and operations. Once you learn it, quantum mechanics becomes much easier to read and write.

The Basics

Kets |⟩

A ket $|⟩$ represents a quantum state (a column vector):

$$|0⟩=\left(\begin{array}{c}1\\ 0\end{array}\right),|1⟩=\left(\begin{array}{c}0\\ 1\end{array}\right)$$

$$|\psi ⟩=\alpha |0⟩+\beta |1⟩=\left(\begin{array}{c}\alpha \\ \beta \end{array}\right)$$

You can put any label inside: $|0⟩$, $|1⟩$, $|\psi ⟩$, $|+⟩$, $|\text{cat}⟩$, etc.

Bras ⟨|

A bra $⟨|$ is the conjugate transpose of a ket (a row vector):

$$⟨\psi |=|\psi {⟩}^{†}=({\alpha }^{\ast }{\beta }^{\ast })$$

where ${\alpha }^{\ast }$ is the complex conjugate of $\alpha$.

Operations

Inner Product (Bra-Ket)

Combining a bra and a ket gives a number:

$$⟨\varphi |\psi ⟩=\text{inner product (a complex number)}$$

This is also called a bracket (bra + ket = bracket).

For computational basis states: $$⟨0|0⟩=1,⟨1|1⟩=1,⟨0|1⟩=0,⟨1|0⟩=0$$

Outer Product (Ket-Bra)

Combining a ket and a bra gives an operator (matrix):

$$|0⟩⟨1|=\left(\begin{array}{c}1\\ 0\end{array}\right)(01)=\left(\begin{array}{cc}0& 1\\ 0& 0\end{array}\right)$$

Common Notation

Multi-Qubit States

For multiple qubits, we use tensor products:

$$|0⟩\otimes |1⟩=|01⟩=|0,1⟩$$

All three notations mean the same thing. The tensor product symbol $\otimes$ is often omitted.

Why This Notation?

1. Compact: $|\psi ⟩$ is shorter than writing column vectors
2. Flexible: Works in any dimension, any basis
3. Intuitive: Inner products $⟨\varphi |\psi ⟩$ look like what they compute
4. Standard: Universal in quantum physics and computing

Pronunciation

• $|0⟩$: “ket zero”
• $⟨\psi |$: “bra psi”
• $⟨\varphi |\psi ⟩$: “bra phi ket psi” or “phi inner psi” or “bracket phi psi”

See also: Quantum State, Hilbert Space, Density Matrix

Density Matrix

A mathematical representation of quantum states that can describe both pure and mixed states, essential for open quantum systems and quantum noise.

A density matrix (also called a density operator) is a more general way to describe quantum states than state vectors. It’s essential when dealing with classical uncertainty, entangled subsystems, or noise.

Definition

For a pure state $|\psi ⟩$, the density matrix is:

$$\rho =|\psi ⟩⟨\psi |$$

For a mixed state (classical probability distribution over pure states):

$$\rho =\sum _i{p}_i|{\psi }_i⟩⟨{\psi }_i|$$

where $p_i$ is the probability of being in state $|{\psi }_i⟩$.

Example

Pure state $|+⟩=\frac{1}{\sqrt{2}}(|0⟩+|1⟩)$:

$$\rho =|+⟩⟨+|=\frac{1}{2}\left(\begin{array}{cc}1& 1\\ 1& 1\end{array}\right)$$

Mixed state (50% $|0⟩$, 50% $|1⟩$):

$$\rho =\frac{1}{2}|0⟩⟨0|+\frac{1}{2}|1⟩⟨1|=\frac{1}{2}\left(\begin{array}{cc}1& 0\\ 0& 1\end{array}\right)$$

Note: These are different states! The pure state has off-diagonal elements (coherence), the mixed state doesn’t.

Properties

A valid density matrix must satisfy:

1. Hermitian: $\rho ={\rho }^{†}$
2. Positive semi-definite: All eigenvalues $\ge 0$
3. Trace one: $\text{Tr}(\rho )=1$

Pure vs Mixed

How to tell if a state is pure or mixed:

Measurement Probabilities

Using the Born rule with density matrices:

$$P(k)=\text{Tr}(|k⟩⟨k|\rho )=⟨k|\rho |k⟩$$

Time Evolution

Density matrices evolve via:

$$\rho (t)=U\rho (0)U^{†}$$

For open systems (with noise), we use quantum channels:

$${\rho }^{\prime }=\mathcal{E}(\rho )$$

Why It Matters

Density matrices are essential for:

• Describing noise and decoherence: Real quantum systems interact with their environment
• Partial traces: Describing part of an entangled system
• Quantum error correction: Tracking how errors affect states
• Quantum information measures: Entropy, fidelity, trace distance

See also: Pure State, Mixed State, Quantum Channel

Pure State

A quantum state with no classical uncertainty. The most complete description of a quantum system.

A pure state represents a quantum system about which we have maximal knowledge. All uncertainty in a pure state is fundamentally quantum mechanical (superposition), not classical.

Definition

A pure state can be written as a single state vector:

$$|\psi ⟩=\sum _i{\alpha }_i|i⟩$$

Or equivalently, as a rank-1 density matrix:

$$\rho =|\psi ⟩⟨\psi |$$

Examples

• $|0⟩$: a definite computational basis state
• $|+⟩=\frac{1}{\sqrt{2}}(|0⟩+|1⟩)$: a superposition, but still pure
• Bell states: entangled but pure

Characteristics

Pure ≠ Definite

A common misconception: pure state does not mean the measurement outcome is certain.

$|+⟩$ is a pure state, but measuring it in the computational basis gives 0 or 1 with 50% probability each. The state is “pure” because there’s no additional classical uncertainty. We know the exact quantum state.

When Pure States Become Mixed

Pure states can become mixed states through:

• Decoherence: Interaction with the environment
• Partial trace: Looking at only part of an entangled system
• Incomplete knowledge: Not knowing which state was prepared

See also: Mixed State, Density Matrix, Quantum State

Mixed State

A quantum state with classical uncertainty, a statistical mixture of pure states.

A mixed state describes a quantum system where we don’t have complete information. It’s a probabilistic combination of pure states, representing classical uncertainty on top of quantum uncertainty.

Definition

A mixed state cannot be written as a single state vector. It’s represented by a density matrix:

$$\rho =\sum _i{p}_i|{\psi }_i⟩⟨{\psi }_i|$$

where $p_i$ are classical probabilities (summing to 1) and $|{\psi }_i⟩$ are pure states.

Example: The Maximally Mixed State

The simplest mixed state for a qubit:

$$\rho =\frac{1}{2}|0⟩⟨0|+\frac{1}{2}|1⟩⟨1|=\frac{1}{2}\left(\begin{array}{cc}1& 0\\ 0& 1\end{array}\right)=\frac{I}{2}$$

This represents “no information at all” - maximum classical uncertainty.

Mixed ≠ Superposition

This is important to understand:

The off-diagonal elements (“coherences”) are what distinguishes quantum superposition from classical probability.

How Mixed States Arise

1. Incomplete preparation: You prepare $|0⟩$ or $|1⟩$ but forget which
2. Decoherence: Environment interaction destroys coherence
3. Partial trace: Taking part of an entangled system

Example: Entanglement and Mixed States

If two qubits are in Bell state $|{\Phi }^{+}⟩=\frac{1}{\sqrt{2}}(|00⟩+|11⟩)$ and you only have access to one qubit:

$${\rho }_A={\text{Tr}}_B(|{\Phi }^{+}⟩⟨{\Phi }^{+}|)=\frac{I}{2}$$

Your qubit looks maximally mixed, even though the total system is pure!

Characteristics

Why It Matters

Mixed states are essential for:

• Describing realistic quantum systems (always some noise)
• Modeling decoherence
• Quantum error correction
• Quantum thermodynamics

See also: Pure State, Density Matrix, Decoherence

Hilbert Space

The mathematical space where quantum states live: a complete complex vector space with an inner product.

A Hilbert space is the mathematical arena for quantum mechanics. Every quantum state is a vector in a Hilbert space, and quantum operations are linear transformations on this space.

The Basics

For quantum computing purposes, think of a Hilbert space as:

• A complex vector space (vectors have complex number components)
• Equipped with an inner product $⟨\varphi |\psi ⟩$
• Complete (no “holes” or missing points)

Dimension

The dimension of the Hilbert space determines how many basis states exist:

The exponential growth ($2^n$) is both the power and the challenge of quantum computing.

Key Properties

Inner Product

For any two states $|\varphi ⟩$ and $|\psi ⟩$: $$⟨\varphi |\psi ⟩=\text{complex number}$$

Properties:

• $⟨\psi |\psi ⟩\ge 0$ (and equals zero only if $|\psi ⟩=0$)
• $⟨\varphi |\psi ⟩=⟨\psi |\varphi {⟩}^{\ast }$ (conjugate symmetry)

Orthonormality

Basis states are orthonormal: $$⟨i|j⟩={\delta }_{ij}=\{\begin{array}{ll}1& i=j\\ 0& i\ne j\end{array}$$

Normalization

Physical quantum states have unit norm: $$⟨\psi |\psi ⟩=1$$

Tensor Products

When combining quantum systems, Hilbert spaces combine via tensor products:

$${\mathcal{H}}_{AB}={\mathcal{H}}_A\otimes {\mathcal{H}}_B$$

Dimension multiplies: if ${\mathcal{H}}_A$ has dimension $d_A$ and ${\mathcal{H}}_B$ has dimension $d_B$, then ${\mathcal{H}}_{AB}$ has dimension $d_A\cdot d_B$.

For Working Quantum Scientists

In practice, you usually don’t need to think deeply about Hilbert space theory. Just know:

1. States are vectors: $|\psi ⟩\in \mathcal{H}$
2. Operators are matrices: $U:\mathcal{H}\to \mathcal{H}$
3. Inner products give probabilities: $|⟨\varphi |\psi ⟩{|}^2$
4. Dimension grows exponentially with qubit count

Infinite-Dimensional Hilbert Spaces

Continuous-variable quantum computing and quantum field theory use infinite-dimensional Hilbert spaces. These require more mathematical care but the basic ideas remain similar.

See also: Quantum State, Bra-Ket Notation, Qubit

Quantum Gate

A basic operation on qubits, the quantum equivalent of classical logic gates.

A quantum gate is a basic operation that transforms quantum states. Just as classical computers use AND, OR, and NOT gates, quantum computers use quantum gates to perform computations.

Key Properties

Unitary

Every quantum gate is represented by a unitary matrix $U$: $$U^{†}U=U{U}^{†}=I$$

This ensures:

• Reversibility (every gate has an inverse: $U^{-1}=U^{†}$)
• Preservation of probability (states stay normalized)

Reversible

Unlike classical gates (AND, OR destroy information), quantum gates are always reversible. Given the output, you can recover the input.

Common Single-Qubit Gates

Common Multi-Qubit Gates

Gate Application

Applying gate $U$ to state $|\psi ⟩$: $$|{\psi }^{\prime }⟩=U|\psi ⟩$$

For density matrices: $${\rho }^{\prime }=U\rho U^{†}$$

Rotation Gates

Single-qubit gates can be parameterized as rotations:

$$R_x(\theta )=e^{-i\theta X/2},R_y(\theta )=e^{-i\theta Y/2},R_z(\theta )=e^{-i\theta Z/2}$$

Any single-qubit gate can be decomposed into rotations: $$U=e^{i\alpha }{R}_z(\beta )R_y(\gamma )R_z(\delta )$$

Gate Sets

A universal gate set can approximate any quantum operation:

• {H, T, CNOT}: standard universal set
• {H, Toffoli}: also universal

Physical Implementation

Gates are implemented differently on different hardware:

• Superconducting qubits: Microwave pulses
• Trapped ions: Laser pulses
• Photonic: Beam splitters, phase shifters

Gate times and error rates are key performance metrics. Fidelity measures how close a real gate is to the ideal operation.

See also: Quantum Circuit, Pauli Gates, Hadamard Gate, CNOT Gate, Universal Gate Set

Pauli Gates

The three fundamental single-qubit gates (X, Y, Z) that form the building blocks of quantum operations.

The Pauli gates (also called Pauli matrices or Pauli operators) are three fundamental single-qubit operations named after physicist Wolfgang Pauli. They’re ubiquitous in quantum computing.

The Three Gates

Pauli X (Bit Flip)

$$X=\left(\begin{array}{cc}0& 1\\ 1& 0\end{array}\right)$$

• Swaps $|0⟩\leftrightarrow |1⟩$
• Quantum analog of classical NOT
• 180° rotation around X-axis on Bloch sphere

$$X|0⟩=|1⟩,X|1⟩=|0⟩$$

Pauli Y

$$Y=\left(\begin{array}{cc}0& -i\\ i& 0\end{array}\right)$$

• Combined bit and phase flip
• 180° rotation around Y-axis

$$Y|0⟩=i|1⟩,Y|1⟩=-i|0⟩$$

Pauli Z (Phase Flip)

$$Z=\left(\begin{array}{cc}1& 0\\ 0& -1\end{array}\right)$$

• Leaves $|0⟩$ unchanged, flips sign of $|1⟩$
• 180° rotation around Z-axis

$$Z|0⟩=|0⟩,Z|1⟩=-|1⟩$$

Key Properties

Self-Inverse

Each Pauli gate is its own inverse: $$X^2=Y^2=Z^2=I$$

Anti-Commutation

Paulis anti-commute with each other: $$XY=-YX=iZ$$ $$YZ=-ZY=iX$$ $$ZX=-XZ=iY$$

Hermitian

All Paulis are Hermitian ($P=P^{†}$), meaning they’re also valid observables (measurement operators).

Eigenvalues

Each Pauli has eigenvalues +1 and -1:

• X eigenstates: $|+⟩,|-⟩$
• Y eigenstates: $|i⟩,|-i⟩$
• Z eigenstates: $|0⟩,|1⟩$

Pauli Group

The Pauli group consists of all products of Paulis with phases $\{\pm 1,\pm i\}$: $${\mathcal{P}}_1=\{\pm I,\pm iI,\pm X,\pm iX,\pm Y,\pm iY,\pm Z,\pm iZ\}$$

For $n$ qubits, Pauli strings are tensor products like $X\otimes Z\otimes Y$.

Why They Matter

Paulis are fundamental because:

• They form a basis for all 2×2 matrices
• Quantum error correction describes errors as Pauli operations
• Pauli decomposition expresses Hamiltonians in terms of Paulis
• Measurements are often in Pauli bases (X, Y, or Z)

See also: Quantum Gate, Bloch Sphere, Hadamard Gate

Hadamard Gate

The gateway to superposition, transforms basis states into equal superpositions.

The Hadamard gate (H gate) is perhaps the most important single-qubit gate. It creates superposition from definite states and is the starting point for most quantum algorithms.

Definition

$$H=\frac{1}{\sqrt{2}}\left(\begin{array}{cc}1& 1\\ 1& -1\end{array}\right)$$

Action on Basis States

$$H|0⟩=\frac{1}{\sqrt{2}}(|0⟩+|1⟩)=|+⟩$$

$$H|1⟩=\frac{1}{\sqrt{2}}(|0⟩-|1⟩)=|-⟩$$

The Hadamard creates an equal superposition with 50/50 measurement probabilities.

Key Properties

Self-Inverse

$$H^2=I$$

Applying Hadamard twice returns to the original state.

Basis Change

Hadamard transforms between two important bases:

• Computational basis: $\{|0⟩,|1⟩\}$ (Z eigenstates)
• Hadamard basis: $\{|+⟩,|-⟩\}$ (X eigenstates)

$$H:|0⟩\leftrightarrow |+⟩,|1⟩\leftrightarrow |-⟩$$

Relation to Paulis

$$H=\frac{1}{\sqrt{2}}(X+Z)$$

Also: $HXH=Z$ and $HZH=X$

Bloch Sphere

Hadamard is a 180° rotation around the axis halfway between X and Z.

Hadamard on Multiple Qubits

Applying H to all $n$ qubits creates a uniform superposition over all $2^n$ states:

$$H^{\otimes n}|0{⟩}^{\otimes n}=\frac{1}{\sqrt{2^n}}\sum _{x=0}^{2^n-1}|x⟩$$

This is the starting point for many quantum algorithms (Grover’s, Shor’s, etc.).

Walsh-Hadamard Transform

The $n$-qubit Hadamard operation:

$$H^{\otimes n}|x⟩=\frac{1}{\sqrt{2^n}}\sum _{y=0}^{2^n-1}(-1{)}^{x\cdot y}|y⟩$$

where $x\cdot y$ is the bitwise inner product. This is the quantum Walsh-Hadamard transform.

In Quantum Circuits

The Hadamard is typically drawn as a box with “H”:

     ┌───┐
|0⟩──┤ H ├──|+⟩
     └───┘

Why It’s Important

Almost every quantum algorithm starts with Hadamards:

1. Initialize qubits in $|0⟩$
2. Apply Hadamard to create superposition
3. Perform computation
4. Extract answer

Without Hadamard, there’s no superposition. Without superposition, there’s no quantum advantage.

See also: Superposition, Quantum Gate, Pauli Gates, Quantum Algorithm

CNOT Gate

The standard two-qubit entangling gate. Flips the target qubit if and only if the control qubit is |1>.

The CNOT (Controlled-NOT) gate is the most important two-qubit gate in quantum computing. It’s essential for creating entanglement and is part of every universal gate set.

Definition

The CNOT operates on two qubits: a control and a target.

$$\text{CNOT}=\left(\begin{array}{cccc}1& 0& 0& 0\\ 0& 1& 0& 0\\ 0& 0& 0& 1\\ 0& 0& 1& 0\end{array}\right)$$

Action

If control is $|0⟩$: target unchanged If control is $|1⟩$: target flipped (X gate applied)

Shorthand: $|c,t⟩\to |c,t\oplus c⟩$ where $\oplus$ is XOR.

Circuit Symbol

Control: ──●──
           │
Target:  ──⊕──

The dot (●) marks the control; the circle-plus (⊕) marks the target.

Creating Entanglement

CNOT is the standard way to create entangled states:

|0⟩ ──H────●────  →  |Φ+⟩ = (|00⟩ + |11⟩)/√2
           │
|0⟩ ───────⊕────

1. Start: $|00⟩$
2. After H: $\frac{1}{\sqrt{2}}(|0⟩+|1⟩)|0⟩=\frac{1}{\sqrt{2}}(|00⟩+|10⟩)$
3. After CNOT: $\frac{1}{\sqrt{2}}(|00⟩+|11⟩)$

This is a Bell state, maximally entangled!

Properties

Self-Inverse

$${\text{CNOT}}^2=I$$

Relation to Other Gates

$$\text{CNOT}=|0⟩⟨0|\otimes I+|1⟩⟨1|\otimes X$$

Can be written as controlled-X: $\text{CX}$

Basis Changes

With Hadamards, control and target can be swapped: $$(H\otimes H)\cdot \text{CNOT}\cdot (H\otimes H)=\text{CNOT reversed}$$

Physical Implementation

CNOT is a native gate on some platforms:

• Superconducting: Cross-resonance or iSWAP-based
• Trapped ions: Mølmer-Sørensen or XX gates
• Photonic: Requires non-linearities or measurement

CNOT fidelity is a key benchmark for quantum hardware.

Universal Computation

CNOT + single-qubit gates = universal quantum computing. Any quantum operation can be decomposed into CNOTs and single-qubit rotations.

See also: Entanglement, Quantum Gate, Bell State, Universal Gate Set, Toffoli Gate

Toffoli Gate

A three-qubit gate that flips the target only when both control qubits are |1>. Also known as the quantum AND gate.

The Toffoli gate (also called CCNOT or Controlled-Controlled-NOT) is a three-qubit gate that’s universal for classical reversible computation and important for quantum algorithms.

Definition

Two control qubits, one target qubit:

$$|a,b,c⟩\to |a,b,c\oplus (a\wedge b)⟩$$

The target flips only when both controls are $|1⟩$.

Circuit Symbol

Control 1: ──●──
             │
Control 2: ──●──
             │
Target:    ──⊕──

Classical Reversible Computing

The Toffoli gate is universal for classical reversible computation:

• AND: Set target to $|0⟩$, result is $a\wedge b$
• NOT: Set both controls to $|1⟩$
• FANOUT: Can copy classical bits

Any classical circuit can be made reversible using Toffoli gates (with ancilla bits).

Quantum Universality

Toffoli + Hadamard is universal for quantum computing. However, Toffoli alone (without superposition-creating gates) cannot perform universal quantum computation.

Decomposition

A Toffoli can be decomposed into simpler gates:

──●────●────────●────●────●──
  │    │        │    │    │
──●────┼────●───┼────●────┼──
  │    │    │   │    │    │
──┼──T─X─T†─X─T─X─T†─X────┼──

This uses ~6 CNOT gates and several T gates, making it expensive on near-term hardware.

Applications

• Quantum arithmetic: Addition, multiplication circuits
• Grover’s oracle: Marking solutions in search
• Reversible classical subroutines: Embedding classical functions in quantum algorithms
• Quantum error correction: Syndrome extraction

Generalization

• Multi-controlled NOT (MCX): $n$ control qubits, 1 target
• Decomposition cost grows with number of controls

See also: CNOT Gate, Quantum Gate, Universal Gate Set, T Gate

Phase Gate

Gates that add a phase to the |1⟩ state while leaving |0⟩ unchanged.

Phase gates are a family of single-qubit gates that modify the relative phase between $|0⟩$ and $|1⟩$ without changing measurement probabilities in the computational basis.

General Form

$$P(\theta )=\left(\begin{array}{cc}1& 0\\ 0& e^{i\theta }\end{array}\right)$$

Action: $|0⟩\to |0⟩$, $|1⟩\to e^{i\theta }|1⟩$

Common Phase Gates

S Gate (Phase Gate, √Z)

$$S=P(\pi /2)=\left(\begin{array}{cc}1& 0\\ 0& i\end{array}\right)$$

• Quarter turn around Z-axis on Bloch sphere
• $S^2=Z$
• Part of Clifford group

S† (S-dagger)

$$S^{†}=P(-\pi /2)=\left(\begin{array}{cc}1& 0\\ 0& -i\end{array}\right)$$

Inverse of S gate.

T Gate (π/8 Gate, √S)

$$T=P(\pi /4)=\left(\begin{array}{cc}1& 0\\ 0& e^{i\pi /4}\end{array}\right)$$

• Eighth turn around Z-axis
• $T^2=S$
• NOT in Clifford group (makes it powerful)
• See T Gate for more

Z Gate

$$Z=P(\pi )=\left(\begin{array}{cc}1& 0\\ 0& -1\end{array}\right)$$

Actually a Pauli gate, but also a phase gate with $\theta =\pi$.

Controlled Phase Gates

CZ (Controlled-Z)

$$CZ=\left(\begin{array}{cccc}1& 0& 0& 0\\ 0& 1& 0& 0\\ 0& 0& 1& 0\\ 0& 0& 0& -1\end{array}\right)$$

Applies Z to target when control is $|1⟩$. Symmetric: control and target are interchangeable!

CP (Controlled-Phase)

$$CP(\theta )=\text{diag}(1,1,1,e^{i\theta })$$

Adds phase only to $|11⟩$ state.

On the Bloch Sphere

Phase gates rotate around the Z-axis:

• $P(\theta )$ rotates by angle $\theta$ around Z
• Only affects superposition states (states on the equator)
• Pure $|0⟩$ or $|1⟩$ states appear unchanged

Why Phase Matters

You might wonder: if phases don’t affect measurement probabilities, why care?

Phases matter because of interference. When paths recombine (through gates like Hadamard), phases determine whether amplitudes add or cancel:

$$H\cdot P(\pi )\cdot H|0⟩=H|-⟩=|1⟩$$

The phase flip changed the final measurement outcome!

See also: T Gate, Pauli Gates, Quantum Gate, Bloch Sphere

T Gate

The “magic” gate that enables universal quantum computation when combined with Clifford gates.

The T gate (also called the π/8 gate) is a single-qubit phase gate needed for universal quantum computation.

Definition

$$T=\left(\begin{array}{cc}1& 0\\ 0& e^{i\pi /4}\end{array}\right)$$

Action: $|0⟩\to |0⟩$, $|1⟩\to e^{i\pi /4}|1⟩$

The name “π/8 gate” comes from writing $T=e^{i\pi /8}{R}_z(\pi /4)$ where the global phase is π/8.

Why T is Special

Non-Clifford

The Clifford gates (H, S, CNOT, and combinations) can be efficiently simulated classically. Adding the T gate makes the gate set universal and computationally powerful.

$$\text{Clifford}+T=\text{Universal}$$

Magic States

T gates can be implemented using “magic states” and Clifford operations: $$|T⟩=T|+⟩=\frac{1}{\sqrt{2}}(|0⟩+e^{i\pi /4}|1⟩)$$

This is important for fault-tolerant quantum computing.

T Gate Count

In fault-tolerant quantum computing, T gates are typically the most expensive operation (requiring complex state distillation). Algorithm efficiency is often measured in T-count: the number of T gates required.

Properties

$$T^2=S\text{(S gate)}$$ $$T^4=Z\text{(Pauli Z)}$$ $$T^8=I\text{(Identity)}$$

T† (T-dagger) is the inverse: $$T^{†}=\left(\begin{array}{cc}1& 0\\ 0& e^{-i\pi /4}\end{array}\right)$$

Bloch Sphere

T is a π/4 (45°) rotation around the Z-axis, an eighth of a full rotation.

In Practice

T gates appear throughout quantum algorithms:

• Toffoli gate decompositions
• Arbitrary rotation synthesis
• Quantum arithmetic circuits
• Phase kickback in phase estimation

See also: Phase Gate, Universal Gate Set, Fault-Tolerant Quantum Computing, Toffoli Gate

SWAP Gate

Exchanges the states of two qubits.

The SWAP gate does exactly what its name suggests: it swaps the quantum states of two qubits.

Definition

$$\text{SWAP}=\left(\begin{array}{cccc}1& 0& 0& 0\\ 0& 0& 1& 0\\ 0& 1& 0& 0\\ 0& 0& 0& 1\end{array}\right)$$

Action: $|a,b⟩\to |b,a⟩$

Circuit Symbol

──✕──
  │
──✕──

Or sometimes with crossing lines.

Decomposition

SWAP can be built from three CNOTs:

──●────⊕────●──
  │    │    │
──⊕────●────⊕──

This is the standard decomposition used when SWAP isn’t a native gate.

Variants

√SWAP (Square Root of SWAP)

$${\sqrt{\text{SWAP}}}^2=\text{SWAP}$$

An entangling gate sometimes native to certain hardware.

iSWAP

$$\text{iSWAP}=\left(\begin{array}{cccc}1& 0& 0& 0\\ 0& 0& i& 0\\ 0& i& 0& 0\\ 0& 0& 0& 1\end{array}\right)$$

Swaps states and adds a phase. Native gate on some superconducting processors (Google Sycamore).

CSWAP (Fredkin Gate)

Controlled-SWAP: swaps two qubits only when control is $|1⟩$.

Why It Matters

Connectivity

Many quantum computers have limited qubit connectivity (not all pairs can interact directly). SWAP gates route quantum information:

Before: q0 ─ q1 ─ q2 ─ q3  (linear connectivity)

To interact q0 with q3:
1. SWAP q0, q1
2. SWAP q1, q2
3. Now original q0 state is next to q3

Circuit Compilation

Mapping logical circuits to physical hardware often requires inserting many SWAP gates, increasing circuit depth and errors.

SWAP Test

A circuit for estimating state overlap:

|0⟩ ──H──●──H──M
         │
|ψ⟩ ─────✕─────
         │
|φ⟩ ─────✕─────

Probability of measuring 0 is $\frac{1}{2}(1+|⟨\psi |\varphi ⟩{|}^2)$.

See also: CNOT Gate, Quantum Gate, Circuit Depth

Universal Gate Set

A set of quantum gates that can approximate any quantum operation to arbitrary precision.

A universal gate set is a collection of quantum gates from which any possible quantum computation can be constructed. This is analogous to how AND, OR, and NOT can build any classical Boolean circuit.

The Key Theorem

Solovay-Kitaev Theorem: Any single-qubit gate can be approximated to precision $ϵ$ using $O({\log }^c(1/ϵ))$ gates from a universal set (where $c\approx 2$).

This means we don’t need infinitely many gates. A small finite set suffices.

Common Universal Gate Sets

The most commonly cited universal set:

• Hadamard (H): Creates superposition
• T gate: Provides the “magic” (non-Clifford) element
• CNOT: Entangles qubits

Any quantum algorithm can be compiled into these three gates.

Alternative universal set:

• Hadamard
• Toffoli (CCNOT)

Continuous Gate Sets

For error-free simulation, continuous rotations suffice:

• $\{R_x(\theta ),R_y(\theta ),\text{CNOT}\}$ for any $\theta$
• Any two-qubit entangling gate + arbitrary single-qubit rotations

Clifford Gates (NOT Universal)

The Clifford group is generated by:

• H (Hadamard)
• S (Phase gate)
• CNOT

Clifford circuits can be simulated efficiently on classical computers (Gottesman-Knill theorem). They become universal only when supplemented with a non-Clifford gate like T.

Why Universality Matters

1. Hardware-agnostic algorithms: Write algorithms once, compile to any gate set
2. Error correction: Fault-tolerant schemes implement universal sets
3. Equivalence: All universal quantum computers are computationally equivalent

Gate Synthesis

Converting arbitrary operations to gates from a universal set:

Native Gate Sets

Different hardware has different native gates:

Compilers translate circuits to native gate sets.

See also: Quantum Gate, T Gate, CNOT Gate, Fault Tolerance

Quantum Circuit

A sequence of quantum gates applied to qubits, representing a quantum computation.

A quantum circuit is the standard model for describing quantum computations. It shows qubits as horizontal lines (wires) and gates as boxes or symbols applied to those wires.

Structure

     ┌───┐     ┌───┐
q0: ─┤ H ├──●──┤ X ├─ M
     └───┘  │  └───┘
            │
q1: ────────⊕──────── M

Components:

• Wires: Horizontal lines representing qubits (time flows left to right)
• Gates: Boxes/symbols representing quantum operations
• Measurements: Usually at the end, marked with M or meter symbol

Reading a Circuit

1. Start with initial states (usually $|0⟩$ for each qubit)
2. Apply gates from left to right
3. Gates on different wires at the same horizontal position happen simultaneously
4. Measure at the end to get classical output

Circuit Metrics

Width

Number of qubits used.

Depth

See Circuit Depth for more details on time steps (layers of parallel gates).

Gate Count

Total number of gates, often broken down by type (single-qubit, two-qubit, T-gates).

Example: Bell State Preparation

     ┌───┐
q0: ─┤ H ├──●──
     └───┘  │
            │
q1: ────────⊕──

1. Start: $|00⟩$
2. H on q0: $\frac{1}{\sqrt{2}}(|0⟩+|1⟩)|0⟩$
3. CNOT: $\frac{1}{\sqrt{2}}(|00⟩+|11⟩)$

Circuit Identities

Gates can often be simplified:

• $HH=I$ (Hadamard is self-inverse)
• $XX=I$, $YY=I$, $ZZ=I$
• Adjacent CNOTs cancel
• $HZH=X$, $HXH=Z$

Optimizers use these to reduce circuit complexity.

Subcircuits and Oracles

Complex operations are often drawn as single boxes:

     ┌─────────┐
q: ──┤         ├──
     │    U    │
q: ──┤         ├──
     │         │
q: ──┤         ├──
     └─────────┘

This abstracts away internal details.

Barriers

Vertical lines that prevent optimization across them:

q0: ──H──|──X──
         |
q1: ──X──|──H──

Useful for separating distinct algorithm phases.

Classical Control

Modern circuits support mid-circuit measurement and classical feedback:

q0: ──H──M─────
         ║
         ╠══╗
q1: ─────║──X── (X if measurement = 1)

Double lines represent classical bits; gates conditioned on classical values.

See also: Quantum Gate, Circuit Depth, Quantum Algorithm, SWAP Gate

Circuit Depth

The number of sequential time steps in a quantum circuit. A key metric for NISQ-era computation.

Circuit depth measures how many layers of gates must be applied sequentially. It’s one of the most important metrics for determining whether a circuit can run on real hardware.

Definition

Depth is the longest path through the circuit, counting layers of gates that cannot be parallelized:

Layer:   1    2    3    4
         │    │    │    │
q0: ──H──┼────●────┼────X──
         │    │    │    │
q1: ──H──●────┼────X────┼──
         │    │    │    │
q2: ─────⊕────⊕────H────M──

This circuit has depth 4.

Why Depth Matters

Decoherence

Qubits lose their quantum properties over time (T1, T2 times). Deeper circuits mean more time for errors to accumulate.

Rule of thumb: Circuit depth should be much less than $T_2$ / gate time.

Error Accumulation

Each gate has some error probability. Errors compound:

• 100 gates at 99.9% fidelity each: ~90% overall fidelity
• 1000 gates at 99.9% fidelity each: ~37% overall fidelity

NISQ Limitations

NISQ devices can typically run circuits with depth ~100-1000 before noise overwhelms the signal. Fault-tolerant systems will enable much deeper circuits.

Depth vs. Width Trade-offs

Sometimes you can trade depth for width (more qubits):

Example: Computing $f(x_1)\wedge f(x_2)\wedge f(x_3)\wedge f(x_4)$

• Sequential: Depth 4, Width 1
• Parallel tree: Depth 2, Width 4

Reducing Depth

Techniques for shallower circuits:

1. Parallelization: Run independent gates simultaneously
2. Gate cancellation: Remove redundant gate pairs
3. Approximate compilation: Trade accuracy for depth
4. Algorithmic redesign: Use algorithms with inherently lower depth

Two-Qubit Gate Depth

Often, two-qubit gate depth is more relevant than total depth, since two-qubit gates are typically slower and noisier:

1Q gates: Fast, high fidelity (~99.9%)
2Q gates: Slower, lower fidelity (~99-99.9%)

Reporting Depth

When comparing algorithms or hardware, always clarify:

• Total depth vs. two-qubit depth
• Native gate set used
• Whether optimization was applied

See also: Quantum Circuit, NISQ, Decoherence, T2 Time

Quantum Parallelism

The ability of quantum computers to process multiple inputs simultaneously through superposition.

Quantum parallelism refers to a quantum computer’s ability to evaluate a function on many inputs at once by exploiting superposition.

The Basic Idea

Classically, to evaluate $f(x)$ on $N$ inputs, you need $N$ evaluations.

Quantumly, you can create a superposition of all inputs and evaluate once:

$$|x⟩|0⟩\stackrel{U_f}{\to }|x⟩|f(x)⟩$$

Apply to superposition: $$\frac{1}{\sqrt{N}}\sum _x|x⟩|0⟩\stackrel{U_f}{\to }\frac{1}{\sqrt{N}}\sum _x|x⟩|f(x)⟩$$

One quantum operation, $N$ function evaluations encoded in the state!

Example: 3 Qubits

With 3 input qubits in superposition:

$$H^{\otimes 3}|000⟩=\frac{1}{\sqrt{8}}(|000⟩+|001⟩+\dots +|111⟩)$$

All 8 inputs ($0$ through $7$) exist simultaneously.

The Catch

Here’s the critical limitation: you can’t read all the answers.

Measurement gives you ONE random result. The superposition collapses.

Before measurement: |f(0)⟩ + |f(1)⟩ + |f(2)⟩ + ... (all answers)
After measurement:  |f(k)⟩ (one random answer)

How Quantum Algorithms Use It

Quantum algorithms don’t just compute all answers. They use interference to extract useful information:

Deutsch-Josza

Determine if function is constant or balanced in ONE query (classically needs ~N/2).

Grover’s Search

Find the marked item in $O(\sqrt{N})$ queries instead of $O(N)$.

Shor’s Factoring

Use parallelism + QFT to find periodicity, enabling factoring.

The Pattern

1. Create superposition over all inputs
2. Evaluate function (quantum parallelism)
3. Apply interference (constructive for answers, destructive for non-answers)
4. Measure to extract the useful result

Common Misconception

Wrong: “Quantum computers try all solutions and pick the right one”

Right: Quantum computers use interference to make correct answers more probable. Designing this interference is the hard part, which is why we have only a handful of useful quantum algorithms.

Exponential State Space

With $n$ qubits:

• $2^n$ basis states can be in superposition
• But only $n$ qubits of information can be extracted (Holevo bound)

The challenge is designing algorithms that concentrate useful information into measurable outcomes.

See also: Superposition, Quantum Algorithm, Grover’s Algorithm

Quantum Algorithm

A step-by-step procedure for solving a problem using quantum computation, often providing speedup over classical algorithms.

A quantum algorithm is a procedure designed to run on a quantum computer. The best quantum algorithms exploit superposition, entanglement, and interference to solve problems faster than any known classical algorithm.

Anatomy of a Quantum Algorithm

Most quantum algorithms follow this pattern:

1. Initialize: Prepare qubits in |0⟩
2. Superpose: Create superposition (usually with Hadamards)
3. Compute: Apply problem-specific transformations
4. Interfere: Make correct answers constructive, wrong answers destructive
5. Measure: Extract the answer

The art is in step 4: designing interference patterns that amplify correct solutions.

Major Quantum Algorithms

Exponential Speedups

*With caveats about input/output

Polynomial Speedups

Near-Term Algorithms

What Makes Algorithms Quantum?

A quantum algorithm must use genuinely quantum resources:

• Superposition: Process multiple states simultaneously
• Entanglement: Create correlations impossible classically
• Interference: Combine amplitudes to concentrate probability

Algorithms that don’t use these don’t provide quantum advantage.

Complexity Classes

The Landscape

                    All Problems
                         │
          ┌──────────────┼──────────────┐
          │              │              │
    Classically     Quantum         Intractable
    Efficient      Advantage         for Both
    (P, BPP)        (BQP)              (?)
          │              │
    Sorting,       Factoring,
    Search         Simulation

Why So Few Algorithms?

Designing quantum algorithms is hard. We can’t just “quantize” classical algorithms. Each requires:

• Finding structure in the problem
• Designing interference to exploit that structure
• Proving the speedup exists

New quantum algorithms are rare discoveries, celebrated by the community.

See also: Shor’s Algorithm, Grover’s Algorithm, Quantum Speedup, Quantum Parallelism

Shor’s Algorithm

The quantum algorithm that factors integers exponentially faster than any known classical algorithm, threatening RSA encryption.

Shor’s algorithm, discovered by Peter Shor in 1994, efficiently factors large integers. This is devastating for RSA and similar cryptosystems that rely on factoring being hard.

The Impact

Classical factoring of an $n$-bit number: $O(e^{n^{1/3}})$ (best known) Quantum factoring with Shor’s: $O(n^3)$ or better

For a 2048-bit RSA key:

• Classical: Millions of years
• Quantum: Hours to days (with a large fault-tolerant quantum computer)

How It Works

Shor’s algorithm has two main parts:

1. Classical Reduction

Factoring is reduced to period finding:

• Pick random $a<N$ (the number to factor)
• Find the period $r$ of $f(x)=a^x\mathrm{mod}N$
• Use $r$ to find factors via $\gcd (a^{r/2}\pm 1,N)$

2. Quantum Period Finding

This is the quantum part:

1. Create superposition over all $x$: ${\sum }_x|x⟩|0⟩$
2. Compute $f(x)$ quantumly: ${\sum }_x|x⟩|a^x\mathrm{mod}N⟩$
3. Apply Quantum Fourier Transform to first register
4. Measure to get information about the period $r$

The QFT causes interference that reveals the period with high probability.

Circuit Overview

|0⟩^n ──H^⊗n──┬─── QFT ── Measure ──→ period info
              │
|0⟩^m ────────⊕── (modular exponentiation)

Resource Requirements

To factor an $n$-bit number:

• Qubits: $O(n)$ (roughly $2n-3n$ qubits)
• Gates: $O(n^3)$ (dominated by modular exponentiation)
• T-gates: Many millions for cryptographically relevant sizes

Current Status

We’re far from breaking real-world RSA. But it’s a matter of engineering, not fundamental obstacles.

Implications

1. Cryptographic transition: Moving to post-quantum cryptography
2. Security timeline: Data encrypted today could be decrypted later (“harvest now, decrypt later”)
3. Motivation for quantum computing: Major driver of quantum research and funding

Variants

• Simplified Shor’s: For specific numbers with known structure
• Quantum resource estimation: Ongoing research to reduce requirements
• Hybrid approaches: Some classical preprocessing

Historical Note

Shor’s algorithm was the “killer app” that launched serious interest in quantum computing. It showed quantum computers could solve a problem of real-world importance exponentially faster.

See also: Quantum Fourier Transform, Quantum Phase Estimation, Post-Quantum Cryptography, Quantum Advantage

Grover’s Algorithm

A quantum search algorithm providing quadratic speedup for finding items in unsorted databases.

Grover’s algorithm (1996) searches an unsorted database of $N$ items in $O(\sqrt{N})$ queries, compared to $O(N)$ classically. It’s one of the foundational quantum algorithms.

The Problem

Given a function $f(x)$ that returns 1 for exactly one “marked” item and 0 otherwise, find the marked item.

• Classical: Check items one by one → $O(N)$ queries on average
• Quantum (Grover): $O(\sqrt{N})$ queries

The Algorithm

Grover’s algorithm repeatedly applies two operations:

1. Oracle $O$

Marks the solution by flipping its sign: $$O|x⟩=\{\begin{array}{ll}-|x⟩& \text{if }f(x)=1\\ |x⟩& \text{otherwise}\end{array}$$

2. Diffusion $D$

Reflects amplitudes about their average (amplitude amplification): $$D=2|s⟩⟨s|-I$$ where $|s⟩=H^{\otimes n}|0{⟩}^{\otimes n}$ is the uniform superposition.

The Circuit

|0⟩^n ── H^⊗n ──┬── O ── D ──┬── ... ── Measure
                │            │
            (repeat √N times)

Geometric Intuition

Think of the state as a vector in a 2D plane:

• One axis: the marked state $|w⟩$
• Other axis: superposition of unmarked states $|s^{\prime }⟩$

Each Grover iteration rotates the state vector toward $|w⟩$ by angle $\approx 2/\sqrt{N}$.

After $\approx \frac{\pi }{4}\sqrt{N}$ iterations, the state points at (or very close to) $|w⟩$.

Example: N = 4

• 4 items, need to find 1 marked item
• Classical: 2.25 queries on average
• Grover: ~1 iteration (plus setup)

Starting state: $\frac{1}{2}(|00⟩+|01⟩+|10⟩+|11⟩)$

If $|10⟩$ is marked:

1. Oracle: $\frac{1}{2}(|00⟩+|01⟩-|10⟩+|11⟩)$
2. Diffusion: $|10⟩$ (exactly the answer!)

Key Properties

Optimal

Grover’s algorithm is provably optimal. No quantum algorithm can do better than $O(\sqrt{N})$ for unstructured search.

Works with Multiple Solutions

If $k$ items are marked, the algorithm finds one in $O(\sqrt{N/k})$ queries.

Requires Knowing When to Stop

Over-iterating causes the amplitude to “rotate past” the solution. You need to know approximately how many iterations to run.

Applications

• Database search: Searching unsorted data
• Cryptography: Speed up brute-force attacks (effectively halving key lengths)
• Satisfiability: Search for satisfying assignments
• Amplitude amplification: Generalization used in many algorithms

Practical Considerations

Quadratic speedup is significant but not transformative:

• $10^{12}$ → $10^6$ queries (meaningful)
• But requires a quantum oracle for $f$, and building this can be expensive

See also: Quantum Algorithm, Quantum Speedup

Quantum Fourier Transform

The quantum version of the discrete Fourier transform, a key subroutine in many quantum algorithms.

The Quantum Fourier Transform (QFT) is a linear transformation on quantum states that’s central to algorithms like Shor’s and quantum phase estimation.

Definition

The QFT maps computational basis states as:

$$QFT|j⟩=\frac{1}{\sqrt{N}}\sum _{k=0}^{N-1}{e}^{2\pi ijk/N}|k⟩$$

where $N=2^n$ for $n$ qubits.

Matrix Form

For 2 qubits ($N=4$):

$$QF{T}_4=\frac{1}{2}\left(\begin{array}{cccc}1& 1& 1& 1\\ 1& i& -1& -i\\ 1& -1& 1& -1\\ 1& -i& -1& i\end{array}\right)$$

Why It’s Important

Classical FFT: O(N log N)

The Fast Fourier Transform revolutionized signal processing.

Quantum QFT: O(n²) = O(log² N)

Exponentially faster! This speedup is key to Shor’s algorithm.

The Circuit

The QFT has a remarkably simple circuit using only Hadamards and controlled rotations:

|x₀⟩ ──H──R₂──R₃──...──Rₙ──────────────────
          │   │       │
|x₁⟩ ─────●───┼───...─┼────H──R₂──...──Rₙ₋₁──
              │       │        │       │
|x₂⟩ ─────────●───...─┼────────●───...─┼──────
                      │                │
...                   ...              ...
                      │                │
|xₙ⟩ ─────────────────●────────────────●──H──

Plus SWAP gates at the end to reverse bit order.

Gates used:

• Hadamard: $H$
• Controlled rotation: $R_k=\left(\begin{array}{cc}1& 0\\ 0& e^{2\pi i/2^k}\end{array}\right)$

Inverse QFT

The inverse is simply the conjugate transpose:

$$QF{T}^{†}=QF{T}^{-1}$$

Same circuit but with negative rotation angles, run in reverse.

Applications

Important Caveat

The QFT is fast, but there’s a catch:

• Input: Requires preparing the input state (often expensive)
• Output: Result is in amplitudes (can’t read them all directly)

The QFT is useful when it’s part of a larger algorithm that handles input/output appropriately.

Approximate QFT

For practical purposes, very small rotations ($R_k$ for large $k$) can be omitted:

$$\text{Approximate QFT}\approx \text{Full QFT}$$

This reduces circuit depth with minimal accuracy loss.

See also: Shor’s Algorithm, Quantum Phase Estimation, Quantum Algorithm

Quantum Phase Estimation

An algorithm to estimate the eigenvalue (phase) of a unitary operator. A key subroutine in many quantum algorithms.

Quantum Phase Estimation (QPE) determines the phase $\theta$ when a unitary $U$ acts on its eigenstate: $U|u⟩=e^{2\pi i\theta }|u⟩$.

The Problem

Given:

• A unitary operator $U$
• An eigenstate $|u⟩$ (or superposition of eigenstates)

Find: The phase $\theta$ such that $U|u⟩=e^{2\pi i\theta }|u⟩$

The Circuit

|0⟩ ──H────────●────────────────────QFT†── Measure (θ₀)
               │
|0⟩ ──H────────┼────●──────────────QFT†── Measure (θ₁)
               │    │
|0⟩ ──H────────┼────┼────●────────QFT†── Measure (θ₂)
               │    │    │
|u⟩ ──────────U¹───U²───U⁴────────────── (unchanged)

Key components:

1. Counting register: $n$ qubits initialized to $|0⟩$, determines precision
2. Target register: Holds the eigenstate $|u⟩$
3. Controlled-U operations: Apply $U^{2^k}$ controlled by qubit $k$
4. Inverse QFT: Extracts the phase as a binary number

How It Works

1. Hadamards create superposition in counting register
2. Controlled-$U$ operations encode phase information
3. The counting register ends up in state encoding $\theta$
4. Inverse QFT converts phase to binary representation
5. Measurement reads out $\theta$ (approximately)

Precision

With $n$ counting qubits:

• Precision: $2^{-n}$ (can distinguish $\theta$ values differing by $1/2^n$)
• Success probability: High for $\theta$ that’s exactly representable
• For general $\theta$: Concentration around true value

Applications

Shor’s Algorithm

QPE finds the period of modular exponentiation.

Quantum Chemistry (VQE-related)

Estimate eigenvalues of molecular Hamiltonians → ground state energies.

HHL Algorithm

Estimate eigenvalues for matrix inversion.

Quantum Counting

Count Grover solutions by estimating phase related to solution count.

Variants

Iterative Phase Estimation

Uses single counting qubit, repeated measurements. More noise-resilient, useful for NISQ.

Robust Phase Estimation

Handles noise and imperfect eigenstates better.

Quantum Eigenvalue Estimation

Generalizations for non-eigenstate inputs (get superposition of phases).

Resource Requirements

For $n$-bit precision:

• Counting qubits: $n$
• Controlled-$U$ calls: $2^n-1$ (can be expensive!)
• QFT on $n$ qubits

The cost of implementing controlled-$U^{2^k}$ is often the bottleneck.

See also: Quantum Fourier Transform, Shor’s Algorithm, VQE

VQE

Variational Quantum Eigensolver: a hybrid quantum-classical algorithm for finding ground state energies, especially useful in quantum chemistry.

VQE (Variational Quantum Eigensolver) is the flagship algorithm for near-term quantum computers. It’s a hybrid approach that uses a quantum computer to evaluate energies and a classical computer to optimize parameters.

The Goal

Find the ground state energy of a Hamiltonian $H$:

$$E_0=\underset{|\psi ⟩}{\min }⟨\psi |H|\psi ⟩$$

This is important for quantum chemistry (molecular ground states) and materials science.

How It Works

The Variational Principle

For any trial state $|\psi (\theta )⟩$: $$⟨\psi (\theta )|H|\psi (\theta )⟩\ge E_0$$

The energy of any guess is always ≥ true ground state energy. So minimize!

The Algorithm

┌─────────────────────────────────────────────────────┐
│                  Classical Computer                  │
│  ┌─────────────┐                    ┌────────────┐  │
│  │  Optimizer  │◄──── Energy ◄─────│   Measure  │  │
│  │   (θ→θ')    │                    │ expectation│  │
│  └──────┬──────┘                    └─────▲──────┘  │
│         │ New θ                           │         │
│         ▼                                 │         │
│  ┌──────────────────────────────────────────────┐  │
│  │              Quantum Computer                 │  │
│  │                                               │  │
│  │  |0⟩ ──[Ansatz(θ)]──── Measure               │  │
│  │                                               │  │
│  └──────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────┘

1. Prepare: Create parameterized trial state $|\psi (\theta )⟩$ on quantum computer
2. Measure: Estimate $⟨H⟩$ via measurements
3. Optimize: Classical optimizer updates $\theta$ to minimize energy
4. Repeat: Until convergence

The Ansatz

The ansatz is the parameterized circuit structure:

|0⟩ ──Ry(θ₁)──●──Ry(θ₃)──...
              │
|0⟩ ──Ry(θ₂)──⊕──Ry(θ₄)──...

Common ansatzes:

• UCCSD: Unitary coupled cluster (chemistry-inspired)
• Hardware-efficient: Native gates, easy to run
• Problem-specific: Tailored to symmetries

Measuring the Hamiltonian

Hamiltonians are decomposed into Pauli strings:

$$H=\sum _i{c}_i{P}_i$$

where $P_i$ are Pauli operators (e.g., $X\otimes Z\otimes I$).

Each term measured separately, results combined classically.

Challenges

Applications

• Quantum chemistry: Molecular energies, reaction pathways
• Materials science: Band structures, superconductivity
• Optimization: Via encoding problems as Hamiltonians

Relation to Other Algorithms

• QPE: More accurate but needs fault tolerance
• QAOA: Similar variational structure, for optimization
• VQA: VQE is a specific type of variational quantum algorithm

See also: Variational Quantum Algorithm, QAOA, Hamiltonian, NISQ

QAOA

Quantum Approximate Optimization Algorithm: a hybrid algorithm for combinatorial optimization problems.

QAOA (Quantum Approximate Optimization Algorithm) is a variational algorithm designed to find approximate solutions to combinatorial optimization problems. Introduced by Farhi et al. in 2014.

The Setup

Given an optimization problem encoded as a cost function $C(z)$ over bit strings $z$, find:

$$z^{\ast }=\arg \underset{z}{\max }C(z)$$

Examples: MaxCut, traveling salesman, scheduling, portfolio optimization.

The Algorithm

QAOA uses a parameterized quantum circuit alternating between two operations:

1. Problem Hamiltonian $H_C$

Encodes the cost function: $$U_C(\gamma )=e^{-i\gamma H_C}$$

2. Mixer Hamiltonian $H_B$

Creates transitions between states: $$U_B(\beta )=e^{-i\beta H_B}$$

Usually $H_B={\sum }_i{X}_i$ (sum of Pauli X on all qubits).

The Circuit (depth $p$)

|+⟩^n ── U_C(γ₁) ── U_B(β₁) ── U_C(γ₂) ── U_B(β₂) ── ... ── Measure

Parameters: $\vec{\gamma }=({\gamma }_1,\dots ,{\gamma }_p)$ and $\vec{\beta }=({\beta }_1,\dots ,{\beta }_p)$

The Variational Loop

1. Choose p (circuit depth)
2. Initialize parameters (γ, β)
3. Repeat:
   a. Run QAOA circuit on quantum computer
   b. Measure in computational basis
   c. Compute expected cost ⟨C⟩
   d. Classical optimizer updates (γ, β)
4. Return best solution found

Example: MaxCut

Problem: Partition graph vertices to maximize edges cut.

Encoding: $$H_C=\sum _{(i,j)\in E}\frac{1}{2}(1-Z_i{Z}_j)$$

Each edge contributes 1 if endpoints have different values (cut), 0 otherwise.

Performance

Theoretical

• $p\to \infty$: Converges to optimal solution
• Small $p$: Provides approximation

Practical (NISQ)

• Low depth ($p=1-3$) to manage noise
• Approximation quality varies by problem
• Ongoing research on when QAOA beats classical

Variants

Comparison with VQE

Challenges

• Parameter optimization: Non-convex landscape
• Barren plateaus: Can occur at high depth
• Classical competition: Best classical algorithms are strong
• Noise sensitivity: Errors accumulate with depth

See also: VQE, Variational Quantum Algorithm, NISQ, Quantum Speedup

Quantum Simulation

Using quantum computers to simulate quantum systems. Potentially the most impactful near-term application.

Quantum simulation uses controllable quantum systems to simulate other quantum systems. This is widely considered the most promising application of quantum computing, with potential breakthroughs in chemistry, materials science, and physics.

Feynman’s Vision