quantrs2-sim 0.2.0

Quantum circuit simulators for the QuantRS2 framework
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

//! # QuantumChemistrySimulator - calculate_single_pauli_expectation_group Methods
//!
//! This module contains method implementations for `QuantumChemistrySimulator`.
//!
//! 🤖 Generated with [SplitRS](https://github.com/cool-japan/splitrs)

use crate::error::{Result, SimulatorError};
use crate::pauli::{PauliOperator, PauliOperatorSum, PauliString};
use scirs2_core::ndarray::{Array1, Array2, Array4};
use scirs2_core::random::prelude::*;
use scirs2_core::Complex64;

use super::quantumchemistrysimulator_type::QuantumChemistrySimulator;

impl QuantumChemistrySimulator {
    /// Calculate expectation value of single Pauli string
    pub(super) fn calculate_single_pauli_expectation(
        &self,
        state: &Array1<Complex64>,
        pauli_string: &PauliString,
    ) -> Result<Complex64> {
        let mut result_state = state.clone();
        for (qubit, pauli_op) in pauli_string.operators.iter().enumerate() {
            match pauli_op {
                PauliOperator::X => {
                    self.apply_pauli_x(&mut result_state, qubit)?;
                }
                PauliOperator::Y => {
                    self.apply_pauli_y(&mut result_state, qubit)?;
                }
                PauliOperator::Z => {
                    self.apply_pauli_z(&mut result_state, qubit)?;
                }
                PauliOperator::I => {}
            }
        }
        let expectation = state
            .iter()
            .zip(result_state.iter())
            .map(|(a, b)| a.conj() * b)
            .sum::<Complex64>();
        Ok(expectation * pauli_string.coefficient)
    }
    /// Apply Pauli-X operator to state
    pub(super) fn apply_pauli_x(&self, state: &mut Array1<Complex64>, qubit: usize) -> Result<()> {
        let n = state.len();
        let bit_mask = 1 << qubit;
        for i in 0..n {
            if (i & bit_mask) == 0 {
                let j = i | bit_mask;
                if j < n {
                    let temp = state[i];
                    state[i] = state[j];
                    state[j] = temp;
                }
            }
        }
        Ok(())
    }
    /// Apply Pauli-Y operator to state
    pub(super) fn apply_pauli_y(&self, state: &mut Array1<Complex64>, qubit: usize) -> Result<()> {
        let n = state.len();
        let bit_mask = 1 << qubit;
        for i in 0..n {
            if (i & bit_mask) == 0 {
                let j = i | bit_mask;
                if j < n {
                    let temp = state[i];
                    state[i] = -Complex64::i() * state[j];
                    state[j] = Complex64::i() * temp;
                }
            }
        }
        Ok(())
    }
    /// Apply Pauli-Z operator to state
    pub(super) fn apply_pauli_z(&self, state: &mut Array1<Complex64>, qubit: usize) -> Result<()> {
        let bit_mask = 1 << qubit;
        for i in 0..state.len() {
            if (i & bit_mask) != 0 {
                state[i] = -state[i];
            }
        }
        Ok(())
    }
}