quantrs2-sim 0.1.3

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

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

use crate::error::{Result, SimulatorError};
use scirs2_core::random::prelude::*;

use super::types::{GeometryMeasurements, SimplicialComplex, TopologyMeasurements};

use super::quantumgravitysimulator_type::QuantumGravitySimulator;

impl QuantumGravitySimulator {
    /// Measure CDT geometry properties
    pub(super) fn measure_cdt_geometry(
        &self,
        complex: &SimplicialComplex,
    ) -> Result<GeometryMeasurements> {
        let area_spectrum: Vec<f64> = complex
            .time_slices
            .iter()
            .map(|slice| slice.spatial_volume.powf(2.0 / 3.0))
            .collect();
        let volume_spectrum: Vec<f64> = complex
            .time_slices
            .iter()
            .map(|slice| slice.spatial_volume)
            .collect();
        let length_spectrum: Vec<f64> = complex
            .simplices
            .iter()
            .map(|_| self.config.planck_length)
            .collect();
        let discrete_curvature: f64 = complex
            .time_slices
            .iter()
            .map(|slice| slice.curvature)
            .sum::<f64>()
            / complex.time_slices.len() as f64;
        let topology_measurements = TopologyMeasurements {
            euler_characteristic: self.calculate_euler_characteristic(complex)?,
            betti_numbers: vec![1, 0, 0, 1],
            homology_groups: vec![
                "Z".to_string(),
                "0".to_string(),
                "0".to_string(),
                "Z".to_string(),
            ],
            fundamental_group: "trivial".to_string(),
        };
        Ok(GeometryMeasurements {
            area_spectrum,
            volume_spectrum,
            length_spectrum,
            discrete_curvature,
            topology_measurements,
        })
    }
    /// Calculate Euler characteristic of simplicial complex
    pub(super) fn calculate_euler_characteristic(
        &self,
        complex: &SimplicialComplex,
    ) -> Result<i32> {
        let vertices = complex.vertices.len() as i32;
        let edges = complex
            .simplices
            .iter()
            .map(|s| s.vertices.len() * (s.vertices.len() - 1) / 2)
            .sum::<usize>() as i32;
        let faces = complex.simplices.len() as i32;
        Ok(vertices - edges + faces)
    }
}