☕ Java SDK v1.8.3

엔터프라이즈급 양자 컴퓨팅 라이브러리 - Spring Boot 완벽 지원

🏢 엔터프라이즈

대규모 시스템 최적화

🌱 Spring Boot

자동 구성 및 의존성 주입

🔒 타입 안전성

컴파일 타임 에러 검출

⚡ 멀티스레드

병렬 시뮬레이션 지원

설치

Maven

XML<dependency>
    <groupId>com.cqmdesk</groupId>
    <artifactId>quantum-sdk</artifactId>
    <version>1.8.3</version>
</dependency>

Gradle

Groovyimplementation 'com.cqmdesk:quantum-sdk:1.8.3'

Gradle (Kotlin DSL)

Kotlinimplementation("com.cqmdesk:quantum-sdk:1.8.3")

빠른 시작

기본 예제

Javaimport com.cqmdesk.quantum.*;

public class QuantumExample {
    public static void main(String[] args) {
        // 2큐비트 Bell 상태 생성
        QuantumCircuit qc = new QuantumCircuit(2);
        qc.h(0);           // Hadamard gate on qubit 0
        qc.cx(0, 1);       // CNOT gate (control: 0, target: 1)
        qc.measureAll();
        
        // 시뮬레이터 실행
        Simulator sim = new Simulator();
        Result result = sim.run(qc, 1000);
        
        System.out.println(result.getCounts());
        // Output: {00=502, 11=498}
    }
}

Spring Boot 통합

Javaimport org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import com.cqmdesk.quantum.*;

@SpringBootApplication
public class QuantumApplication {
    
    public static void main(String[] args) {
        SpringApplication.run(QuantumApplication.class, args);
    }
    
    @Bean
    public Simulator quantumSimulator() {
        return new Simulator.Builder()
                .backend("statevector")
                .optimization(2)
                .build();
    }
}

주요 기능

1. 양자 회로 생성

JavaQuantumCircuit qc = new QuantumCircuit(4);  // 4큐비트 회로

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

