# Julia REPL에서 버전 확인하기
julia> versioninfo()
      

# Julia REPL에서 패키지 모드로 전환 (']' 키를 누르세요)
julia> ]

# 패키지 설치
(@v1.x) pkg> add Yao

# 추가 유용한 패키지들
(@v1.x) pkg> add QuantumInformation
(@v1.x) pkg> add Plots
      

using Yao

# 단일 큐비트 회로 만들기
circuit = chain(1, X)  # X는 NOT 게이트와 같은 역할을 해요

# 초기 상태 (|0⟩)
initial_state = zero_state(1)

# 회로 실행
final_state = apply(circuit, initial_state)

# 결과 확인
measure(final_state; nshots=100)
      

using Yao

# 2큐비트 벨 상태 만들기
bell_circuit = chain(2,
    put(1 => H),     # 첫 번째 큐비트에 아다마르 게이트 적용
    control(1, 2 => X)  # CNOT 게이트: 첫 번째 큐비트가 컨트롤, 두 번째가 타겟
)

# 초기 상태 (|00⟩)
initial_state = zero_state(2)

# 회로 실행
bell_state = apply(bell_circuit, initial_state)

# 결과 출력
println(state(bell_state))
      

using Yao

# X 게이트 적용하기
circuit = chain(1, X)  # 1개의 큐비트에 X 게이트 적용
initial_state = zero_state(1)  # |0⟩ 상태로 초기화
final_state = apply(circuit, initial_state)  # 회로 적용

# 결과 확인
println("초기 상태: ", state(initial_state))
println("최종 상태: ", state(final_state))
println("측정 결과: ", measure(final_state; nshots=10))
      

# H 게이트 적용하기
h_circuit = chain(1, H)
initial_state = zero_state(1)
superposition_state = apply(h_circuit, initial_state)

# 결과 확인
println("중첩 상태: ", state(superposition_state))
println("측정 결과: ", measure(superposition_state; nshots=100))
      

# 여러 게이트 조합하기
combined_circuit = chain(1, H, X, H)
initial_state = zero_state(1)
final_state = apply(combined_circuit, initial_state)

# 결과 확인
println("최종 상태: ", state(final_state))
println("측정 결과: ", measure(final_state; nshots=100))
      

using Yao

# 벨 상태 생성 회로
bell_circuit = chain(2,
    put(1 => H),        # 첫 번째 큐비트에 H 게이트 적용
    control(1, 2 => X)  # CNOT: 첫 번째 큐비트가 컨트롤, 두 번째가 타겟
)

# 초기 상태 (|00⟩)
initial_state = zero_state(2)

# 회로 적용
bell_state = apply(bell_circuit, initial_state)

# 결과 확인
println("벨 상태: ", state(bell_state))

# 측정 시뮬레이션 (100번)
results = measure(bell_state; nshots=100)
println("측정 결과: ", results)

# 측정 결과 분석
zeros = count(x -> x == 0, results)
ones = count(x -> x == 3, results)  # 이진수 11 = 십진수 3
println("00 측정 횟수: ", zeros)
println("11 측정 횟수: ", ones)
      

🔍 다른 벨 상태 만들기

벨 상태는 총 4가지가 있어요. 위에서 만든 건 |Φ⁺⟩ = (|00⟩ + |11⟩)/√2 상태예요. 다른 벨 상태도 만들어볼까요?

예를 들어, |Φ⁻⟩ = (|00⟩ - |11⟩)/√2 상태를 만들려면 CNOT 게이트 후에 두 번째 큐비트에 Z 게이트를 적용하면 돼요:

# |Φ⁻⟩ 상태 만들기
phi_minus_circuit = chain(2,
    put(1 => H),
    control(1, 2 => X),
    put(2 => Z)
)
      

# GHZ 상태 생성 (|000⟩ + |111⟩)/√2
ghz_circuit = chain(3,
    put(1 => H),
    control(1, 2 => X),
    control(2, 3 => X)
)

initial_state = zero_state(3)
ghz_state = apply(ghz_circuit, initial_state)

println("GHZ 상태: ", state(ghz_state))
results = measure(ghz_state; nshots=100)
println("측정 결과: ", results)

