quantum-computing

name	quantum-computing
description	Quantum computing fundamentals, quantum gates, algorithms, circuit design, and practical implementation using Qiskit and Cirq. Covers superposition, entanglement, interference, and real-world quantum applications.
origin	Orythix

Quantum Computing

A comprehensive guide to quantum computing concepts, circuit design, and practical implementation.

When to Use

• Explaining quantum computing fundamentals and concepts
• Designing quantum circuits and algorithms
• Writing quantum code in Qiskit, Cirq, or PennyLane
• Analyzing quantum algorithm complexity and advantages
• Discussing quantum hardware, noise, and error correction
• Comparing classical vs. quantum approaches to problems

---

Core Concepts

1. Qubits vs Classical Bits

Classical bits are either 0 or 1. Qubits exist in a superposition — a linear combination of both states simultaneously until measured.

|ψ⟩ = α|0⟩ + β|1⟩
where |α|² + |β|² = 1

• |α|² = probability of measuring 0
• |β|² = probability of measuring 1
• After measurement, the qubit collapses to a definite classical state

2. Superposition

A qubit can represent 0 and 1 simultaneously. An n-qubit system can represent 2ⁿ states simultaneously — exponential parallelism.

# Qiskit: Put a qubit into superposition using Hadamard gate
from qiskit import QuantumCircuit

qc = QuantumCircuit(1, 1)
qc.h(0)          # Hadamard: |0⟩ → (|0⟩ + |1⟩) / √2
qc.measure(0, 0) # 50% chance of 0, 50% chance of 1

3. Entanglement

Two qubits are entangled when the state of one instantly determines the state of the other, regardless of distance.

# Create a Bell state (maximally entangled pair)
qc = QuantumCircuit(2, 2)
qc.h(0)          # Superpose qubit 0
qc.cx(0, 1)      # CNOT: entangle qubit 1 with qubit 0
qc.measure([0, 1], [0, 1])
# Result: always 00 or always 11 — never 01 or 10

4. Interference

Quantum algorithms use constructive interference to amplify correct answers and destructive interference to cancel wrong ones.

---

Quantum Gates (Single-Qubit)

Gate	Symbol	Matrix	Effect
Hadamard	H	1/√2 [[1,1],[1,-1]]	Superposition
Pauli-X	X	[[0,1],[1,0]]	Bit flip (NOT)
Pauli-Y	Y	[[0,-i],[i,0]]	Bit + phase flip
Pauli-Z	Z	[[1,0],[0,-1]]	Phase flip
S gate	S	[[1,0],[0,i]]	90° phase rotation
T gate	T	[[1,0],[0,e^{iπ/4}]]	45° phase rotation
Rx(θ)	Rx	rotation around X-axis	Parameterized rotation

Quantum Gates (Two-Qubit)

Gate	Symbol	Effect
CNOT	CX	Flip target if control is |1⟩
CZ	CZ	Phase flip target if both |1⟩
SWAP	SWAP	Exchange two qubit states
Toffoli	CCX	CNOT with two controls

---

Quantum Algorithms

Deutsch-Jozsa Algorithm

Problem: Determine if a function f(x) is constant or balanced with one query. Classical: Needs 2^(n-1) + 1 queries worst case. Quantum: Always 1 query — exponential speedup.

from qiskit import QuantumCircuit

def deutsch_jozsa(oracle: QuantumCircuit, n: int) -> QuantumCircuit:
    """n = number of input qubits; oracle implements f(x)."""
    qc = QuantumCircuit(n + 1, n)
    # Initialize output qubit to |1⟩
    qc.x(n)
    # Apply Hadamard to all qubits
    qc.h(range(n + 1))
    # Apply oracle
    qc = qc.compose(oracle)
    # Apply Hadamard to input qubits
    qc.h(range(n))
    # Measure input qubits — all 0s = constant, any 1 = balanced
    qc.measure(range(n), range(n))
    return qc

Grover's Search Algorithm

Problem: Find a marked item in an unsorted database of N items. Classical: O(N) average. Quantum: O(√N) — quadratic speedup.

from qiskit import QuantumCircuit
import numpy as np

