양자역학 완전 정복: 슈뢰딩거의 고양이부터 양자컴퓨터까지

# 광전효과 시뮬레이션
class PhotoelectricEffect:
    def __init__(self, metal_work_function):
        self.work_function = metal_work_function  # 문턱 에너지 (eV)
    
    def will_emit_electron(self, photon_frequency):
        photon_energy = h * photon_frequency
        
        if photon_energy >= self.work_function:
            kinetic_energy = photon_energy - self.work_function
            return True, kinetic_energy
        else:
            return False, 0

# 예시: 나트륨 금속
sodium = PhotoelectricEffect(work_function=2.3)  # eV

# 빨간 빛 (낮은 진동수)
emit, ke = sodium.will_emit_electron(freq=4.5e14)  # Hz
print(f"전자 방출: {emit}")  # False

# 자외선 (높은 진동수)
emit, ke = sodium.will_emit_electron(freq=1.0e15)  # Hz
print(f"전자 방출: {emit}, 운동에너지: {ke} eV")  # True

import numpy as np

h = 6.626e-34  # 플랑크 상수 (J·s)

# 1. 전자의 드브로이 파장
m_electron = 9.109e-31  # kg
v_electron = 1e6  # m/s (빠른 전자)

lambda_electron = h / (m_electron * v_electron)
print(f"전자 파장: {lambda_electron:.2e} m")
# 출력: 7.27e-10 m = 0.727 nm (원자 크기!)

# 2. 축구공의 드브로이 파장
m_ball = 0.43  # kg
v_ball = 20  # m/s

lambda_ball = h / (m_ball * v_ball)
print(f"축구공 파장: {lambda_ball:.2e} m")
# 출력: 7.70e-35 m (관측 불가능!)

class DoubleSlitExperiment:
    def __init__(self, observe=False):
        self.observe = observe
    
    def run_experiment(self, num_electrons=1000):
        results = []
        
        for _ in range(num_electrons):
            if self.observe:
                # 관측함: 전자가 특정 슬릿을 "선택"
                slit = random.choice([1, 2])
                position = self.classical_pattern(slit)
            else:
                # 관측 안 함: 전자가 "둘 다" 통과
                position = self.quantum_interference_pattern()
            
            results.append(position)
        
        return results
    
    def quantum_interference_pattern(self):
        # 간섭 무늬: 코사인 제곱 분포
        x = random.uniform(-10, 10)
        prob = (np.cos(x) ** 2) * 0.5 + 0.5
        
        if random.random() < prob:
            return x
        return self.quantum_interference_pattern()
    
    def classical_pattern(self, slit):
        # 고전적 패턴: 두 개의 가우시안 분포
        if slit == 1:
            return random.gauss(-2, 1)
        else:
            return random.gauss(2, 1)

# 실험 실행
experiment_no_observe = DoubleSlitExperiment(observe=False)
results_quantum = experiment_no_observe.run_experiment()

experiment_observe = DoubleSlitExperiment(observe=True)
results_classical = experiment_observe.run_experiment()

# 결과 시각화하면:
# results_quantum → 간섭 무늬 █ █ █ █ █
# results_classical → 두 개의 띠 ████    ████

def heisenberg_limit(position_uncertainty):
    """위치 불확정성이 주어졌을 때, 최소 운동량 불확정성 계산"""
    hbar = 1.055e-34  # J·s
    
    delta_p = hbar / (2 * position_uncertainty)
    
    # 전자의 경우 속도 불확정성 계산
    m_electron = 9.109e-31  # kg
    delta_v = delta_p / m_electron
    
    return delta_p, delta_v

# 예시 1: 전자를 1nm 정확도로 위치 측정
dx = 1e-9  # m
dp, dv = heisenberg_limit(dx)

print(f"위치 불확정성: {dx*1e9:.1f} nm")
print(f"운동량 불확정성: {dp:.2e} kg·m/s")
print(f"속도 불확정성: {dv:.2e} m/s")
# 출력: 속도 불확정성 약 58,000 m/s!

# 예시 2: 원자 크기로 국한시키면
dx = 1e-10  # m (0.1 nm)
dp, dv = heisenberg_limit(dx)
print(f"속도 불확정성: {dv:.2e} m/s")
# 출력: 약 580,000 m/s (빛의 속도의 0.2%!)