# 000과 111의 측정 횟수 계산
zeros = count(x -> x == 0, results)
ones = count(x -> x == 7, results)  # 이진수 111 = 십진수 7
println("000 측정 횟수: ", zeros)
println("111 측정 횟수: ", ones)
      

using Yao

# 2큐비트 그로버 알고리즘 구현 (타겟: |10⟩)
function grover_circuit()
    n = 2  # 큐비트 수
    
    # 1. 균등 중첩 상태 생성
    init = repeat(H, n)
    
    # 2. 오라클 (타겟 상태 |10⟩에 -1을 곱함)
    # |10⟩ = |2⟩ (십진수로는 2)
    oracle = oracle_gate(n, 2)
    
    # 3. 확산 연산자 (진폭 증폭)
    diffusion = diffusion_gate(n)
    
    # 전체 회로 구성
    return chain(init, oracle, diffusion)
end

# 오라클 게이트 정의 (타겟 상태의 위상을 반전)
function oracle_gate(n, target)
    m = zeros(ComplexF64, 1<<n, 1<<n)
    for i in 0:(1<<n)-1
        if i == target
            m[i+1, i+1] = -1
        else
            m[i+1, i+1] = 1
        end
    end
    return matblock(m)
end

# 확산 연산자 정의 (평균에 대한 반사)
function diffusion_gate(n)
    return chain(
        repeat(H, n),
        chain(repeat(X, n), control(1:n-1, n => Z), repeat(X, n)),
        repeat(H, n)
    )
end

# 회로 생성 및 실행
circuit = grover_circuit()
initial_state = zero_state(2)
final_state = apply(circuit, initial_state)

# 결과 확인
println("최종 상태: ", state(final_state))
results = measure(final_state; nshots=100)
println("측정 결과: ", results)

# 결과 분석
counts = Dict{Int, Int}()
for result in results
    counts[result] = get(counts, result, 0) + 1
end
println("측정 통계: ", counts)
      

# 3큐비트 그로버 알고리즘 (타겟: |101⟩ = 5)
function grover_circuit_3qubits(iterations)
    n = 3  # 큐비트 수
    target = 5  # |101⟩ = 5
    
    # 1. 균등 중첩 상태 생성
    init = repeat(H, n)
    
    # 2. 그로버 반복 (오라클 + 확산)
    iteration = chain(
        oracle_gate(n, target),
        diffusion_gate(n)
    )
    
    # 전체 회로 구성 (반복 적용)
    return chain(init, [iteration for _ in 1:iterations]...)
end

# 회로 생성 및 실행 (2번 반복)
circuit = grover_circuit_3qubits(2)
initial_state = zero_state(3)
final_state = apply(circuit, initial_state)

# 결과 확인
println("최종 상태: ", state(final_state))
results = measure(final_state; nshots=100)

# 결과 분석
counts = Dict{Int, Int}()
for result in results
    counts[result] = get(counts, result, 0) + 1
end
println("측정 통계: ", counts)
      

using Yao

# 양자 푸리에 변환(QFT) 구현
function qft(n::Int)
    circuit = chain(n)
    for i = 1:n
        push!(circuit, put(i => H))
        for j = i+1:n
            push!(circuit, control(j, i => shift(2π / (2^(j-i+1)))))
        end
    end
    
    # 큐비트 순서 뒤집기 (선택 사항)
    for i = 1:n÷2
        push!(circuit, swap(i, n-i+1))
    end
    
    return circuit
end

# QFT의 역변환
function inverse_qft(n::Int)
    return adjoint(qft(n))
end

# 테스트: 3큐비트 QFT
n = 3
qft_circuit = qft(n)
println("3큐비트 QFT 회로:")
println(qft_circuit)

# |000⟩ 상태에 QFT 적용
initial_state = zero_state(n)
qft_state = apply(qft_circuit, initial_state)
println("QFT 적용 후 상태:")
println(state(qft_state))

# 역변환으로 원래 상태로 복원
restored_state = apply(inverse_qft(n), qft_state)
println("역변환 후 상태 (원래대로 복원됨):")
println(state(restored_state))
      

