lift-quantum 0.4.2

LIFT-QUANTUM: Quantum dialect — qubits (linear types), gates, noise attributes, layout mapping
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum NoiseModel {
    Ideal,
    Depolarizing {
        p: f64,
    },
    AmplitudeDamping {
        gamma: f64,
    },
    PhaseDamping {
        gamma: f64,
    },
    BitFlip {
        p: f64,
    },
    PhaseFlip {
        p: f64,
    },
    ThermalRelaxation {
        t1_us: f64,
        t2_us: f64,
        gate_time_us: f64,
    },
    Kraus {
        operators: Vec<Vec<(f64, f64)>>,
    },
    Composed(Vec<NoiseModel>),
}

impl NoiseModel {
    pub fn fidelity(&self) -> f64 {
        match self {
            NoiseModel::Ideal => 1.0,
            NoiseModel::Depolarizing { p } => 1.0 - p,
            NoiseModel::AmplitudeDamping { gamma } => 1.0 - gamma / 2.0,
            NoiseModel::PhaseDamping { gamma } => 1.0 - gamma / 2.0,
            NoiseModel::BitFlip { p } => 1.0 - p,
            NoiseModel::PhaseFlip { p } => 1.0 - p,
            NoiseModel::ThermalRelaxation {
                t1_us,
                t2_us,
                gate_time_us,
            } => {
                let p1 = (-gate_time_us / t1_us).exp();
                let p2 = (-gate_time_us / t2_us).exp();
                (1.0 + p1 + 2.0 * p2) / 4.0
            }
            NoiseModel::Kraus { .. } => 0.99, // approximate
            NoiseModel::Composed(models) => models.iter().map(|m| m.fidelity()).product(),
        }
    }

    pub fn compose(&self, other: &NoiseModel) -> NoiseModel {
        match (self, other) {
            (NoiseModel::Ideal, m) | (m, NoiseModel::Ideal) => m.clone(),
            _ => NoiseModel::Composed(vec![self.clone(), other.clone()]),
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GateNoise {
    pub gate_fidelity: f64,
    pub gate_time_us: f64,
    pub noise: NoiseModel,
}

impl GateNoise {
    pub fn ideal() -> Self {
        Self {
            gate_fidelity: 1.0,
            gate_time_us: 0.0,
            noise: NoiseModel::Ideal,
        }
    }

    pub fn with_depolarizing(fidelity: f64, gate_time: f64) -> Self {
        Self {
            gate_fidelity: fidelity,
            gate_time_us: gate_time,
            noise: NoiseModel::Depolarizing { p: 1.0 - fidelity },
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CircuitNoise {
    pub total_fidelity: f64,
    pub gate_count: usize,
    pub two_qubit_count: usize,
    pub circuit_depth: usize,
    pub total_time_us: f64,
}

impl CircuitNoise {
    pub fn new() -> Self {
        Self {
            total_fidelity: 1.0,
            gate_count: 0,
            two_qubit_count: 0,
            circuit_depth: 0,
            total_time_us: 0.0,
        }
    }

    pub fn add_gate(&mut self, noise: &GateNoise, is_two_qubit: bool) {
        self.total_fidelity *= noise.gate_fidelity;
        self.gate_count += 1;
        self.total_time_us += noise.gate_time_us;
        if is_two_qubit {
            self.two_qubit_count += 1;
        }
    }

    pub fn meets_threshold(&self, min_fidelity: f64) -> bool {
        self.total_fidelity >= min_fidelity
    }
}

impl Default for CircuitNoise {
    fn default() -> Self {
        Self::new()
    }
}