💡 왼쪽 원문을 읽으면서 오른쪽에 따라 써보세요. Tab 키로 힌트를 받을 수 있습니다.

원문 렌더가 준비되기 전까지 텍스트 가이드로 표시합니다.

1. What Is Quantum Computing?

Quantum computing is a computing paradigm that harnesses the principles of quantum mechanics — superposition, entanglement, and interference — to solve problems that are practically intractable for classical computers.

Classical vs. Quantum Computers

| Aspect | Classical Computer | Quantum Computer |

| --------------------- | ------------------------------- | ---------------------------------------------- |

| Basic unit | Bit (0 or 1) | Qubit (0, 1, or superposition) |

| Operations | Sequential/parallel logic gates | Quantum gates (unitary transformations) |

| State space | n bits = one of 2^n states | n qubits = 2^n states simultaneously |

| Error characteristics | Deterministic, predictable | Probabilistic, decoherence-prone |

| Best suited for | General-purpose computation | Optimization, quantum simulation, cryptography |

With n qubits representing $2^n$ states simultaneously, a 300-qubit system can process more states than there are atoms in the observable universe.

Why Does Quantum Computing Matter?

Quantum computing offers transformative breakthroughs in:

- **Cryptography**: Shor's algorithm solves the integer factorization problem — the foundation of RSA encryption — in polynomial time. Breaking 2048-bit RSA would take classical computers millions of years; a fault-tolerant quantum computer could do it in hours.

- **Drug Discovery**: Quantum simulation overcomes the exponential complexity barrier of classical molecular simulation, accelerating new material design and protein-folding prediction.

- **Optimization**: NP-hard problems in logistics, financial portfolio optimization, and scheduling can benefit from algorithms like QAOA.

- **AI / Machine Learning**: Quantum kernels and quantum neural networks may offer superior expressibility over classical ML on certain datasets.

Quantum Advantage vs. Quantum Supremacy

**Quantum Supremacy**: The moment a quantum computer performs a task that no classical computer can complete in a realistic time. In 2019, Google's Sycamore processor solved a specific sampling problem in 200 seconds — a task estimated to take the best classical supercomputer 10,000 years.

**Quantum Advantage**: The stricter, more practical bar — when a quantum computer is demonstrably faster on a _useful_ problem, not merely a contrived benchmark.

The NISQ Era

We currently live in the **NISQ (Noisy Intermediate-Scale Quantum)** era. Devices with 50–1,000 qubits exist but suffer from high error rates and short coherence times. Achieving full **Fault-Tolerant Quantum Computing (FTQC)** requires millions of physical qubits, a target set for the 2030s and beyond.

2. Qubits

Physical Implementations

| --------------- | ------------------------------------- | ---------------- | -------------------------------------- |

Superposition

Before measurement, a qubit exists in a superposition of 0 and 1:

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

where $\alpha$ and $\beta$ are complex amplitudes satisfying the normalization condition $|\alpha|^2 + |\beta|^2 = 1$.

Measurement probabilities are:

$$P(0) = |\alpha|^2, \quad P(1) = |\beta|^2$$

When $\alpha = \frac{1}{\sqrt{2}}$ and $\beta = \frac{1}{\sqrt{2}}$, each outcome has exactly 50% probability — this is the state produced by the Hadamard gate.

Bloch Sphere Representation

Any single-qubit pure state can be represented as a point on the unit sphere (Bloch sphere):

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

- $\theta = 0$: North pole = $|0\rangle$

- $\theta = \pi$: South pole = $|1\rangle$

- Equator: Superposition states (e.g., $|+\rangle = \frac{1}{\sqrt{2}}(|0\rangle + |1\rangle)$)

Quantum gates correspond to rotations on this sphere.

Decoherence

Qubits lose their quantum superposition when they interact with the environment (heat, electromagnetic noise, vibration). This is called **decoherence**. Current superconducting qubits have coherence times of tens to hundreds of microseconds — a critical limiting factor for running deep circuits.

3. Quantum Gates

Quantum gates are represented by unitary matrices $U$ satisfying $UU^\dagger = I$. Unlike classical logic gates, all quantum gates are **reversible**.

Single-Qubit Gates

**Pauli Gates**

$$X = \begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix}, \quad Y = \begin{pmatrix} 0 & -i \\ i & 0 \end{pmatrix}, \quad Z = \begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix}$$

- **X gate**: Quantum NOT. $|0\rangle \to |1\rangle$, $|1\rangle \to |0\rangle$

- **Z gate**: Phase flip. Applies $-1$ phase to $|1\rangle$

**Hadamard Gate**

$$H = \frac{1}{\sqrt{2}}\begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix}$$

Transforms $|0\rangle \to \frac{1}{\sqrt{2}}(|0\rangle + |1\rangle) = |+\rangle$, creating a uniform superposition.

