operation OptimizeDeliveryRoutes(
    locations: Location[], 
    constraints: Constraint[]
) : Route[] {
    // 100만 개 경로를 10초 만에 최적화
    use qubits = Qubit[Ceiling(Lg(IntAsDouble(Length(locations))))];
    // ... 양자 알고리즘
}

# 클래식 비트의 세계
bit = 0  # 또는 1
# "동시에 0이면서 1"은 불가능

# 큐비트의 세계 (의사 코드)
qubit = |0⟩ + |1⟩  # 동시에 0이면서 1!
# 관측하는 순간 0 또는 1로 "붕괴"

두 큐비트를 얽히게 하면:
- 첫 번째 큐비트를 측정 → 0으로 붕괴
- 두 번째 큐비트도 순간적으로 영향을 받음
- 거리와 무관 (1cm든 1광년이든)

from qiskit import QuantumCircuit, execute, Aer

# 양자 회로 생성
circuit = QuantumCircuit(2, 2)  # 2큐비트, 2클래식비트

# 중첩 상태 만들기 (Hadamard gate)
circuit.h(0)  # 큐비트 0을 |0⟩과 |1⟩의 중첩으로

# 얽힘 만들기 (CNOT gate)
circuit.cx(0, 1)  # 큐비트 0과 1을 얽힘

# 측정
circuit.measure([0, 1], [0, 1])

# 시뮬레이터에서 실행
backend = Aer.get_backend('qasm_simulator')
job = execute(circuit, backend, shots=1000)
result = job.result()

print(result.get_counts())
# 출력: {'00': 503, '11': 497}
# → 0과 1이 항상 같이 나타남 (얽힘 증명)

import cirq

# 큐비트 정의
qubits = cirq.LineQubit.range(3)

# 회로 생성
circuit = cirq.Circuit(
    # 모든 큐비트를 중첩 상태로
    cirq.H.on_each(*qubits),
    
    # 얽힘 생성
    cirq.CNOT(qubits[0], qubits[1]),
    cirq.CNOT(qubits[1], qubits[2]),
    
    # 측정
    cirq.measure(*qubits, key='result')
)

print(circuit)

# 시뮬레이터 실행
simulator = cirq.Simulator()
result = simulator.run(circuit, repetitions=1000)
print(result.histogram(key='result'))

namespace QuantumTeleportation {
    open Microsoft.Quantum.Canon;
    open Microsoft.Quantum.Intrinsic;

    // 양자 텔레포테이션 구현
    operation Teleport(message : Qubit, target : Qubit) : Unit {
        use auxiliary = Qubit();
        
        // 얽힘 쌍 생성
        H(auxiliary);
        CNOT(auxiliary, target);
        
        // 메시지와 보조 큐비트 얽힘
        CNOT(message, auxiliary);
        H(message);
        
        // 측정
        let m1 = M(message);
        let m2 = M(auxiliary);
        
        // 수신자 측 보정
        if (m2 == One) { X(target); }
        if (m1 == One) { Z(target); }
    }
}

from qiskit import QuantumCircuit
from qiskit.algorithms import AmplificationProblem, Grover
from qiskit.primitives import Sampler

# 문제: 1,000,000개 중 특정 항목 찾기
# 클래식: 평균 500,000번 검색
# 양자: 약 1,000번만에 찾음!

def create_oracle(marked_item):
    """찾고자 하는 항목에 표시하는 오라클"""
    n = len(bin(marked_item)[2:])
    oracle = QuantumCircuit(n)
    
    # 찾고자 하는 항목의 위상 반전
    # (구체적 구현은 복잡하므로 생략)
    
    return oracle

# Grover 알고리즘 실행
oracle = create_oracle(marked_item=42)
problem = AmplificationProblem(oracle)
grover = Grover(sampler=Sampler())

result = grover.amplify(problem)
print(f"찾은 항목: {result.top_measurement}")
# 출력: "찾은 항목: 42"

# RSA의 안전성 기반: 큰 수의 소인수분해는 어렵다
# 예: 2048비트 RSA 키 깨기
# 클래식 컴퓨터: 수억 년
# → 안전함 ✅

p = 매우_큰_소수  # 1024비트
q = 또다른_큰_소수  # 1024비트
N = p * q  # 2048비트

# N을 알아도 p와 q를 찾기는 거의 불가능 (클래식으로는)

신약 하나 개발:
━━━━━━━━━━━━━━━━━
비용: 평균 26억 달러
기간: 10~15년
성공률: 약 10%

from qiskit_nature.units import DistanceUnit
from qiskit_nature.second_q.drivers import PySCFDriver

# 분자 정의: 물(H2O)
driver = PySCFDriver(
    atom="""
    O 0.0 0.0 0.0
    H 0.757 0.586 0.0
    H -0.757 0.586 0.0
    """,
    unit=DistanceUnit.ANGSTROM,
    basis="sto3g"
)

# 양자 컴퓨터로 에너지 계산
problem = driver.run()
# 실제 하드웨어나 시뮬레이터에서 실행
# → 정확한 분자 궤도 에너지 계산

from qiskit_machine_learning.algorithms import VQC
from qiskit_machine_learning.neural_networks import SamplerQNN

# 양자 신경망 정의
qnn = SamplerQNN(
    circuit=feature_map,  # 양자 feature map
    input_params=input_params,
    weight_params=weight_params
)

# 양자 분류기
vqc = VQC(
    num_qubits=4,
    quantum_instance=quantum_backend,
    optimizer=optimizer
)

# 학습 (클래식보다 빠름)
vqc.fit(X_train, y_train)

# 추론
predictions = vqc.predict(X_test)

외판원 문제 (TSP):
- N개 도시를 최단 경로로 방문
- 가능한 경로: N! (팩토리얼)
- 100개 도시: 10^157 경로
- 우주 나이 동안 계산해도 불가능

from qiskit.algorithms.optimizers import COBYLA
from qiskit_optimization.applications import Maxcut
from qiskit_optimization.algorithms import MinimumEigenOptimizer
from qiskit.algorithms import QAOA
from qiskit.primitives import Sampler

# 문제 정의: 배송 경로 최적화
problem = define_delivery_problem(
    locations=1000,
    vehicles=50,
    constraints=["time_windows", "capacity"]
)

# QAOA로 해결
qaoa = QAOA(optimizer=COBYLA(), reps=3, sampler=Sampler())
optimizer = MinimumEigenOptimizer(qaoa)

result = optimizer.solve(problem)
optimal_routes = result.x

# 클래식: 며칠
# 양자: 몇 분

기후 변화 대응의 핵심:
━━━━━━━━━━━━━━━━━━━
대기 중 CO2를 효율적으로 포집하여
유용한 화학물질로 전환

현재 촉매: 비효율적, 비싸다
필요: 획기적인 새 촉매

양자 컴퓨터:
→ 수백만 개 후보 물질 시뮬레이션
→ 최적 촉매 발견
→ CO2를 연료/플라스틱/건축자재로 전환