✍️ 필사 모드: Quantum Computing for Developers Complete Guide 2025: Qiskit, Cirq, Algorithms, Supremacy

Introduction: Why Quantum Computing?

Quantum computing fundamentally changes the computing paradigm. In 2019, Google's Sycamore first demonstrated quantum supremacy; in 2024, IBM's Condor surpassed 1121 qubits; and as of 2025, IBM, Google, Quantinuum, IonQ, and PsiQuantum are in fierce competition. Quantum computing is not a magic bullet, but for specific problems (integer factoring, certain optimizations, quantum simulation) it has the potential to solve in hours what classical computers would take thousands of years.

This guide targets software developers, not physicists. With only basic linear algebra, you can follow along with intuitive explanations and practical Qiskit/Cirq code. We cover quantum mechanics fundamentals, algorithms, NISQ-era practice, quantum ML, and Post-Quantum cryptography - everything developers need.

1. Why Quantum Computing Matters

1.1 Classical vs Quantum Complexity

1.2 What Quantum Can Help With

• Cryptography: Breaking public-key crypto like RSA, ECC (Shor)
• Chemistry: Molecular energy, drug discovery, fertilizer synthesis
• Materials: Superconductors, battery design
• Optimization: Logistics, portfolios, scheduling
• Machine Learning: Certain kernel methods, quantum neural networks
• Finance: Option pricing, Monte Carlo

1.3 What Quantum Can't Help With

• General parallelism: Measurement collapses to a single outcome
• Most classical algorithms: Sorting, hash tables get no advantage
• All of NP-complete: Only quadratic via Grover
• Everyday apps: Web servers, games see little benefit

2. Classical Bits vs Qubits

2.1 Bit vs Qubit

A classical bit is 0 or 1. A qubit can be in a superposition $|\psi\rangle = \alpha|0\rangle + \beta|1\rangle$ with $|\alpha|^2 + |\beta|^2 = 1$.

When measured, it yields 0 with probability $|\alpha|^2$ and 1 with probability $|\beta|^2$. After measurement, the state collapses.

2.2 State Space of n Qubits

• Classical n bits: one of $2^n$ states
• Quantum n qubits: vector of $2^n$ complex amplitudes (all simultaneously)

The state vector of 300 qubits has $2^{300}$ complex numbers, more than the atoms in the universe. This is the potential of quantum computing.

3. Quantum Mechanics Fundamentals

3.1 Superposition

Qubits can exist in linear combinations of basis states before measurement.

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

Measuring this state yields 0 or 1 with 50% each.

3.2 Entanglement

Entangled qubits cannot be described separately.

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

Measuring the first qubit forces the second to the same value with 100% correlation, even across distance.

3.3 Measurement

Measurement destroys superposition. It collapses the state into the observed basis state. Quantum algorithms must carefully engineer interference so the measurement outcome carries meaningful information.

3.4 No-Cloning Theorem

It is impossible to perfectly copy an arbitrary unknown quantum state. This underpins quantum communication and quantum cryptography.

4. Bloch Sphere Visualization

The pure state of a single qubit maps to a point on the surface of a 3D sphere.

• North pole: $|0\rangle$
• South pole: $|1\rangle$
• Equator: superposition states

$|\psi\rangle = \cos(\theta/2)|0\rangle + e^{i\phi}\sin(\theta/2)|1\rangle$

5. Quantum Gates

5.1 Single-Qubit Gates

Pauli gates

• X (NOT): Bit flip, $|0\rangle \leftrightarrow |1\rangle$
• Y: Bit + phase flip
• Z: Phase flip, $|1\rangle \to -|1\rangle$

Hadamard gate: Creates superposition. Applying the Hadamard maps the basis states to balanced superpositions.

Hadamard action:
  Hadamard |0>  ->  (|0> + |1>) / sqrt(2)
  Hadamard |1>  ->  (|0> - |1>) / sqrt(2)

Matrix form:
  (1/sqrt(2)) * [[1,  1],
                 [1, -1]]

Phase gates

• S: 90 degrees phase
• T: 45 degrees phase

Rotation gates

• Rx(theta), Ry(theta), Rz(theta): rotations around each axis

5.2 Multi-Qubit Gates