**S and T Gates** (Phase gates)

$$S = \begin{pmatrix} 1 & 0 \\ 0 & i \end{pmatrix}, \quad T = \begin{pmatrix} 1 & 0 \\ 0 & e^{i\pi/4} \end{pmatrix}$$

Rotation Gates

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

These serve as trainable parameters in variational quantum algorithms.

Two-Qubit Gates

**CNOT (Controlled-NOT)**: Flips the target qubit when the control qubit is $|1\rangle$.

$$\text{CNOT} = \begin{pmatrix} 1&0&0&0 \\ 0&1&0&0 \\ 0&0&0&1 \\ 0&0&1&0 \end{pmatrix}$$

**Toffoli (CCNOT)**: Three-qubit gate. Flips target when _both_ control qubits are $|1\rangle$. Together with single-qubit gates, ensures universality.

Creating a Bell State with Qiskit

from qiskit import QuantumCircuit

from qiskit_aer import AerSimulator

Create a Bell state (maximum entanglement)

qc = QuantumCircuit(2, 2)

qc.h(0) # Hadamard: put qubit 0 into superposition

qc.cx(0, 1) # CNOT: entangle qubit 0 (control) and qubit 1 (target)

qc.measure([0, 1], [0, 1])

print(qc.draw())

Simulate

simulator = AerSimulator()

job = simulator.run(qc, shots=1000)

result = job.result()

counts = result.get_counts()

print("Measurement results:", counts)

Expected: {'00': ~500, '11': ~500}

01 and 10 never appear — perfect entanglement

The Bell state is $|\Phi^+\rangle = \frac{1}{\sqrt{2}}(|00\rangle + |11\rangle)$. Measuring one qubit instantly determines the other, no matter how far apart they are.

4. Quantum Circuits

Statevector Simulation

An n-qubit system's state is a $2^n$-dimensional complex vector.

from qiskit import QuantumCircuit

from qiskit.quantum_info import Statevector

qc = QuantumCircuit(2)

qc.h(0)

qc.cx(0, 1)

sv = Statevector.from_instruction(qc)

print(sv)

[0.707+0j, 0, 0, 0.707+0j]

|00> and |11> each with amplitude 1/sqrt(2)

GHZ State (3-Qubit Entanglement)

The GHZ (Greenberger-Horne-Zeilinger) state is the 3-qubit maximally entangled state:

$$|GHZ\rangle = \frac{1}{\sqrt{2}}(|000\rangle + |111\rangle)$$

qc = QuantumCircuit(3)

qc.h(0)

qc.cx(0, 1)

qc.cx(0, 2)

print(qc.draw())

Quantum Teleportation Protocol

Quantum teleportation transmits a quantum state using a classical communication channel and a shared entangled pair — without physically moving the qubit:

1. Alice and Bob share a Bell pair.

2. Alice applies CNOT and H to her qubit and the Bell qubit.

3. Alice measures her 2 qubits and sends 2 classical bits to Bob.

4. Bob applies X and/or Z corrections based on the classical bits, recovering Alice's original state.

Quantum Error Correction (QEC) Overview

Physical qubits experience bit-flip and phase-flip errors. QEC codes (Shor Code, Steane Code, Surface Code) encode one logical qubit into multiple physical qubits. The **Surface Code** is the most promising approach, requiring hundreds to thousands of physical qubits per logical qubit.

5. Landmark Quantum Algorithms

Deutsch-Jozsa Algorithm

Determines whether a function $f:\{0,1\}^n \to \{0,1\}$ is constant or balanced in **exactly 1 query**. Classically, worst case requires $2^{n-1}+1$ queries. This was the first proof of quantum advantage.

Grover's Search Algorithm

Finds a target in an unsorted database of N items in $O(\sqrt{N})$ queries. Classical brute-force requires $O(N)$, so Grover provides a quadratic speedup.

from qiskit.circuit.library import GroverOperator

from qiskit import QuantumCircuit

from qiskit_aer import AerSimulator

2-qubit Grover search (target: |11>)

oracle = QuantumCircuit(2)

oracle.cz(0, 1) # Oracle: applies phase -1 to |11>

grover_op = GroverOperator(oracle)

qc = QuantumCircuit(2)

qc.h([0, 1]) # Uniform superposition

qc.compose(grover_op, inplace=True) # Grover iteration

qc.measure_all()

simulator = AerSimulator()

job = simulator.run(qc, shots=1000)

result = job.result()

print(result.get_counts())

|11> appears with high probability

Shor's Factoring Algorithm

Factors an integer N into its prime components in $O((\log N)^3)$ polynomial time. The best classical algorithm (GNFS) runs in sub-exponential time $O(e^{1.9(\log N)^{1/3}(\log\log N)^{2/3}})$, making Shor exponentially faster.