import numpy as np
import matplotlib.pyplot as plt

class ParticleInBox:
    def __init__(self, L, n):
        """
        L: 상자의 길이
        n: 양자수 (1, 2, 3, ...)
        """
        self.L = L
        self.n = n
        self.hbar = 1.055e-34
        self.m = 9.109e-31  # 전자 질량
    
    def wave_function(self, x):
        """파동함수"""
        return np.sqrt(2/self.L) * np.sin(n * np.pi * x / self.L)
    
    def probability_density(self, x):
        """확률 밀도"""
        return self.wave_function(x) ** 2
    
    def energy(self):
        """에너지 준위"""
        return (self.n ** 2) * (np.pi ** 2) * (self.hbar ** 2) / (2 * self.m * self.L ** 2)

# 시각화
L = 1e-9  # 1 nm 상자
x = np.linspace(0, L, 1000)

fig, axes = plt.subplots(3, 2, figsize=(12, 10))

for n in range(1, 4):
    particle = ParticleInBox(L, n)
    
    # 파동함수
    psi = particle.wave_function(x)
    axes[n-1, 0].plot(x*1e9, psi)
    axes[n-1, 0].set_title(f'n={n}: 파동함수 Ψ(x)')
    axes[n-1, 0].set_xlabel('위치 (nm)')
    
    # 확률 밀도
    prob = particle.probability_density(x)
    axes[n-1, 1].fill_between(x*1e9, prob, alpha=0.5)
    axes[n-1, 1].set_title(f'n={n}: 확률 밀도 |Ψ(x)|²')
    axes[n-1, 1].set_xlabel('위치 (nm)')
    
    # 에너지
    E = particle.energy()
    print(f"n={n}: E = {E:.2e} J = {E/1.602e-19:.2f} eV")

# 출력:
# n=1: E = 6.02e-20 J = 0.38 eV (바닥상태)
# n=2: E = 2.41e-19 J = 1.50 eV (4배)
# n=3: E = 5.42e-19 J = 3.38 eV (9배)

class QuantumBit:
    """큐비트: 양자 컴퓨터의 기본 단위"""
    
    def __init__(self):
        # 초기 상태: |0⟩
        self.alpha = 1.0 + 0.0j  # |0⟩의 진폭
        self.beta = 0.0 + 0.0j   # |1⟩의 진폭
    
    def hadamard_gate(self):
        """하다마드 게이트: 중첩 상태 생성"""
        new_alpha = (self.alpha + self.beta) / np.sqrt(2)
        new_beta = (self.alpha - self.beta) / np.sqrt(2)
        
        self.alpha = new_alpha
        self.beta = new_beta
    
    def measure(self):
        """측정: 중첩 상태 붕괴"""
        prob_0 = abs(self.alpha) ** 2
        prob_1 = abs(self.beta) ** 2
        
        if random.random() < prob_0:
            # |0⟩으로 붕괴
            self.alpha = 1.0
            self.beta = 0.0
            return 0
        else:
            # |1⟩으로 붕괴
            self.alpha = 0.0
            self.beta = 1.0
            return 1
    
    def state(self):
        return f"|ψ⟩ = {self.alpha:.3f}|0⟩ + {self.beta:.3f}|1⟩"

# 실험
qubit = QuantumBit()
print(f"초기: {qubit.state()}")
# 출력: |ψ⟩ = 1.000|0⟩ + 0.000|1⟩

qubit.hadamard_gate()
print(f"중첩: {qubit.state()}")
# 출력: |ψ⟩ = 0.707|0⟩ + 0.707|1⟩

# 1000번 측정
results = [QuantumBit().hadamard_gate() or qubit.measure() 
           for _ in range(1000)]
print(f"0이 나온 횟수: {results.count(0)}")  # 약 500
print(f"1이 나온 횟수: {results.count(1)}")  # 약 500