CNOT: Flips target if control is 1.

CNOT truth table:
|00> -> |00>
|01> -> |01>
|10> -> |11>
|11> -> |10>

Toffoli (CCNOT): 3-qubit gate, universal for classical computation.

SWAP: Swaps two qubits.

Controlled-Z, Controlled-Phase: Phase-based controls.

5.3 Universal Gate Sets

The set {H, T, CNOT} is a universal gate set: any quantum operation can be approximated to arbitrary accuracy.

6. Quantum Circuits and Measurement

6.1 Reading Circuit Diagrams

Quantum circuits flow left to right in time. Each horizontal line is a qubit, each box a gate, and measurement icons mark the end.

6.2 Reversibility

All quantum gates except measurement are unitary and reversible, unlike classical gates such as AND.

7. Qiskit Deep Dive

7.1 Installation

pip install qiskit qiskit-aer qiskit-ibm-runtime

7.2 Basic Circuit

from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator

qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])

print(qc)

simulator = AerSimulator()
compiled = transpile(qc, simulator)
result = simulator.run(compiled, shots=1024).result()
counts = result.get_counts()
print(counts)  # e.g. {'00': 512, '11': 512}

This creates a Bell state. Measurements yield only 00 or 11.

7.3 Transpiler

Real hardware has specific gate sets and coupling topologies. The transpiler converts abstract circuits to hardware-executable form.

from qiskit import transpile

compiled = transpile(qc, backend, optimization_level=3)
print(f"Depth: {compiled.depth()}")
print(f"Gate count: {compiled.count_ops()}")

7.4 IBM Quantum Hardware

from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 as Sampler

service = QiskitRuntimeService(channel="ibm_quantum", token="YOUR_TOKEN")
backend = service.least_busy(operational=True, simulator=False)
print(f"Using backend: {backend.name}")

sampler = Sampler(backend)
job = sampler.run([compiled])
result = job.result()
print(result[0].data.meas.get_counts())

7.5 Simulator Types

• AerSimulator: State vector (exact, small circuits)
• qasm_simulator: Measurement sampling
• statevector_simulator: Direct state vector
• unitary_simulator: Unitary matrix
• Noise models: Hardware noise modeling

from qiskit_aer.noise import NoiseModel, depolarizing_error

noise_model = NoiseModel()
error = depolarizing_error(0.01, 1)
noise_model.add_all_qubit_quantum_error(error, ['h', 'x'])

sim = AerSimulator(noise_model=noise_model)
result = sim.run(compiled).result()

8. Cirq Deep Dive

8.1 Installation

pip install cirq

8.2 Basic Example

import cirq

q0, q1 = cirq.LineQubit.range(2)

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

print(circuit)

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

8.3 Cirq vs Qiskit

• Qiskit: IBM ecosystem, rich docs, industry standard
• Cirq: Google/Sycamore, NISQ-friendly, experimental features
• Qubit models: Cirq has GridQubit, LineQubit, NamedQubit
• Gate sets: Cirq gate sets match Google hardware

9. Famous Quantum Algorithms

9.1 Deutsch-Jozsa

Problem: Is $f: \{0,1\}^n \to \{0,1\}$ constant or balanced?

• Classical worst case: $2^{n-1}+1$ calls
• Quantum: 1 call

Historically the first to show quantum speedup.

def deutsch_jozsa(n, oracle):
    qc = QuantumCircuit(n+1, n)
    qc.x(n)
    qc.h(range(n+1))
    qc.compose(oracle, inplace=True)
    qc.h(range(n))
    qc.measure(range(n), range(n))
    return qc

9.2 Grover's Search

$O(\sqrt{N})$ unstructured search. Quadratic speedup over classical $O(N)$.

from qiskit.circuit.library import GroverOperator
from qiskit.algorithms import AmplificationProblem, Grover

oracle = QuantumCircuit(3)
oracle.cz(0, 2)
oracle.cz(1, 2)

problem = AmplificationProblem(oracle, is_good_state=['101', '111'])
grover = Grover(quantum_instance=simulator)
result = grover.amplify(problem)
print(f"Top measurement: {result.top_measurement}")

9.3 Shor's Factoring

Solves integer factoring in polynomial time. Threatens RSA if enough qubits exist.