This is why RSA and ECC encryption are threatened. In response, NIST published **Post-Quantum Cryptography (PQC)** standards in 2024.

Quantum Fourier Transform (QFT)

Performs the Discrete Fourier Transform using $O(n^2)$ quantum gates, exponentially faster than classical FFT at $O(N \log N)$. It is the core subroutine in Shor's algorithm and quantum phase estimation.

QAOA (Quantum Approximate Optimization Algorithm)

A variational quantum algorithm for combinatorial optimization problems (Max-Cut, TSP, scheduling). It operates as a hybrid of classical optimizer and quantum circuit, making it suitable for near-term NISQ devices.

6. Quantum Errors and Noise

Error Types

**Bit-flip error**: $|0\rangle \to |1\rangle$ or $|1\rangle \to |0\rangle$ — an unintended X channel flip.

**Phase-flip error**: $|+\rangle \to |-\rangle$ — a Z channel phase change.

**Depolarizing channel**: The most common noise model. With probability $p$, one of X, Y, or Z is applied randomly:

$$\mathcal{E}(\rho) = (1-p)\rho + \frac{p}{3}(X\rho X + Y\rho Y + Z\rho Z)$$

Gate Fidelity on Current NISQ Devices

| Operation | Typical Error Rate |

| ------------------- | -------------------- |

| Single-qubit gate | Below 0.1% |

| Two-qubit CNOT gate | 0.5–1% |

| Readout | 1–2% |

| T1 coherence time | 100–500 microseconds |

Noise Simulation with Qiskit

from qiskit_aer.noise import NoiseModel, depolarizing_error

from qiskit_aer import AerSimulator

from qiskit import QuantumCircuit

Build noise model

noise_model = NoiseModel()

error_1q = depolarizing_error(0.001, 1) # 0.1% single-qubit error

error_2q = depolarizing_error(0.01, 2) # 1% two-qubit error

noise_model.add_all_qubit_quantum_error(error_1q, ['h', 'x'])

noise_model.add_all_qubit_quantum_error(error_2q, ['cx'])

qc = QuantumCircuit(2, 2)

qc.h(0)

qc.cx(0, 1)

qc.measure_all()

sim = AerSimulator(noise_model=noise_model)

job = sim.run(qc, shots=1000)

print(job.result().get_counts())

Ideal: {'00': 500, '11': 500}

With noise: small counts of '01', '10' appear

7. Quantum Machine Learning (QML)

Variational Quantum Algorithms (VQA)

VQA trains a parameterized quantum circuit (PQC) using a classical optimizer in a hybrid loop:

$$\min_\theta \langle \psi(\theta) | H | \psi(\theta) \rangle$$

Key variants:

- **VQE (Variational Quantum Eigensolver)**: Molecular energy minimization

- **QAOA**: Combinatorial optimization

- **QNN**: Classification and regression

Data Encoding Strategies

| Method | Description | Qubit Cost |

| ------------------ | -------------------------------------------- | --------------------- |

| Angle encoding | Each feature encoded as Ry rotation angle | N features = N qubits |

| Amplitude encoding | Features stored in state vector amplitudes | log2(N) qubits |

| Basis encoding | Binary representation in computational basis | N bits = N qubits |

Implementing a QNN with PennyLane

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

@qml.qnode(dev)

def quantum_circuit(x, weights):

Angle encoding

qml.AngleEmbedding(x, wires=[0, 1])

Variational layer with entanglement

qml.BasicEntanglerLayers(weights, wires=[0, 1])

return qml.expval(qml.PauliZ(0))

Input data and initial weights

x = np.array([0.5, 0.3])

weights = np.random.random((3, 2)) # 3 layers, 2 wires

result = quantum_circuit(x, weights)

print(f"Expectation value: {result:.4f}")

Compute gradients via Parameter-Shift Rule

grad_fn = qml.grad(quantum_circuit, argnum=1)

gradients = grad_fn(x, weights)

print(f"Gradients: {gradients}")

Quantum Kernel Methods

Replace the classical kernel in SVMs with a quantum feature map:

$$K(x_i, x_j) = |\langle \phi(x_i)|\phi(x_j)\rangle|^2$$

A quantum computer efficiently computes inner products in a high-dimensional Hilbert space that is exponentially expensive to simulate classically.

Current Limitations of QML

- **Barren Plateaus**: As the number of qubits grows, gradients vanish exponentially, making training infeasible.

- **Data Loading Bottleneck**: Encoding classical data into quantum states (amplitude encoding) can negate quantum speedup.

- **NISQ Noise**: High error rates limit circuit depth and expressibility.

8. Quantum Hardware Landscape (2026)

Platform Comparison

| ----------- | ----------------- | --------------------- | -------------------------------- |