// 회전 게이트
qc.rx(Math.PI / 4, 0);  // X축 회전
qc.ry(Math.PI / 2, 1);  // Y축 회전
qc.rz(Math.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. 빌더 패턴

JavaQuantumCircuit qc = QuantumCircuit.builder()
        .qubits(3)
        .gate(Gate.H, 0)
        .gate(Gate.CNOT, 0, 1)
        .gate(Gate.CNOT, 1, 2)
        .measureAll()
        .build();

3. 고급 시뮬레이션

JavaSimulator sim = new Simulator.Builder()
        .backend("statevector")
        .optimization(2)
        .threads(4)
        .seed(42)
        .build();

SimulationOptions options = SimulationOptions.builder()
        .shots(10000)
        .memoryLimit("8GB")
        .build();

Result result = sim.run(qc, options);

// 결과 확인
Map<String, Integer> counts = result.getCounts();
ComplexVector statevector = result.getStatevector();
double[] probabilities = result.getProbabilities();

4. Spring Service 예제

Javaimport org.springframework.stereotype.Service;
import org.springframework.beans.factory.annotation.Autowired;

@Service
public class QuantumService {
    
    private final Simulator simulator;
    
    @Autowired
    public QuantumService(Simulator simulator) {
        this.simulator = simulator;
    }
    
    public Result createBellState() {
        QuantumCircuit qc = new QuantumCircuit(2);
        qc.h(0);
        qc.cx(0, 1);
        qc.measureAll();
        
        return simulator.run(qc, 1000);
    }
    
    public Result runGroverSearch(int n, Oracle oracle) {
        QuantumCircuit qc = buildGroverCircuit(n, oracle);
        return simulator.run(qc, 5000);
    }
    
    private QuantumCircuit buildGroverCircuit(int n, Oracle oracle) {
        QuantumCircuit qc = new QuantumCircuit(n);
        
        // 초기화
        for (int i = 0; i < n; i++) {
            qc.h(i);
        }
        
        // Grover 반복
        int iterations = (int) (Math.PI / 4 * Math.sqrt(Math.pow(2, n)));
        for (int iter = 0; iter < iterations; iter++) {
            oracle.apply(qc);
            qc.groverDiffusion();
        }
        
        qc.measureAll();
        return qc;
    }
}

API 레퍼런스

QuantumCircuit

메서드	파라미터	설명
`h(int qubit)`	qubit: 큐비트 인덱스	Hadamard 게이트 적용
`x(int qubit)`	qubit: 큐비트 인덱스	Pauli-X 게이트 적용
`cx(int control, int target)`	control, target: 큐비트 인덱스	CNOT 게이트 적용
`rx(double angle, int qubit)`	angle: 라디안, qubit: 인덱스	X축 회전 게이트
`measure(int qubit, int cbit)`	qubit, cbit: 인덱스	단일 큐비트 측정
`measureAll()`	없음	전체 큐비트 측정

Simulator

메서드	반환 타입	설명
`run(QuantumCircuit qc, int shots)`	Result	회로 실행 (기본)
`run(QuantumCircuit qc, SimulationOptions options)`	Result	회로 실행 (고급)
`runAsync(QuantumCircuit qc, int shots)`	CompletableFuture<Result>	비동기 실행

Result

메서드	반환 타입	설명
`getCounts()`	Map<String, Integer>	측정 결과 카운트
`getStatevector()`	ComplexVector	상태 벡터
`getProbabilities()`	double[]	확률 분포

고급 예제

병렬 시뮬레이션

Javaimport java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;

public class ParallelQuantum {
    
    public static void main(String[] args) {
        Simulator sim = new Simulator.Builder()
                .threads(8)
                .build();
        
        // 여러 회로를 병렬로 실행
        List<QuantumCircuit> circuits = generateCircuits();
        
        List<CompletableFuture<Result>> futures = circuits.stream()
                .map(qc -> sim.runAsync(qc, 1000))
                .collect(Collectors.toList());
        
        // 모든 결과 수집
        CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
                .thenRun(() -> {
                    futures.forEach(future -> {
                        try {
                            Result result = future.get();
                            System.out.println(result.getCounts());
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    });
                });
    }
    
    private static List<QuantumCircuit> generateCircuits() {
        return List.of(
            createBellCircuit(),
            createGHZCircuit(),
            createQFTCircuit()
        );
    }
}

REST API 예제

Javaimport org.springframework.web.bind.annotation.*;
import org.springframework.beans.factory.annotation.Autowired;

@RestController
@RequestMapping("/api/quantum")
public class QuantumController {
    
    @Autowired
    private QuantumService quantumService;
    
    @PostMapping("/bell-state")
    public ResponseEntity<Result> createBellState() {
        Result result = quantumService.createBellState();
        return ResponseEntity.ok(result);
    }
    
    @PostMapping("/grover")
    public ResponseEntity<Result> runGrover(
            @RequestParam int numQubits,
            @RequestBody OracleRequest oracleRequest) {
        
        Oracle oracle = oracleRequest.toOracle();
        Result result = quantumService.runGroverSearch(numQubits, oracle);
        
        return ResponseEntity.ok(result);
    }
    
    @GetMapping("/circuit/{id}")
    public ResponseEntity<QuantumCircuit> getCircuit(@PathVariable String id) {
        QuantumCircuit qc = quantumService.getCircuit(id);
        return ResponseEntity.ok(qc);
    }
}

JUnit 테스트

Javaimport org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

class QuantumCircuitTest {
    
    @Test
    void testBellState() {
        QuantumCircuit qc = new QuantumCircuit(2);
        qc.h(0);
        qc.cx(0, 1);
        qc.measureAll();
        
        Simulator sim = new Simulator();
        Result result = sim.run(qc, 1000);
        
        Map<String, Integer> counts = result.getCounts();
        
        // Bell 상태는 |00⟩과 |11⟩만 나와야 함
        assertTrue(counts.containsKey("00"));
        assertTrue(counts.containsKey("11"));
        assertFalse(counts.containsKey("01"));
        assertFalse(counts.containsKey("10"));
        
        // 약 50:50 비율
        int count00 = counts.get("00");
        int count11 = counts.get("11");
        assertTrue(Math.abs(count00 - count11) < 100);
    }
}

💡 Pro Tip: @EnableQuantum 어노테이션을 사용하면 Spring Boot에서 자동 구성을 활성화할 수 있습니다.

⚠️ 주의: 대규모 시뮬레이션 시 JVM 힙 메모리 설정 필요: -Xmx8g

성능 최적화

Java// application.properties
cqm.quantum.backend=statevector
cqm.quantum.optimization=3
cqm.quantum.threads=8
cqm.quantum.memory-limit=8GB
cqm.quantum.cache-enabled=true

문의 및 지원

📖 문서: docs.cqmdesk.com/sdk/java
💬 Discord: discord.gg/cqmdesk
🐛 이슈: GitHub Issues
📧 이메일: sdk@cqmdesk.com