Shor algorithm overview:
1. Pick random a where 1 < a < N
2. Compute gcd(a, N); if not 1, factor found
3. Quantum step: find period r of a^x mod N
4. If r even, compute gcd(a^(r/2) +/- 1, N) for factors

9.4 Quantum Fourier Transform (QFT)

Quantum version of DFT. Core to Shor, phase estimation.

def qft(n):
    qc = QuantumCircuit(n)
    for j in range(n):
        qc.h(j)
        for k in range(j+1, n):
            qc.cp(np.pi / (2 ** (k-j)), k, j)
    for i in range(n//2):
        qc.swap(i, n-1-i)
    return qc

9.5 Bernstein-Vazirani

Find a hidden bit string with a single oracle query. Generalization of Deutsch-Jozsa.

10. Variational Quantum Algorithms

10.1 VQE

Computes molecular ground-state energy. A parameterized quantum circuit (ansatz) is trained by a classical optimizer.

from qiskit.algorithms.minimum_eigensolvers import VQE
from qiskit.algorithms.optimizers import COBYLA
from qiskit.circuit.library import EfficientSU2

ansatz = EfficientSU2(num_qubits=2, reps=2)
optimizer = COBYLA(maxiter=100)

vqe = VQE(estimator, ansatz, optimizer)
result = vqe.compute_minimum_eigenvalue(hamiltonian)
print(f"Ground state energy: {result.eigenvalue}")

10.2 QAOA

Hybrid quantum-classical algorithm for combinatorial optimization (Max-Cut, TSP).

from qiskit.algorithms.minimum_eigensolvers import QAOA

qaoa = QAOA(sampler, optimizer, reps=2)
result = qaoa.compute_minimum_eigenvalue(operator=cost_operator)

11. Quantum Machine Learning (QML)

11.1 Quantum Neural Networks

from qiskit_machine_learning.neural_networks import EstimatorQNN
from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap

feature_map = ZZFeatureMap(feature_dimension=2, reps=1)
ansatz = RealAmplitudes(num_qubits=2, reps=1)

qc = QuantumCircuit(2)
qc.compose(feature_map, inplace=True)
qc.compose(ansatz, inplace=True)

qnn = EstimatorQNN(
    circuit=qc,
    input_params=feature_map.parameters,
    weight_params=ansatz.parameters,
)

11.2 Quantum Kernel Methods

from qiskit_machine_learning.kernels import FidelityQuantumKernel

kernel = FidelityQuantumKernel(feature_map=feature_map)
from sklearn.svm import SVC
svc = SVC(kernel=kernel.evaluate)
svc.fit(X_train, y_train)

12. Quantum Supremacy

12.1 Google Sycamore (2019)

53-qubit Sycamore performed random circuit sampling in 200 seconds, estimated 10,000 years on IBM Summit. IBM later rebutted with efficient simulation (days), but this was the first supremacy demonstration.

12.2 USTC Jiuzhang (2020)

Gaussian Boson Sampling on photonic hardware, 200 seconds vs 2.5 billion years classical estimate.

12.3 IBM Roadmap (2025)

• 2019 Falcon: 27 qubits
• 2021 Eagle: 127 qubits
• 2022 Osprey: 433 qubits
• 2023 Condor: 1121 qubits
• 2024 Flamingo: 1386 qubits (multi-chip)
• 2025 Kookaburra: 4158 qubits (target)

12.4 Useful Quantum Advantage

Supremacy proves "useless" problems. Real-world useful quantum advantage is still unclaimed - the main goal of the NISQ era.

13. Quantum Hardware Platforms

13.1 Platform Comparison

13.2 Error Rates

14. NISQ Era and Error Correction

14.1 NISQ

John Preskill coined NISQ for 50-1000 qubit noisy machines. Characteristics:

• No full error correction
• Limited circuit depth
• Hybrid algorithms (VQE, QAOA) popular
• Exploring useful advantage

14.2 Quantum Error Correction

Unlike classical, quantum must correct continuous errors (X, Z, and combinations) without cloning. Shor 9-qubit code, Surface code, LDPC-based.

• Surface Code: 2D lattice, ~1% threshold, most promising
• Color Code: Surface Code extension
• LDPC: Active research area

14.3 Fault-Tolerant Quantum Computing

Full error correction with fault-tolerant operations. Useful Shor (RSA-2048) estimated to need millions of physical qubits.

15. Quantum Advantage Applications

15.1 Chemistry and Drugs

• Molecular energy calculation
• Reaction mechanism simulation
• Drug screening
• Enzyme modeling (FeMoco)

15.2 Optimization

• Logistics route optimization
• Portfolio optimization
• Graph problems (Max-Cut)
• Manufacturing scheduling

15.3 Finance

• Monte Carlo acceleration
• Option pricing
• Risk analysis
• Fraud detection (QML)

15.4 Materials

• Superconductor design
• Battery chemistry
• Catalyst discovery

16. Post-Quantum Cryptography (PQC)

16.1 Why

Shor's algorithm can break RSA, ECC, DH in polynomial time. Once large enough quantum computers exist, TLS, VPN, and signatures collapse. "Harvest Now, Decrypt Later" attacks are happening today.

16.2 NIST PQC Standards

In 2024 NIST published the first PQC standards:

• FIPS 203 (ML-KEM): CRYSTALS-Kyber based key encapsulation
• FIPS 204 (ML-DSA): CRYSTALS-Dilithium based signatures
• FIPS 205 (SLH-DSA): SPHINCS+ hash-based signatures

16.3 Algorithm Families

• Lattice: Kyber, Dilithium, Falcon - main
• Hash: SPHINCS+ - stateless
• Code: Classic McEliece - conservative
• Multivariate: Rainbow (broken)
• Isogeny: SIDH (broken 2022)

16.4 Migration Strategy

• Crypto Agility: Design for algorithm swap
• Hybrid modes: Combine classical + PQC (TLS 1.3 extension)
• Inventory: Map current crypto usage
• Timeline: 2030-2035 PQC migration goal

17. Hands-on: Bell State and Teleportation

17.1 Bell State

from qiskit import QuantumCircuit

bell = QuantumCircuit(2, 2)
bell.h(0)
bell.cx(0, 1)
bell.measure([0, 1], [0, 1])

17.2 Quantum Teleportation

Transfer Alice's unknown state $|\psi\rangle$ to Bob using entanglement + 2 classical bits.

def teleportation():
    qc = QuantumCircuit(3, 3)

    # Alice qubit 0 to some arbitrary state
    qc.h(0)
    qc.rz(0.7, 0)
    qc.barrier()

    # Bell pair (qubits 1, 2)
    qc.h(1)
    qc.cx(1, 2)
    qc.barrier()

    # Alice measurement prep
    qc.cx(0, 1)
    qc.h(0)
    qc.measure([0, 1], [0, 1])
    qc.barrier()

    # Bob conditional gates
    qc.cx(1, 2)
    qc.cz(0, 2)
    qc.measure(2, 2)
    return qc

18. Quiz

19. References

1. Qiskit Documentation - qiskit.org
2. Cirq Documentation - quantumai.google/cirq
3. IBM Quantum Learning - learning.quantum.ibm.com
4. Nielsen and Chuang, Quantum Computation and Quantum Information
5. Preskill, Quantum Computing in the NISQ era and beyond (2018)
6. Arute et al., Quantum Supremacy, Nature 2019
7. NIST PQC Project - csrc.nist.gov/projects/post-quantum-cryptography
8. Google Quantum AI - quantumai.google
9. Shor, Algorithms for quantum computation (1994)
10. Grover, A fast quantum mechanical algorithm (1996)
11. Microsoft Quantum Development Kit
12. QuTiP Library - qutip.org
13. Quantum Algorithm Zoo - quantumalgorithmzoo.org

Conclusion

Quantum computing is no longer the exclusive domain of physicists. Open-source SDKs like Qiskit and Cirq let software developers run quantum circuits in Jupyter notebooks and access real quantum hardware via IBM Quantum cloud. The NISQ era is imperfect, but hybrid approaches like VQE, QAOA, and quantum ML are edging toward the first useful advantages. Simultaneously, migrating to Post-Quantum cryptography is mandatory for all security infrastructure. The quantum age has begun, and opportunities await developers who prepare.