Quantum Computing

Quantum computing processes information stored in quantum states. A register of $n$ qubits is described by $2^n$ complex amplitudes. Gates manipulate the amplitudes, and quantum algorithms arrange for interference to concentrate probability on correct answers before measurement. For certain problems this gives provable speedups: exponential for factoring and for simulating quantum systems, and quadratic for unstructured search. For most everyday workloads it offers nothing. This hub summarizes the field as of late 2026 and points to the detailed pages on this site.

Table of contents

1. Pages in This Section
2. Core Concepts
3. Algorithm Landscape
4. Hardware Platforms
5. Error Correction and the Road to Fault Tolerance
   1. Milestones
6. Cryptographic Impact and Post-Quantum Cryptography
7. Applications
8. Programming and Tools
   1. Quick Start
   2. Cloud Access
9. Further Reading
10. See Also

Pages in This Section

How the topics depend on one another:

flowchart TD
    LA[Linear algebra] --> QI[Qubits, gates, measurement]
    QM[Quantum mechanics] --> QI
    QI --> Circ[Circuits and programming]
    QI --> Alg[Algorithms]
    Circ --> HW[Hardware platforms]
    HW --> QEC[Error correction and<br/>fault tolerance]
    QEC --> FT[Fault-tolerant algorithms:<br/>Shor, phase estimation, simulation]
    Alg --> FT
    Alg --> NISQ[Near-term heuristics:<br/>VQE, QAOA, sampling]
    Circ --> NISQ
    FT --> PQC[Cryptographic impact<br/>and post-quantum crypto]
    Alg --> Cx[Complexity: BQP]

Core Concepts

A qubit is a unit vector in $\mathbb{C}^2$:

An $n$-qubit state lives in the tensor product $(\mathbb{C}^2)^{\otimes n}$, which has dimension $2^n$. A computation applies a unitary $U$, built from a small set of one- and two-qubit gates, and then measures. Measuring in the computational basis returns bitstring $x$ with probability $\lvert\langle x\rvert U\lvert\psi_0\rangle\rvert^2$ (the Born rule).

Gates are unitary matrices. The two workhorses are

Applying $H$ to the first qubit of $\lvert00\rangle$ and then CNOT produces the Bell state

Algorithm Landscape

Quantum speedups are problem-specific. Speedups also differ in how firmly they are established: some are proven in the query model, some depend on unproven complexity assumptions, and some are heuristic.

Quantum singular value transformation (QSVT), introduced in 2019, gives one framework that covers amplitude amplification, Hamiltonian simulation, and linear-systems solvers. Most modern fault-tolerant algorithms are expressed in it. For derivations, see Quantum Algorithms Research.

Hardware Platforms

Several physical platforms compete, and none has won. They differ in speed, connectivity, coherence, and how they scale.

Headline qubit counts say little about capability on their own. The more useful measures are two-qubit gate error, coherence relative to gate time, connectivity, measurement and reset speed, and, increasingly, the number and error rate of logical qubits.

Error Correction and the Road to Fault Tolerance

Physical error rates of around $10^{-3}$ limit uncorrected circuits to a few thousand gates. Useful fault-tolerant algorithms need $10^{9}$ or more gates at logical error rates of $10^{-10}$ or lower. Quantum error correction (QEC) closes this gap by encoding each logical qubit in many physical qubits and repeatedly measuring stabilizers, which reveal errors without disturbing the encoded information.

flowchart LR
    subgraph Cycle["One QEC cycle (repeated about every microsecond)"]
        direction LR
        D[Data qubits<br/>hold logical state] --> S[Measure stabilizers<br/>via ancilla qubits]
        S --> Syn[Syndrome bits]
        Syn --> Dec[Real-time classical<br/>decoder]
        Dec --> Fix[Track or apply<br/>Pauli correction]
        Fix --> D
    end