2026 Roadmap Summary

- **Now**: NISQ, 100–1000 physical qubits, error rates 0.1–1%

- **2027–2029**: Early error correction, thousands of physical qubits → tens of logical qubits

- **2030+**: Fault-tolerant quantum computing, target of millions of physical qubits

9. Quantum Cloud Access

Key Platforms

**IBM Quantum** (quantum.ibm.com): Free access to real devices with 127+ qubits. Based on the Qiskit SDK.

**AWS Braket** (aws.amazon.com/braket): Single API access to IonQ, Rigetti, D-Wave, and Amazon's own simulators.

**Google Quantum AI** (quantumai.google): Cirq framework, research collaboration access.

**Azure Quantum** (azure.microsoft.com/quantum): IonQ, Quantinuum, and Microsoft's topological qubit efforts.

Running on a Real IBM Quantum Device

from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 as Sampler

from qiskit import QuantumCircuit

from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

Initialize IBM Quantum service (requires API token)

service = QiskitRuntimeService(channel="ibm_quantum", token="YOUR_TOKEN")

service = QiskitRuntimeService()

Select the least busy real device

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

print(f"Backend: {backend.name}")

print(f"Qubits: {backend.num_qubits}")

Prepare and transpile circuit

qc = QuantumCircuit(2)

qc.h(0)

qc.cx(0, 1)

qc.measure_all()

pm = generate_preset_pass_manager(backend=backend, optimization_level=1)

isa_circuit = pm.run(qc)

Run with Sampler primitive

sampler = Sampler(mode=backend)

job = sampler.run([isa_circuit], shots=1000)

result = job.result()

print(result[0].data.meas.get_counts())

AWS Braket Example

from braket.aws import AwsDevice

from braket.circuits import Circuit

circuit = Circuit()

circuit.h(0)

circuit.cnot(0, 1)

circuit.measure([0, 1])

device = AwsDevice("arn:aws:braket:::device/quantum-simulator/amazon/sv1")

task = device.run(circuit, shots=1000)

result = task.result()

print(result.measurement_counts)

10. Learning Roadmap and References

Learning Paths by Engineer Type

**Software Engineers**: Python → Qiskit basics → Quantum algorithms → QML with PennyLane

**Electrical / Hardware Engineers**: Quantum mechanics fundamentals → Physical qubit implementations → Circuit design → Error correction

**AI / ML Engineers**: Linear algebra deep dive → Quantum gates → PennyLane → Hybrid QML models

Essential References

- Nielsen & Chuang, **Quantum Computation and Quantum Information** (Cambridge, 2000) — the field's bible

- Qiskit documentation: qiskit.org

- PennyLane documentation: pennylane.ai

- IBM Quantum Learning: learning.quantum.ibm.com

- arXiv quant-ph section: latest research preprints

Quiz

**Answer**: A qubit can exist in a **superposition** of 0 and 1 simultaneously before measurement. A classical bit is always definitively either 0 or 1.

**Explanation**: With n qubits representing 2^n states simultaneously, a 300-qubit system can process more states than there are atoms in the observable universe. This exponential parallelism is the core promise of quantum computing.

**Answer**: The plus state — an equal superposition where measuring yields 0 or 1 with 50% probability each.

**Explanation**: Mathematically expressed as (1/sqrt(2))(|0> + |1>). This state is the starting point for most quantum algorithms, as it creates the uniform superposition needed for quantum parallelism.

**Answer**: Shor's algorithm solves integer factorization in polynomial time O((log N)^3), while the best classical algorithm requires sub-exponential time. Since RSA security relies on the hardness of factoring large numbers, a fault-tolerant quantum computer would be able to break current RSA encryption.

**Explanation**: This has motivated NIST to standardize Post-Quantum Cryptography (PQC) algorithms in 2024, designed to be secure against quantum attacks.

**Answer**: NISQ (Noisy Intermediate-Scale Quantum) describes today's quantum computers — 50 to several thousand qubits with error rates too high for full error correction.

**Explanation**: NISQ devices are powerful enough to explore near-term applications (QAOA, VQE, QML) but not yet capable of running deep fault-tolerant algorithms like Shor's. Engineers building quantum applications today must design algorithms that tolerate noise and work within shallow circuit depths.

**Answer**: As the number of qubits and circuit depth increases, the gradients of a quantum neural network vanish exponentially, making training practically impossible.

**Explanation**: Similar to the vanishing gradient problem in classical deep learning. Mitigation strategies include using local cost functions, careful circuit architecture design, layer-wise pre-training, and identity block initialization.

Quantum computing is still in its NISQ era, but the pace of progress is remarkable. Start with Qiskit and PennyLane today, and you will be well positioned when fault-tolerant quantum computers become a practical reality. The future belongs to engineers who understand both the quantum and classical worlds.