# 간단한 주기 찾기 함수 (쇼어 알고리즘의 핵심 부분)
function find_period_shor(a::Int, N::Int, n_count::Int, n_target::Int)
    # 1. 레지스터 초기화
    circuit = chain(n_count + n_target)
    
    # 2. 첫 번째 레지스터에 균등 중첩 생성
    push!(circuit, repeat(H, n_count))
    
    # 3. 모듈러 지수 함수 적용 (U_f |x⟩|0⟩ = |x⟩|a^x mod N⟩)
    # 이 부분은 실제로는 매우 복잡하므로 간소화된 버전을 사용
    function modular_exponentiation(x)
        return mod(a^x, N)
    end
    
    # 4. 양자 푸리에 변환 적용
    push!(circuit, put(1:n_count => inverse_qft(n_count)))
    
    # 5. 측정
    initial_state = zero_state(n_count + n_target)
    final_state = apply(circuit, initial_state)
    
    # 첫 번째 레지스터만 측정
    results = measure(final_state, 1:n_count; nshots=100)
    
    return results
end

# 예: N=15, a=7의 주기 찾기
# (실제로는 r=4가 나와야 함)
N = 15
a = 7
n_count = 8   # 첫 번째 레지스터 크기
n_target = 4  # 두 번째 레지스터 크기

println("N=$N, a=$a에 대한 주기 찾기 시뮬레이션:")
results = find_period_shor(a, N, n_count, n_target)
println("측정 결과: ", results)

# 주: 실제 쇼어 알고리즘은 이보다 훨씬 복잡하며,
# 위 코드는 개념적인 이해를 위한 간소화된 버전입니다.
      

using Yao, YaoPlots
using LinearAlgebra: norm

# 양자 텔레포테이션 회로 구현
function quantum_teleportation(psi)
    # 3큐비트 회로 생성
    # 1: 전송할 상태 |ψ⟩
    # 2: 앨리스의 얽힌 큐비트
    # 3: 밥의 얽힌 큐비트
    circuit = chain(3)
    
    # 1. 앨리스와 밥 사이에 얽힘 생성 (벨 상태)
    push!(circuit, put(2 => H))
    push!(circuit, control(2, 3 => X))
    
    # 2. 앨리스의 벨 측정 준비
    push!(circuit, control(1, 2 => X))
    push!(circuit, put(1 => H))
    
    # 3. 앨리스의 측정 (시뮬레이션에서는 측정 대신 조건부 연산으로 표현)
    # 측정 결과에 따라 밥이 적용할 연산
    push!(circuit, control(1, 3 => Z))
    push!(circuit, control(2, 3 => X))
    
    # 초기 상태 준비: |ψ⟩|00⟩
    initial_state = join(psi, zero_state(2))
    
    # 회로 실행
    final_state = apply(circuit, initial_state)
    
    return final_state
end

# 임의의 1큐비트 상태 생성
function random_state()
    # 랜덤 복소수 계수
    a = rand() + im * rand()
    b = rand() + im * rand()
    
    # 정규화
    norm_factor = sqrt(abs(a)^2 + abs(b)^2)
    a = a / norm_factor
    b = b / norm_factor
    
    # 상태 벡터 생성
    return ArrayReg([a, b])
end

# 테스트
# 1. 임의의 상태 생성
psi = random_state()
println("전송할 상태 |ψ⟩:")
println(state(psi))

# 2. 텔레포테이션 수행
final_state = quantum_teleportation(psi)

# 3. 결과 확인
# 3번째 큐비트의 상태가 원래 상태와 같은지 확인
# (부분 트레이스를 통해 3번째 큐비트만 추출)
function get_third_qubit_state(state_vector)
    # 3큐비트 상태에서 첫 번째와 두 번째 큐비트를 트레이스 아웃
    result = zeros(ComplexF64, 2)
    for i in 0:1
        for j in 0:1
            for k in 0:1
                idx = 4*i + 2*j + k + 1
                if k == 0
                    result[1] += state_vector[idx]
                else
                    result[2] += state_vector[idx]
                end
            end
        end
    end
    return result / norm(result)
end

teleported_state = get_third_qubit_state(state(final_state))
println("텔레포트된 상태 (밥의 큐비트):")
println(teleported_state)