def grovers(n_qubits: int, target: int) -> QuantumCircuit:
    """Search for `target` among 2^n_qubits items."""
    N = 2 ** n_qubits
    iterations = int(np.pi / 4 * np.sqrt(N))  # Optimal iterations

    qc = QuantumCircuit(n_qubits, n_qubits)
    # Superpose all states
    qc.h(range(n_qubits))

    for _ in range(iterations):
        # Oracle: flip phase of target state
        target_bits = format(target, f'0{n_qubits}b')
        for i, bit in enumerate(reversed(target_bits)):
            if bit == '0':
                qc.x(i)
        qc.h(n_qubits - 1)
        qc.mcx(list(range(n_qubits - 1)), n_qubits - 1)
        qc.h(n_qubits - 1)
        for i, bit in enumerate(reversed(target_bits)):
            if bit == '0':
                qc.x(i)

        # Diffuser (amplitude amplification)
        qc.h(range(n_qubits))
        qc.x(range(n_qubits))
        qc.h(n_qubits - 1)
        qc.mcx(list(range(n_qubits - 1)), n_qubits - 1)
        qc.h(n_qubits - 1)
        qc.x(range(n_qubits))
        qc.h(range(n_qubits))

    qc.measure(range(n_qubits), range(n_qubits))
    return qc

Quantum Fourier Transform (QFT)

Foundation of Shor's algorithm and phase estimation.

from qiskit import QuantumCircuit
import numpy as np