The threshold theorem says that when physical error rates are below a threshold $p_{\text{th}}$, logical errors can be made arbitrarily small at polylogarithmic overhead. For the surface code of distance $d$,

with $p_{\text{th}} \approx 1\%$ under circuit-level noise. The ratio $\Lambda = p_L(d)/p_L(d+2)$ measures how much each increase in distance helps. Below threshold, $\Lambda > 1$.

Magic-state distillation or cultivation supplies the non-Clifford $T$ gates needed for universality. These factories often dominate resource estimates.

Milestones

timeline
    title Selected milestones
    1982 : Feynman proposes quantum simulation
    1994 : Shor's factoring algorithm
    1995 : Shor's 9-qubit code, first QEC scheme
    1996 : Grover search
    1997 : Kitaev surface and toric codes
    2019 : Google Sycamore random-circuit sampling
    2023 : Harvard and QuEra run circuits on 48 logical qubits
    2024 : Google Willow surface code below threshold, d = 7
    2025 : Gidney estimates RSA-2048 needs under 1M noisy qubits
         : Google Quantum Echoes verifiable-advantage experiment
         : Quantinuum Helios trapped-ion system
    2029 : IBM Starling target, 200 logical qubits

• Google Willow (Nature, Dec 2024): a 105-qubit superconducting chip ran surface-code memories at distances 3, 5, and 7. The logical error rate fell by a factor of about 2.14 with each step in distance, reaching roughly 0.14% per cycle at $d=7$. This was the first clear demonstration of below-threshold scaling.
• Resource estimates for breaking RSA: Gidney (2025) estimated that 2048-bit RSA could be factored in under a week with fewer than one million noisy qubits, down from the roughly 20 million estimated in 2019. The machines that exist today are still orders of magnitude short of this.
• Verifiable advantage: in 2025 Google reported its “Quantum Echoes” out-of-time-order-correlator experiment on Willow (Nature). Its output can be checked, unlike random-circuit sampling. The practical relevance of such demonstrations is still debated.
• Roadmaps: IBM’s published roadmap targets a fault-tolerant machine, Starling, for 2029, running about $10^8$ gates on 200 logical qubits with qLDPC codes. Other vendors, including Quantinuum, QuEra, and PsiQuantum, have announced fault-tolerance targets for the late 2020s. Treat all such dates as goals, not guarantees.

The industry usually divides progress into three eras:

Error mitigation techniques such as zero-noise extrapolation, probabilistic error cancellation, and readout correction reduce bias in expectation values without encoding. Their sampling cost grows exponentially with circuit size, so they serve as a bridge to error correction, not a replacement for it.

Cryptographic Impact and Post-Quantum Cryptography

A large enough fault-tolerant machine running Shor’s algorithm would break RSA, finite-field Diffie-Hellman, and elliptic-curve cryptography. Grover’s algorithm only halves the effective key length of symmetric ciphers and hashes, so AES-256 and SHA-384 remain adequate. The immediate concern is “harvest now, decrypt later”: adversaries can record encrypted traffic today and decrypt it once quantum computers become capable enough.

In August 2024, NIST published the first post-quantum standards:

NIST’s transition guidance (IR 8547) proposes deprecating quantum-vulnerable public-key algorithms after 2030 and disallowing them after 2035. Hybrid key exchange (X25519 combined with ML-KEM-768) is already the default in current major browsers and in OpenSSH. Quantum key distribution (QKD) takes a different approach, deriving security from physics rather than computational hardness, but it requires dedicated hardware and authenticated channels. National security agencies generally recommend PQC over QKD for most uses. For details, see Cryptography: Foundations & Post-Quantum.

Applications

Realistic expectations, ordered from most to least established:

Programming and Tools

Most quantum software is Python-based. It is usually written at the circuit level and compiled (“transpiled”) to each device’s native gates and qubit connectivity.

