rqism 0.4.1

A multi-backend quantum circuit simulator
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

use ndarray::Array2;
use num::Complex;
use rand::{distributions::WeightedIndex, prelude::Distribution, rngs::ThreadRng, Rng};

use crate::{
    circuit::Circuit,
    counts::Counts,
    instruction::{Instruction, PauliKind},
};

/// Trait that must be implemented for all simulators. Includes common behaviour
pub trait Simulator {
    fn execute_instruction(&mut self, ins: &Instruction);
    fn execute_circuit(&mut self, circuit: &Circuit);
    fn get_counts(&self, circuit: &Circuit, n: usize) -> Counts;
    fn get_random(&mut self) -> &mut ThreadRng;

    fn apply_local_depolarizing_noise(&mut self, target: usize, p: f32) {
        let rng = self.get_random();
        let pauli_kinds = [
            None,
            Some(PauliKind::X),
            Some(PauliKind::Y),
            Some(PauliKind::Z),
        ];

        let weights = [1.0 - p, p / 3.0, p / 3.0, p / 3.0];

        let dist = WeightedIndex::new(weights).unwrap();

        let op = pauli_kinds[dist.sample(rng)];

        if let Some(k) = op {
            self.execute_instruction(&Instruction::Pauli { kind: k, target });
        }
    }

    fn apply_amplitude_damping(&mut self, target: usize, gamma: f32) {
        let e0 = Array2::from_shape_vec(
            (2, 2),
            vec![
                Complex::new(1.0, 0.0),
                Complex::new(0.0, 0.0),
                Complex::new(0.0, 0.0),
                Complex::new((1.0 - gamma).sqrt(), 0.0),
            ],
        )
        .unwrap();

        let e1 = Array2::from_shape_vec(
            (2, 2),
            vec![
                Complex::new(0.0, 0.0),
                Complex::new(gamma.sqrt(), 0.0),
                Complex::new(0.0, 0.0),
                Complex::new(0.0, 0.0),
            ],
        )
        .unwrap();

        let k = self.get_random().gen_range(0.0..1.0);

        self.execute_instruction(&Instruction::Gate {
            matrix: std::borrow::Cow::Owned(if k < gamma { e1 } else { e0 }),
            indices: vec![target],
            kind: None,
        });
    }
}