🦀 Rust SDK v0.9.2

안전하고 빠른 양자 컴퓨팅 라이브러리 - 메모리 안전성 보장, Zero-Cost Abstraction

⚡ 고성능

C/C++ 수준의 실행 속도

🔒 메모리 안전

컴파일 타임 메모리 체크

🧵 동시성

안전한 멀티스레드 처리

🎯 Zero-Cost

추상화 비용 제로

설치

Cargo.toml에 추가

TOML[dependencies]
cqm-quantum = "0.9.2"

또는 Cargo 명령어

Bashcargo add cqm-quantum

빠른 시작

기본 예제

Rustuse cqm_quantum::{QuantumCircuit, Simulator};
use std::f64::consts::PI;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 2큐비트 Bell 상태 생성
    let mut qc = QuantumCircuit::new(2)?;
    qc.h(0)?;           // Hadamard gate on qubit 0
    qc.cx(0, 1)?;       // CNOT gate (control: 0, target: 1)
    qc.measure_all()?;
    
    // 시뮬레이터 실행
    let sim = Simulator::new();
    let result = sim.run(&qc, 1000)?;
    
    println!("{:?}", result.counts());
    // Output: {"00": 502, "11": 498}
    
    Ok(())
}

비동기 예제 (Tokio)

Rustuse cqm_quantum::{QuantumCircuit, Simulator};
use tokio;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut qc = QuantumCircuit::new(3)?;
    qc.h(0)?;
    qc.h(1)?;
    qc.h(2)?;
    qc.measure_all()?;
    
    let sim = Simulator::new();
    let result = sim.run_async(&qc, 1000).await?;
    
    println!("Results: {:?}", result.counts());
    
    Ok(())
}

주요 기능

1. 양자 회로 생성

Rustuse cqm_quantum::QuantumCircuit;
use std::f64::consts::PI;

let mut qc = QuantumCircuit::new(4)?;  // 4큐비트 회로

// 기본 게이트
qc.h(0)?;                    // Hadamard
qc.x(1)?;                    // Pauli-X (NOT)
qc.y(2)?;                    // Pauli-Y
qc.z(3)?;                    // Pauli-Z

// 회전 게이트
qc.rx(PI / 4.0, 0)?;         // X축 회전
qc.ry(PI / 2.0, 1)?;         // Y축 회전
qc.rz(PI, 2)?;               // Z축 회전

// 제어 게이트
qc.cx(0, 1)?;                // CNOT
qc.cz(1, 2)?;                // Controlled-Z
qc.ccx(0, 1, 2)?;            // Toffoli (CCX)

// 기타
qc.swap(0, 1)?;              // SWAP
qc.measure(0, 0)?;           // 측정

2. Builder 패턴

Rustuse cqm_quantum::QuantumCircuit;

let qc = QuantumCircuit::builder()
    .qubits(3)
    .h(0)
    .cx(0, 1)
    .cx(1, 2)
    .measure_all()
    .build()?;

3. 고급 시뮬레이션

Rustuse cqm_quantum::{Simulator, SimulatorOptions, Backend};

let sim = Simulator::with_options(
    SimulatorOptions::new()
        .backend(Backend::Statevector)
        .optimization_level(3)
        .threads(8)
        .seed(42)
)?;

let result = sim.run(&qc, 10000)?;

// 결과 확인
let counts = result.counts();
let statevector = result.statevector()?;
let probabilities = result.probabilities()?;

4. 에러 처리

Rustuse cqm_quantum::{QuantumCircuit, QuantumError};

fn create_bell_state() -> Result<QuantumCircuit, QuantumError> {
    let mut qc = QuantumCircuit::new(2)?;
    
    qc.h(0)?;
    qc.cx(0, 1)?;
    qc.measure_all()?;
    
    Ok(qc)
}

fn main() {
    match create_bell_state() {
        Ok(qc) => println!("Circuit created successfully"),
        Err(e) => eprintln!("Error: {}", e),
    }
}

API 레퍼런스

QuantumCircuit

메서드	시그니처	설명
`new(num_qubits)`	`fn(usize) -> Result<Self>`	새 회로 생성
`h(qubit)`	`fn(&mut self, usize) -> Result<()>`	Hadamard 게이트
`cx(control, target)`	`fn(&mut self, usize, usize) -> Result<()>`	CNOT 게이트
`rx(angle, qubit)`	`fn(&mut self, f64, usize) -> Result<()>`	X축 회전
`measure(qubit, cbit)`	`fn(&mut self, usize, usize) -> Result<()>`	단일 큐비트 측정

Simulator

메서드	반환 타입	설명
`run(&qc, shots)`	Result<SimulationResult>	동기 실행
`run_async(&qc, shots)`	impl Future<Output = Result<SimulationResult>>	비동기 실행

고급 예제

병렬 시뮬레이션 (Rayon)

Rustuse cqm_quantum::{QuantumCircuit, Simulator};
use rayon::prelude::*;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let circuits = generate_circuits()?;
    let sim = Simulator::new();
    
    let results: Vec<_> = circuits
        .par_iter()
        .map(|qc| sim.run(qc, 1000))
        .collect::<Result<Vec<_>, _>>()?;
    
    for result in results {
        println!("{:?}", result.counts());
    }
    
    Ok(())
}

Grover 알고리즘

Rustuse cqm_quantum::{QuantumCircuit, Simulator};
use std::f64::consts::PI;

