QSim — 量子计算全栈模拟器

QSim 是一个支持 32 量子比特的态向量与张量网络混合模拟引擎，实现了 Shor 算法、Grover 搜索、VQE 变分求解器等经典量子算法，并包含噪声模型与量子纠错码的完整模拟。

一、态向量模拟核心

态向量模拟将 n 量子比特的量子态表示为 2^n 维复向量。量子门操作为该向量上的酉矩阵乘法。使用 SIMD 指令加速复数运算，32 量子比特需要 64GB 内存。

use num_complex::Complex64;
use std::arch::x86_64::*;

pub struct StateVector {
    data: Vec,
    num_qubits: usize,
}

impl StateVector {
    pub fn apply_hadamard(&mut self, target: usize) {
        let mask = 1 << target;
        let inv_sqrt2 = 1.0 / 2.0_f64.sqrt();

        for i in 0..self.data.len() {
            if i & mask == 0 {
                let j = i | mask;
                let a = self.data[i];
                let b = self.data[j];
                self.data[i] = (a + b) * inv_sqrt2;
                self.data[j] = (a - b) * inv_sqrt2;
            }
        }
    }

    pub fn apply_cnot(&mut self, control: usize, target: usize) {
        let c_mask = 1 << control;
        let t_mask = 1 << target;

        for i in 0..self.data.len() {
            if i & c_mask != 0 {
                let j = i ^ t_mask;
                if i < j {
                    self.data.swap(i, j);
                }
            }
        }
    }
}

二、Shor 算法实现

Shor 算法是量子计算最具代表性的算法，能在多项式时间内分解大整数。核心是量子傅里叶变换（QFT）和模幂运算的量子电路实现。

impl QSim {
    pub fn shor_factor(&mut self, n: u64) -> Option {
        // 1. 随机选择 a，满足 1 < a < n 且 gcd(a, n) = 1
        let a = self.random_coprime(n);

        // 2. 构建量子电路：Hadamard + 模幂 + QFT
        let num_qubits = (2 * n as f64).log2().ceil() as usize;
        let mut circuit = QuantumCircuit::new(num_qubits * 2);

        // 初始化叠加态
        for q in 0..num_qubits {
            circuit.add_gate(Gate::Hadamard(q));
        }

        // 模幂运算 U_a |x⟩|y⟩ = |x⟩|y ⊕ a^x mod n⟩
        circuit.add_gate(Gate::ModularExponentiation {
            base: a, modulus: n, reg1: 0..num_qubits, reg2: num_qubits..
        });

        // 逆量子傅里叶变换
        circuit.add_gate(Gate::InverseQFT { qubits: 0..num_qubits });

        // 3. 测量并提取周期
        let result = self.run_and_measure(&circuit);
        let period = self.extract_period(result, a, n);

        // 4. 计算因子
        if period % 2 == 0 {
            let factor1 = gcd(a.pow(period / 2) - 1, n);
            let factor2 = gcd(a.pow(period / 2) + 1, n);
            if factor1 > 1 && factor1 < n { return Some(factor1); }
            if factor2 > 1 && factor2 < n { return Some(factor2); }
        }
        None
    }
}

三、张量网络压缩

对于低纠缠度的量子电路，使用张量网络（MPS/PEPS）表示可将内存复杂度从 O(2^n) 降至 O(n·χ²)，其中 χ 为键维度。这使得模拟 100+ 量子比特成为可能。

pub struct MatrixProductState {
    tensors: Vec>,
    bond_dimension: usize,
}

impl MatrixProductState {
    pub fn apply_two_qubit_gate(&mut self, gate: &Array4,
        q1: usize, q2: usize)
    {
        // 收缩相邻张量
        let theta = self.contract_neighbors(q1, q2);

        // 应用门操作
        let theta_prime = self.apply_gate_to_theta(&theta, gate);

        // SVD 分解恢复 MPS 形式
        let (u, s, v) = self.svd_decompose(&theta_prime);
        self.tensors[q1] = u;
        self.tensors[q2] = v;

        // 截断键维度
        self.truncate_bond_dimension(q1, s);
    }
}

四、噪声模型与纠错码

支持多种量子噪声通道：比特翻转、相位翻转、去极化噪声、振幅阻尼。实现了 Shor 码和 Surface Code 两种纠错码，可模拟容错量子计算。

pub enum NoiseChannel {
    BitFlip(f64),           // 概率 p
    PhaseFlip(f64),
    Depolarizing(f64),      // 完全去极化
    AmplitudeDamping(f64),  // 振幅阻尼参数 gamma
}

impl StateVector {
    pub fn apply_noise(&mut self, qubit: usize, channel: &NoiseChannel) {
        match channel {
            NoiseChannel::BitFlip(p) => {
                let sqrt_p = p.sqrt();
                let sqrt_1mp = (1.0 - p).sqrt();
                // Kraus 算子: E0 = sqrt(1-p)*I, E1 = sqrt(p)*X
                self.apply_kraus(qubit, &[
                    (sqrt_1mp, &Pauli::I),
                    (sqrt_p, &Pauli::X),
                ]);
            }
            NoiseChannel::Depolarizing(p) => {
                let p3 = p / 3.0;
                self.apply_kraus(qubit, &[
                    ((1.0 - p).sqrt(), &Pauli::I),
                    (p3.sqrt(), &Pauli::X),
                    (p3.sqrt(), &Pauli::Y),
                    (p3.sqrt(), &Pauli::Z),
                ]);
            }
            _ => unimplemented!(),
        }
    }
}

五、VQE 变分量子求解器

实现 Variational Quantum Eigensolver（VQE），使用经典优化器（L-BFGS）优化参数化量子电路的参数，求解分子基态能量。支持 Jordan-Wigner 变换将费米子哈密顿量映射到量子比特。

QSim 是量子计算与经典高性能计算交叉领域的深度实践，展示了从底层线性代数到上层量子算法的全栈能力。