# 원래 상태와 텔레포트된 상태 비교
original = state(psi)
println("원래 상태와 텔레포트된 상태의 유사도:")
similarity = abs(dot(original, teleported_state))
println(similarity)  # 1에 가까울수록 성공적인 텔레포테이션
      

using Yao, Zygote, Optim
using Random, LinearAlgebra, Statistics

# 1. 양자 회로 정의 (파라미터화된 회로)
function create_quantum_circuit(n_qubits, n_layers)
    circuit = chain(n_qubits)
    
    # 데이터 인코딩 레이어 (여기서는 단순화)
    push!(circuit, repeat(H, n_qubits))
    
    # 변분 레이어 (학습 가능한 파라미터)
    params = rand(3 * n_qubits * n_layers)
    variational_circuit = variational_circuit(n_qubits, n_layers, params)
    push!(circuit, variational_circuit)
    
    return circuit, params
end

# 변분 레이어 생성
function variational_circuit(n_qubits, n_layers, params)
    circuit = chain(n_qubits)
    param_idx = 1
    
    for l in 1:n_layers
        # 회전 게이트 레이어
        for i in 1:n_qubits
            push!(circuit, put(i => Rx(params[param_idx])))
            param_idx += 1
            push!(circuit, put(i => Ry(params[param_idx])))
            param_idx += 1
            push!(circuit, put(i => Rz(params[param_idx])))
            param_idx += 1
        end
        
        # 얽힘 레이어
        if l < n_layers
            for i in 1:n_qubits-1
                push!(circuit, control(i, i+1 => X))
            end
        end
    end
    
    return circuit
end

# 2. 데이터 생성 (간단한 이진 분류 문제)
function generate_data(n_samples)
    # 두 개의 클래스로 구성된 간단한 데이터셋
    X = rand(2, n_samples) * 2 .- 1  # -1에서 1 사이의 값
    y = [norm(X[:, i]) < 0.5 ? 0 : 1 for i in 1:n_samples]
    return X, y
end

# 3. 데이터 인코딩 (특징을 양자 상태로 변환)
function encode_data(circuit, x)
    # 여기서는 단순화를 위해 데이터 인코딩을 생략
    # 실제로는 앵글 인코딩, 진폭 인코딩 등 다양한 방법 사용
    return apply(circuit, zero_state(nqubits(circuit)))
end

# 4. 손실 함수 정의
function loss_function(params, circuit, X, y)
    n_samples = size(X, 2)
    loss = 0.0
    
    for i in 1:n_samples
        # 회로 파라미터 업데이트
        updated_circuit = update_params(circuit, params)
        
        # 데이터 인코딩 및 회로 실행
        state = encode_data(updated_circuit, X[:, i])
        
        # 측정 결과 (첫 번째 큐비트의 기대값)
        result = expect(put(1 => Z), state) |> real
        
        # 이진 분류 손실 (간소화된 버전)
        pred = result > 0 ? 1 : 0
        loss += (pred - y[i])^2
    end
    
    return loss / n_samples
end

# 파라미터 업데이트 함수
function update_params(circuit, params)
    # 실제 구현에서는 회로의 파라미터를 업데이트
    # 여기서는 간소화
    return circuit
end

# 5. 학습 과정
function train_quantum_model(X, y, n_qubits, n_layers, n_epochs)
    circuit, initial_params = create_quantum_circuit(n_qubits, n_layers)
    
    # 최적화 설정
    optimizer = BFGS()
    
    # 손실 함수 (클로저)
    function f(p)
        return loss_function(p, circuit, X, y)
    end
    
    # 그래디언트 계산 (자동 미분)
    function g!(G, p)
        G .= Zygote.gradient(f, p)[1]
    end
    
    # 최적화 실행
    result = Optim.optimize(f, g!, initial_params, optimizer, 
                          Optim.Options(iterations=n_epochs))
    
    optimal_params = Optim.minimizer(result)
    return circuit, optimal_params
end

# 메인 실행 코드
# 주: 이 코드는 개념적 이해를 위한 것으로, 실제 실행은 복잡한 설정이 필요합니다.
n_qubits = 4
n_layers = 2
n_samples = 100
n_epochs = 50

