kana 1.1.0

Quantum mechanics simulation — state vectors, operators, entanglement, quantum circuits
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
127
128
129
130
131
132
133
134

//! # Kana — Quantum mechanics simulation for AGNOS
//!
//! Sanskrit: कण (kana) — particle, atom
//!
//! Provides quantum state vectors, Hilbert spaces, unitary operators,
//! entanglement simulation, quantum circuit primitives, and time evolution.
//! Built on [hisab](https://crates.io/crates/hisab) for complex linear
//! algebra (via the `hisab-bridge` feature).
//!
//! # Modules
//!
//! - [`state`] — State vectors, kets/bras, measurement, Bloch sphere
//! - [`operator`] — Unitary operators, Pauli/rotation gates, decompositions
//! - [`entanglement`] — Density matrices, entanglement measures, noise channels
//! - [`circuit`] — Quantum circuits, gate optimization, algorithms (Grover, QFT, VQE)
//! - [`safe`] — Ownership-based circuit builder (compile-time no-cloning)
//! - [`dynamics`] — Time evolution (Schrodinger, Lindblad master equation)
//! - [`bridge`] — Hisab interop (feature-gated)
//! - [`parallel`] — Rayon-parallelized operations (feature-gated)
//! - [`error`] — Error types

pub mod error;

#[cfg(feature = "state")]
pub mod state;

#[cfg(feature = "operator")]
pub mod operator;

#[cfg(feature = "entanglement")]
pub mod entanglement;

#[cfg(feature = "circuit")]
pub mod circuit;

#[cfg(feature = "circuit")]
pub mod safe;

#[cfg(all(feature = "state", feature = "operator", feature = "entanglement"))]
pub mod dynamics;

#[cfg(feature = "logging")]
pub mod logging;

#[cfg(feature = "ai")]
pub mod ai;

#[cfg(feature = "hisab-bridge")]
pub mod bridge;

#[cfg(all(feature = "parallel", feature = "state", feature = "operator"))]
pub mod parallel;

pub use error::{KanaError, Result};

#[cfg(feature = "state")]
pub use state::{NORM_TOLERANCE, StateVector};

#[cfg(feature = "operator")]
pub use operator::{KakDecomposition, Operator, SparseOperator};

#[cfg(feature = "entanglement")]
pub use entanglement::{DensityMatrix, NoiseChannel};

#[cfg(feature = "circuit")]
pub use circuit::Circuit;

#[cfg(feature = "circuit")]
pub use safe::{ClassicalBit, QuantumBuilder, Qubit};

#[cfg(all(feature = "state", feature = "operator", feature = "entanglement"))]
pub use dynamics::{Hamiltonian, expectation_value};

/// Convenience re-exports for common usage.
pub mod prelude {
    pub use crate::error::{KanaError, Result};

    #[cfg(feature = "state")]
    pub use crate::state::StateVector;

    #[cfg(feature = "operator")]
    pub use crate::operator::Operator;

    #[cfg(feature = "entanglement")]
    pub use crate::entanglement::{DensityMatrix, NoiseChannel};

    #[cfg(feature = "circuit")]
    pub use crate::circuit::Circuit;

    #[cfg(feature = "circuit")]
    pub use crate::safe::{ClassicalBit, QuantumBuilder, Qubit};

    #[cfg(all(feature = "state", feature = "operator", feature = "entanglement"))]
    pub use crate::dynamics::Hamiltonian;
}

// Compile-time trait assertions: all public types must be Send + Sync.
#[cfg(test)]
mod assert_traits {
    fn _assert_send_sync<T: Send + Sync>() {}

    #[test]
    fn public_types_are_send_sync() {
        _assert_send_sync::<crate::error::KanaError>();

        #[cfg(feature = "state")]
        _assert_send_sync::<crate::state::StateVector>();

        #[cfg(feature = "operator")]
        {
            _assert_send_sync::<crate::operator::Operator>();
            _assert_send_sync::<crate::operator::SparseOperator>();
            _assert_send_sync::<crate::operator::KakDecomposition>();
        }

        #[cfg(feature = "entanglement")]
        {
            _assert_send_sync::<crate::entanglement::DensityMatrix>();
            _assert_send_sync::<crate::entanglement::NoiseChannel>();
        }

        #[cfg(feature = "circuit")]
        {
            _assert_send_sync::<crate::circuit::Circuit>();
            _assert_send_sync::<crate::circuit::Gate>();
            _assert_send_sync::<crate::safe::Qubit>();
            _assert_send_sync::<crate::safe::ClassicalBit>();
            _assert_send_sync::<crate::safe::QuantumBuilder>();
        }

        #[cfg(all(feature = "state", feature = "operator", feature = "entanglement"))]
        _assert_send_sync::<crate::dynamics::Hamiltonian>();
    }
}