class EntangledPair:
    def __init__(self):
        # 벨 상태 생성: |Ψ⁻⟩ = 1/√2(|01⟩ - |10⟩)
        self.state = "entangled"
        self.measured_A = None
        self.measured_B = None
    
    def measure_A(self, angle):
        """Alice의 측정 (각도 단위: 라디안)"""
        if self.measured_A is not None:
            return self.measured_A
        
        # 양자역학적 확률
        prob_up = 0.5
        
        if random.random() < prob_up:
            self.measured_A = "up"
            self.measured_B = "down"  # 즉시 결정!
        else:
            self.measured_A = "down"
            self.measured_B = "up"
        
        return self.measured_A
    
    def measure_B(self, angle):
        """Bob의 측정"""
        if self.measured_B is not None:
            return self.measured_B
        
        # Alice가 먼저 측정했다면 이미 결정됨
        prob_up = 0.5
        
        if random.random() < prob_up:
            self.measured_B = "up"
            self.measured_A = "down"
        else:
            self.measured_B = "down"
            self.measured_A = "up"
        
        return self.measured_B

def bell_test(num_trials=10000):
    """벨 부등식 검증"""
    
    # 측정 각도 설정
    a = 0
    a_prime = np.pi / 4
    b = np.pi / 8
    c = 3 * np.pi / 8
    
    correlations = {
        (a, b): 0,
        (a, c): 0,
        (a_prime, b): 0,
        (a_prime, c): 0
    }
    
    for _ in range(num_trials):
        # 각 조합마다 얽힌 쌍 생성
        for angles in correlations.keys():
            pair = EntangledPair()
            result_A = pair.measure_A(angles[0])
            result_B = pair.measure_B(angles[1])
            
            # 상관관계 계산 (같으면 +1, 다르면 -1)
            if result_A == result_B:
                correlations[angles] += 1
            else:
                correlations[angles] -= 1
    
    # 정규화
    E_ab = correlations[(a, b)] / num_trials
    E_ac = correlations[(a, c)] / num_trials
    E_a_prime_b = correlations[(a_prime, b)] / num_trials
    E_a_prime_c = correlations[(a_prime, c)] / num_trials
    
    S = E_ab - E_ac + E_a_prime_b + E_a_prime_c
    
    print(f"벨 매개변수 S = {S:.3f}")
    print(f"고전 한계: |S| ≤ 2")
    print(f"양자 예측: S = 2√2 ≈ 2.828")
    
    if abs(S) > 2:
        print("✅ 벨 부등식 위반! 양자역학 승리!")
    else:
        print("❌ 벨 부등식 만족. 고전 이론 가능.")

bell_test()

def tunneling_probability(barrier_height, particle_energy, barrier_width, mass):
    """
    터널링 확률 계산
    
    Parameters:
    - barrier_height: 장벽 높이 (J)
    - particle_energy: 입자 에너지 (J)
    - barrier_width: 장벽 두께 (m)
    - mass: 입자 질량 (kg)
    """
    hbar = 1.055e-34
    
    if particle_energy >= barrier_height:
        return 1.0  # 고전적으로 통과 가능
    
    kappa = np.sqrt(2 * mass * (barrier_height - particle_energy)) / hbar
    T = np.exp(-2 * kappa * barrier_width)
    
    return T

# 예시 1: 전자가 1eV 장벽 터널링
m_e = 9.109e-31  # kg
eV = 1.602e-19   # J

barrier_V = 2 * eV  # 2 eV
energy_E = 1 * eV   # 1 eV
width_L = 1e-9      # 1 nm

prob = tunneling_probability(barrier_V, energy_E, width_L, m_e)
print(f"터널링 확률: {prob:.2%}")
# 출력: 약 13%

# 예시 2: 장벽 두께 변화의 영향
widths = np.linspace(0.1e-9, 5e-9, 100)
probs = [tunneling_probability(barrier_V, energy_E, w, m_e) for w in widths]

# 플롯하면: 지수적 감소
# 1 nm → 13%
# 2 nm → 1.7%
# 3 nm → 0.2%
# 5 nm → 0.001%

"""
문제: 소인수분해
N = p × q (p, q는 소수)

예: N = 15 = 3 × 5
큰 수: N = 617283920183...  (수백 자리)

고전 컴퓨터: O(e^(n^(1/3)))
            → 2048비트 RSA: 수십억 년

양자 컴퓨터: O((log N)³)
            → 2048비트 RSA: 수 시간!
"""