fn grover_search(n: usize, oracle: impl Fn(&mut QuantumCircuit) -> Result<(), Box<dyn std::error::Error>>) 
    -> Result<QuantumCircuit, Box<dyn std::error::Error>> 
{
    let mut qc = QuantumCircuit::new(n)?;
    
    // 초기화: 균등 중첩
    for i in 0..n {
        qc.h(i)?;
    }
    
    // Grover 반복
    let iterations = (PI / 4.0 * (2_usize.pow(n as u32) as f64).sqrt()) as usize;
    
    for _ in 0..iterations {
        // Oracle
        oracle(&mut qc)?;
        
        // Diffusion
        for i in 0..n {
            qc.h(i)?;
            qc.x(i)?;
        }
        
        qc.h(n - 1)?;
        qc.mcx(&(0..n-1).collect::<Vec<_>>(), n - 1)?;
        qc.h(n - 1)?;
        
        for i in 0..n {
            qc.x(i)?;
            qc.h(i)?;
        }
    }
    
    qc.measure_all()?;
    Ok(qc)
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let oracle = |qc: &mut QuantumCircuit| {
        qc.cz(0, 1)?;
        Ok(())
    };
    
    let qc = grover_search(2, oracle)?;
    
    let sim = Simulator::new();
    let result = sim.run(&qc, 1000)?;
    
    println!("Found: {:?}", result.counts());
    
    Ok(())
}

양자 푸리에 변환 (QFT)

Rustuse cqm_quantum::QuantumCircuit;
use std::f64::consts::PI;

fn qft(qc: &mut QuantumCircuit, qubits: &[usize]) -> Result<(), Box<dyn std::error::Error>> {
    let n = qubits.len();
    
    for i in 0..n {
        qc.h(qubits[i])?;
        
        for j in (i + 1)..n {
            let angle = PI / 2_f64.powi((j - i) as i32);
            qc.cp(angle, qubits[j], qubits[i])?;
        }
    }
    
    // Swap qubits
    for i in 0..(n / 2) {
        qc.swap(qubits[i], qubits[n - i - 1])?;
    }
    
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut qc = QuantumCircuit::new(4)?;
    qft(&mut qc, &[0, 1, 2, 3])?;
    qc.measure_all()?;
    
    Ok(())
}

WASM 통합 (웹 어셈블리)

Rustuse wasm_bindgen::prelude::*;
use cqm_quantum::{QuantumCircuit, Simulator};

#[wasm_bindgen]
pub fn run_bell_state(shots: usize) -> Result<JsValue, JsValue> {
    let mut qc = QuantumCircuit::new(2)
        .map_err(|e| JsValue::from_str(&e.to_string()))?;
    
    qc.h(0).map_err(|e| JsValue::from_str(&e.to_string()))?;
    qc.cx(0, 1).map_err(|e| JsValue::from_str(&e.to_string()))?;
    qc.measure_all().map_err(|e| JsValue::from_str(&e.to_string()))?;
    
    let sim = Simulator::new();
    let result = sim.run(&qc, shots)
        .map_err(|e| JsValue::from_str(&e.to_string()))?;
    
    Ok(serde_wasm_bindgen::to_value(&result.counts())?)
}

하드웨어 제어 인터페이스

Rustuse cqm_quantum::{QuantumCircuit, HardwareBackend};

#[derive(Clone)]
struct CustomHardware {
    // 하드웨어 연결 정보
}

impl HardwareBackend for CustomHardware {
    fn execute(&self, qc: &QuantumCircuit, shots: usize) 
        -> Result<SimulationResult, Box<dyn std::error::Error>> 
    {
        // 실제 양자 하드웨어로 회로 전송
        todo!("Implement hardware communication")
    }
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let hardware = CustomHardware { /* ... */ };
    let mut qc = QuantumCircuit::new(2)?;
    
    qc.h(0)?;
    qc.cx(0, 1)?;
    qc.measure_all()?;
    
    let result = hardware.execute(&qc, 1000)?;
    println!("{:?}", result.counts());
    
    Ok(())
}

💡 Pro Tip: cargo build --release로 컴파일하면 최적화된 성능을 얻을 수 있습니다. 시뮬레이션 속도가 최대 10배 빨라집니다.

⚠️ 주의: Rust SDK는 현재 베타 버전입니다. API가 변경될 수 있으므로 프로덕션 환경에서 사용 시 주의하세요.

성능 벤치마크

작업	Rust	Python	비고
20큐비트 시뮬레이션	1.2초	8.5초	7배 빠름
QFT (15큐비트)	0.5초	3.2초	6.4배 빠름
메모리 사용량	120MB	450MB	3.7배 적음

기능 매트릭스

기능	상태	버전
기본 게이트	✅ 안정	v0.1.0+
제어 게이트	✅ 안정	v0.2.0+
비동기 실행	✅ 안정	v0.5.0+
WASM 지원	✅ 안정	v0.7.0+
하드웨어 백엔드	🚧 베타	v0.9.0+
GPU 가속	🔜 계획	v1.0.0

문의 및 지원

📖 문서: docs.cqmdesk.com/sdk/rust
💬 Discord: discord.gg/cqmdesk
🐛 이슈: GitHub Issues
📧 이메일: sdk@cqmdesk.com
🦀 Crates.io: crates.io/crates/cqm-quantum