X, y = generate_data(n_samples)
println("데이터 생성 완료: $(n_samples)개의 샘플")

# 학습 (실제 실행 시 시간이 오래 걸릴 수 있음)
# circuit, optimal_params = train_quantum_model(X, y, n_qubits, n_layers, n_epochs)
println("양자 머신러닝 모델 개념 설명 완료!")
      

# 1. 희소 표현 활용하기
using SparseArrays

# 희소 행렬로 게이트 정의
sparse_gate = spzeros(ComplexF64, 2^n, 2^n)
# ... (희소 행렬 채우기)
sparse_block = matblock(sparse_gate)

# 2. 불필요한 중간 상태 제거하기
function optimized_circuit()
    reg = zero_state(n)
    reg = apply!(reg, gate1)  # apply! 사용하여 제자리 업데이트
    reg = apply!(reg, gate2)
    # ... 더 많은 게이트 적용
    return reg
end

# 3. 정확한 타입 사용하기
# Float64 대신 Float32를 사용하면 메모리를 절반으로 줄일 수 있어요
reg_f32 = ArrayReg{Float32}(zero_state(n).state)
      

# 1. 회로 최적화하기
using Yao.YaoCompiler

# 회로 최적화
optimized_circuit = optimize_circuit(original_circuit)

# 2. 병렬 처리 활용하기
using Distributed
addprocs(4)  # 4개의 프로세서 추가

@everywhere using Yao

# 병렬로 여러 시뮬레이션 실행
results = @distributed (vcat) for i in 1:100
    measure(apply(circuit, zero_state(n)); nshots=1)
end

# 3. GPU 가속 활용하기 (CUDA.jl 필요)
using Yao, YaoArrayRegister, CuYao

# GPU로 상태 벡터 이동
cu_reg = cu(zero_state(n))
cu_circuit = chain(n, H, X, control(1, 2=>Z))
result = apply!(cu_reg, cu_circuit)
      

# 1. 텐서 네트워크 방법 사용하기
using ITensors

# 텐서 네트워크 기반 시뮬레이션
# (실제 구현은 더 복잡하지만, 개념적으로는 이런 방식)
function tensor_network_simulation(circuit, n)
    # MPS(Matrix Product State) 초기화
    sites = siteinds("Qubit", n)
    psi = MPS(sites, "0")
    
    # 회로 적용
    # ...
    
    return psi
end

# 2. 대칭성 활용하기
function symmetry_aware_simulation(circuit, n)
    # 회로의 대칭성을 활용하여 필요한 계산 줄이기
    # ...
end

# 3. 확률적 방법 사용하기
function monte_carlo_simulation(circuit, n, samples=1000)
    # 몬테카를로 방법으로 근사 결과 계산
    # ...
end
      

⚠️ 성능 측정 및 병목 찾기

최적화하기 전에 항상 성능을 측정하고 병목을 찾는 것이 중요해요!

using BenchmarkTools

# 코드 성능 측정
@btime apply($circuit, $zero_state(n))

# 메모리 할당 확인
@allocated apply(circuit, zero_state(n))

# 프로파일링
using Profile
@profile apply(circuit, zero_state(n))
Profile.print()
      

# 1. 블록 합성 최적화
# 여러 게이트를 하나의 유닛으로 합성
composite_gate = chain(X, H, Z) |> Yao.YaoCompiler.simplify

# 2. 상수 레지스터 사용
# 자주 사용하는 초기 상태는 상수로 정의
const ZERO_STATE_10 = zero_state(10)

# 3. 정적 회로 사용
# 회로 구조가 고정된 경우 정적 회로 사용
static_circuit = chain(n, put(1=>X), put(2=>Y), control(1, 3=>Z))
      

# 미래의 코드 예시 (개념적)
using QuantumHardware

# 클라우드 양자 컴퓨터에 연결
qpu = connect_quantum_device("ibm_oslo")

# Julia로 회로 정의
circuit = chain(2, put(1 => H), control(1, 2 => X))

# 실제 양자 하드웨어에서 실행
results = execute(qpu, circuit, shots=1000)

# 결과 분석
plot_histogram(results)