flowchart TD
    App[Application / algorithm] --> SDK[SDK: Qiskit, Cirq, QDK, PennyLane, CUDA-Q]
    SDK --> IR[Circuit IR: OpenQASM 3, QIR]
    IR --> Comp[Transpiler: layout, routing,<br/>gate synthesis, optimization]
    Comp --> Run{Target}
    Run --> Sim[Simulator<br/>statevector, MPS, stabilizer]
    Run --> Cloud[Cloud QPU service]
    Cloud --> Ctrl[Control electronics<br/>pulses, readout, QEC decoding]
    Ctrl --> QPU[Physical qubits]

Quick Start

Install Qiskit into a virtual environment. Qiskit 2.x requires Python 3.10 or later and a 64-bit platform.

python3 -m venv .venv && source .venv/bin/activate
pip install qiskit qiskit-ibm-runtime   # IBM SDK + cloud runtime client
pip install cirq                        # Google Cirq (optional)
pip install qdk                         # Microsoft QDK: Q#, OpenQASM, resource estimation (optional)

A Bell state, simulated locally with Qiskit’s reference StatevectorSampler:

from qiskit import QuantumCircuit
from qiskit.primitives import StatevectorSampler

qc = QuantumCircuit(2)
qc.h(0)          # superposition on qubit 0
qc.cx(0, 1)      # entangle qubit 1 with qubit 0
qc.measure_all() # adds a classical register named "meas"

result = StatevectorSampler().run([qc], shots=1000).result()
print(result[0].data.meas.get_counts())   # about 500 '00' and 500 '11', never '01' or '10'

The same circuit in Cirq:

import cirq

q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit(cirq.H(q0), cirq.CNOT(q0, q1), cirq.measure(q0, q1, key="m"))
result = cirq.Simulator().run(circuit, repetitions=1000)
print(result.histogram(key="m"))   # Counter({0: ~500, 3: ~500})

To run on IBM hardware, create an account on the IBM Quantum Platform, which includes a free Open Plan with a monthly allocation of QPU time. Save the API key once with QiskitRuntimeService.save_account(...), then transpile the circuit to the device’s native instruction set architecture (ISA) and submit it:

from qiskit.transpiler import generate_preset_pass_manager
from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 as Sampler

service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)

isa_circuit = generate_preset_pass_manager(backend=backend, optimization_level=1).run(qc)
job = Sampler(mode=backend).run([isa_circuit], shots=1000)
print(job.result()[0].data.meas.get_counts())   # mostly '00' and '11', plus some hardware noise

On real hardware, a few percent of shots will land on 01 and 10 because of gate and readout errors. Measuring that noise is a useful first exercise.

Cloud Access

Further Reading

Textbooks

• Nielsen & Chuang, Quantum Computation and Quantum Information (10th anniversary ed., 2010). This is the standard reference.
• Aaronson, Quantum Computing Since Democritus (2013), on complexity-theoretic perspectives.
• Preskill, Lecture Notes for Physics 219 (Caltech), free online, especially the chapters on error correction and fault tolerance.
• Preskill, “Quantum Computing in the NISQ era and beyond,” Quantum 2, 79 (2018), the paper that named the NISQ era.

Online

• IBM Quantum Learning: courses and tutorials that replace the retired Qiskit Textbook.
• Qiskit documentation and Cirq documentation.
• Quantum Algorithm Zoo: a catalog of known quantum algorithms and their speedups.
• Error Correction Zoo: a catalog of classical and quantum codes.
• arXiv quant-ph, Quantum (open access), npj Quantum Information.
• Quantum Computing Stack Exchange.

See Also

• Introduction to Quantum Computing: the full walkthrough of gates, algorithms, error correction, and hardware.
• Quantum Mechanics: the physics underlying qubits.
• Quantum Algorithms Research: rigorous theory and complexity.
• Cryptography: Foundations & Post-Quantum: lattice cryptography and migration.
• AI/ML Documentation and the Artificial Intelligence Hub: where quantum machine learning connects to classical ML.