def qft(n: int) -> QuantumCircuit:
    """Quantum Fourier Transform on n qubits."""
    qc = QuantumCircuit(n)
    for j in range(n):
        qc.h(j)
        for k in range(j + 1, n):
            angle = np.pi / (2 ** (k - j))
            qc.cp(angle, k, j)  # Controlled phase
    # Swap qubits to correct bit ordering
    for i in range(n // 2):
        qc.swap(i, n - i - 1)
    return qc

Shor's Factoring Algorithm

Problem: Factor a large integer N into primes. Classical: Sub-exponential but slow for large N. Quantum: Polynomial time — breaks RSA encryption at scale.

Key steps:

1. Choose random a < N
2. Compute GCD(a, N) — if > 1, factor found classically
3. Use QFT-based period finding to find r where a^r mod N = 1
4. Use r to compute factors: GCD(a^(r/2) ± 1, N)

---

Running on Real Hardware (Qiskit)

from qiskit import QuantumCircuit, transpile
from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2

# Connect to IBM Quantum
service = QiskitRuntimeService(channel="ibm_quantum", token="YOUR_TOKEN")
backend = service.least_busy(operational=True, simulator=False)

# Build your circuit
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

# Transpile for the specific backend's native gates and topology
transpiled = transpile(qc, backend=backend, optimization_level=3)

# Run with SamplerV2
sampler = SamplerV2(backend)
job = sampler.run([transpiled], shots=1024)
result = job.result()
print(result[0].data.meas.get_counts())

Simulation (No Hardware Needed)

from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator

sim = AerSimulator()

qc = QuantumCircuit(3, 3)
qc.h(0)
qc.cx(0, 1)
qc.cx(0, 2)  # 3-qubit GHZ state
qc.measure_all()

transpiled = transpile(qc, sim)
result = sim.run(transpiled, shots=1024).result()
counts = result.get_counts()
print(counts)  # Should show only '000' and '111'

---

Google Cirq Patterns

import cirq

# Create qubits
q0, q1 = cirq.LineQubit.range(2)

# Build circuit
circuit = cirq.Circuit([
    cirq.H(q0),
    cirq.CNOT(q0, q1),
    cirq.measure(q0, q1, key='result')
])
print(circuit)

# Simulate
simulator = cirq.Simulator()
result = simulator.run(circuit, repetitions=1000)
print(result.histogram(key='result'))

---

PennyLane (Quantum ML)

import pennylane as qml
import numpy as np

dev = qml.device("default.qubit", wires=2)

@qml.qnode(dev)
def variational_circuit(params):
    qml.RX(params[0], wires=0)
    qml.RY(params[1], wires=1)
    qml.CNOT(wires=[0, 1])
    return qml.expval(qml.PauliZ(0))

# Optimize using gradient descent
params = np.array([0.1, 0.2], requires_grad=True)
opt = qml.GradientDescentOptimizer(stepsize=0.1)
for step in range(100):
    params, cost = opt.step_and_cost(variational_circuit, params)
    if step % 20 == 0:
        print(f"Step {step}: cost = {cost:.4f}")

---

Quantum Error Correction

Real quantum hardware is noisy. Error correction encodes logical qubits into many physical qubits.

# 3-qubit bit-flip code (protects against X errors)
from qiskit import QuantumCircuit

def bit_flip_encode() -> QuantumCircuit:
    qc = QuantumCircuit(3)
    # Encode logical |0⟩ = |000⟩, logical |1⟩ = |111⟩
    qc.cx(0, 1)
    qc.cx(0, 2)
    return qc

def bit_flip_correct() -> QuantumCircuit:
    qc = QuantumCircuit(3, 1)
    # Majority vote using ancilla measurement
    qc.cx(0, 1)
    qc.cx(0, 2)
    qc.ccx(1, 2, 0)  # Toffoli corrects qubit 0
    qc.measure(0, 0)
    return qc

Key codes:

• 3-qubit code: Protects against single bit-flip errors
• Shor code (9 qubits): Protects against any single-qubit error
• Surface code: Most hardware-practical, ~1% error threshold

---

Quantum Advantage Landscape

Problem	Classical	Quantum	Advantage
Unstructured search	O(N)	O(√N)	Quadratic
Integer factoring	Sub-exp	Polynomial	Exponential
Simulation (chemistry)	Exp	Polynomial	Exponential
Linear systems (HHL)	O(N)	O(log N)	Exponential*
Optimization (QAOA)	NP-hard	Heuristic	Unclear
Machine learning	Varies	Varies	Case-dependent

*With caveats on data loading (QRAM problem)

---

NISQ Era Algorithms (Current Hardware)

Current devices are Noisy Intermediate-Scale Quantum (NISQ) — 50-1000 qubits, no error correction.

QAOA (Quantum Approximate Optimization)

from qiskit.circuit.library import QAOAAnsatz
from qiskit_algorithms import QAOA
from qiskit_algorithms.optimizers import COBYLA

# Max-cut on a graph
from qiskit_optimization.applications import Maxcut
import networkx as nx

G = nx.Graph()
G.add_edges_from([(0,1), (0,3), (1,2), (2,3)])
maxcut = Maxcut(G)
problem = maxcut.to_quadratic_program()

qaoa = QAOA(optimizer=COBYLA(), reps=2)
result = qaoa.compute_minimum_eigenvalue(problem.to_ising()[0])
print(maxcut.interpret(result))

VQE (Variational Quantum Eigensolver)

Used for quantum chemistry — find ground state energy of molecules.

from qiskit_nature.second_q.drivers import PySCFDriver
from qiskit_nature.second_q.algorithms import GroundStateEigensolver
from qiskit_algorithms import VQE

# H2 molecule ground state energy
driver = PySCFDriver(atom="H 0 0 0; H 0 0 0.735", basis="sto3g")
problem = driver.run()

vqe = VQE(...)
solver = GroundStateEigensolver(mapper, vqe)
result = solver.solve(problem)
print(f"Ground state energy: {result.total_energies[0]:.4f} Hartree")

---

Key Terms Quick Reference

Term	Definition
Qubit	Quantum bit — superposition of 0 and 1
Gate	Unitary operation on qubits
Circuit	Sequence of gates applied to qubits
Entanglement	Correlated quantum states across qubits
Superposition	Linear combination of basis states
Interference	Amplitude combination — can amplify or cancel
Decoherence	Loss of quantum properties due to environment
Fidelity	Measure of how close a state is to ideal
NISQ	Noisy Intermediate-Scale Quantum (current era)
Oracle	Black-box quantum operation encoding a problem
Ansatz	Parameterized quantum circuit for variational algorithms
T1/T2	Qubit relaxation / dephasing time constants

---

Recommended Libraries

Library	Use Case	Install
Qiskit	IBM hardware + simulation	pip install qiskit qiskit-aer
Cirq	Google hardware + research	pip install cirq
PennyLane	Quantum ML + autodiff	pip install pennylane
QuTiP	Open quantum systems	pip install qutip
Strawberry Fields	Photonic quantum computing	pip install strawberryfields

---

Anti-Patterns to Avoid

• Measuring mid-circuit without reset — destroys superposition, ruins entanglement
• Expecting deterministic results — quantum circuits are probabilistic; always use sufficient shots
• Ignoring transpilation — raw circuits may not match hardware topology; always transpile()
• Deep circuits on NISQ — gate count × error rate ≈ failure; keep circuits shallow
• Assuming QFT = DFT — QFT gives phases, not amplitudes; extracting amplitudes still costs exponential reads
• Simulating >30 qubits classically — state vector grows as 2ⁿ; use approximate simulators beyond ~20 qubits