class ShorsAlgorithm:
    """쇼어 알고리즘 (단순화된 버전)"""
    
    def __init__(self, N):
        self.N = N
    
    def quantum_period_finding(self, a):
        """
        양자 푸리에 변환으로 주기 찾기
        (실제로는 양자 회로 필요)
        """
        # 의사 코드: a^r mod N = 1인 r 찾기
        for r in range(1, self.N):
            if pow(a, r, self.N) == 1:
                return r
        return None
    
    def factorize(self):
        """소인수분해"""
        import math
        
        # 1. 무작위로 a 선택 (1 < a < N)
        a = random.randint(2, self.N - 1)
        
        # 2. gcd(a, N) 확인
        gcd = math.gcd(a, self.N)
        if gcd != 1:
            return gcd, self.N // gcd
        
        # 3. 양자 부분: 주기 r 찾기
        r = self.quantum_period_finding(a)
        
        if r is None or r % 2 != 0:
            return None
        
        # 4. 소인수 계산
        x = pow(a, r // 2, self.N)
        
        factor1 = math.gcd(x - 1, self.N)
        factor2 = math.gcd(x + 1, self.N)
        
        if factor1 != 1 and factor1 != self.N:
            return factor1, self.N // factor1
        if factor2 != 1 and factor2 != self.N:
            return factor2, self.N // factor2
        
        return None

# 실행
N = 15
shor = ShorsAlgorithm(N)
factors = shor.factorize()
print(f"{N} = {factors[0]} × {factors[1]}")
# 출력: 15 = 3 × 5

"""
문제: 정렬되지 않은 데이터베이스 검색
N개 항목 중 특정 항목 찾기

고전 컴퓨터: O(N) - 평균 N/2번 확인
양자 컴퓨터: O(√N) - 제곱근 가속!

예: N = 1,000,000
고전: 500,000번 평균
양자: 1,000번!
"""

class GroverSearch:
    def __init__(self, database):
        self.database = database
        self.N = len(database)
        
    def quantum_search(self, target):
        """
        그로버 알고리즘 시뮬레이션
        """
        # 반복 횟수: π/4 × √N
        iterations = int(np.pi / 4 * np.sqrt(self.N))
        
        # 초기 상태: 균등 중첩
        amplitudes = np.ones(self.N) / np.sqrt(self.N)
        
        target_index = self.database.index(target)
        
        for _ in range(iterations):
            # 1. Oracle: 타겟 진폭 반전
            amplitudes[target_index] *= -1
            
            # 2. Diffusion: 평균 진폭 증폭
            mean = np.mean(amplitudes)
            amplitudes = 2 * mean - amplitudes
        
        # 측정: 확률이 가장 높은 상태
        probabilities = amplitudes ** 2
        found_index = np.argmax(probabilities)
        
        return self.database[found_index], found_index

# 테스트
database = list(range(10000))
random.shuffle(database)
target = 7777

grover = GroverSearch(database)
result, index = grover.quantum_search(target)

print(f"찾은 값: {result}, 위치: {index}")
print(f"고전 평균: {len(database)/2:.0f}번")
print(f"그로버: {int(np.pi/4 * np.sqrt(len(database)))}번")
# 출력:
# 고전 평균: 5000번
# 그로버: 79번

from qiskit import QuantumCircuit, execute, Aer
from qiskit.visualization import plot_histogram

# 양자 회로 생성
qc = QuantumCircuit(2, 2)  # 2 큐비트, 2 고전 비트

# 벨 상태 생성
qc.h(0)          # 하다마드 게이트: 큐비트 0을 중첩 상태로
qc.cx(0, 1)      # CNOT 게이트: 얽힘 생성

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

# 시뮬레이션
simulator = Aer.get_backend('qasm_simulator')
job = execute(qc, simulator, shots=1000)
result = job.result()
counts = result.get_counts(qc)

print(counts)
# 출력: {'00': 약 500, '11': 약 500}
# → 00과 11만 나타남 (얽힘 증명!)
# → 01과 10은 절대 안 나타남

1. 양자 난수 생성기
2. 간단한 양자 게임 (BB84 프로토콜)
3. 양자 텔레포테이션 시뮬레이션
4. 그로버 알고리즘으로 스도쿠 풀기
5. 변분 양자 고유값 풀이기 (VQE)