872 lines
26 KiB
Rust
872 lines
26 KiB
Rust
//! Comprehensive tests for Quantum/Algebraic Topology Module
|
|
//!
|
|
//! This test suite verifies quantum computing and topology constructs including:
|
|
//! - Quantum state normalization and operations
|
|
//! - Topological invariant computation (Betti numbers)
|
|
//! - Persistent homology
|
|
//! - Structure-preserving encoding
|
|
|
|
use prime_radiant::quantum::{
|
|
ComplexMatrix, ComplexVector, Complex64,
|
|
QuantumState, QuantumBasis, Qubit,
|
|
DensityMatrix, MixedState,
|
|
QuantumChannel, KrausOperator, PauliOperator, PauliType,
|
|
TopologicalInvariant, HomologyGroup, CohomologyGroup, Cocycle,
|
|
PersistenceDiagram, BirthDeathPair, PersistentHomologyComputer,
|
|
Simplex, SimplicialComplex, SparseMatrix, BoundaryMatrix,
|
|
TopologicalCode, StabilizerCode, GraphState, StructurePreservingEncoder,
|
|
TopologicalEnergy, TopologicalCoherenceAnalyzer, QuantumCoherenceMetric,
|
|
QuantumTopologyError, constants,
|
|
};
|
|
use prime_radiant::quantum::complex_matrix::gates;
|
|
use proptest::prelude::*;
|
|
use approx::assert_relative_eq;
|
|
use std::f64::consts::PI;
|
|
|
|
// =============================================================================
|
|
// COMPLEX VECTOR AND MATRIX TESTS
|
|
// =============================================================================
|
|
|
|
mod complex_math_tests {
|
|
use super::*;
|
|
|
|
/// Test complex vector creation and normalization
|
|
#[test]
|
|
fn test_vector_normalization() {
|
|
let mut v = ComplexVector::new(vec![
|
|
Complex64::new(3.0, 0.0),
|
|
Complex64::new(0.0, 4.0),
|
|
]);
|
|
|
|
assert_relative_eq!(v.norm(), 5.0, epsilon = 1e-10);
|
|
|
|
v.normalize();
|
|
assert_relative_eq!(v.norm(), 1.0, epsilon = 1e-10);
|
|
}
|
|
|
|
/// Test inner product
|
|
#[test]
|
|
fn test_inner_product() {
|
|
let v1 = ComplexVector::new(vec![
|
|
Complex64::new(1.0, 0.0),
|
|
Complex64::new(0.0, 0.0),
|
|
]);
|
|
let v2 = ComplexVector::new(vec![
|
|
Complex64::new(0.0, 0.0),
|
|
Complex64::new(1.0, 0.0),
|
|
]);
|
|
|
|
// Orthogonal vectors
|
|
let inner = v1.inner(&v2);
|
|
assert_relative_eq!(inner.norm(), 0.0, epsilon = 1e-10);
|
|
|
|
// Self inner product
|
|
let self_inner = v1.inner(&v1);
|
|
assert_relative_eq!(self_inner.re, 1.0, epsilon = 1e-10);
|
|
assert_relative_eq!(self_inner.im, 0.0, epsilon = 1e-10);
|
|
}
|
|
|
|
/// Test tensor product
|
|
#[test]
|
|
fn test_tensor_product() {
|
|
// |0> tensor |1> = |01>
|
|
let v0 = ComplexVector::basis_state(2, 0); // |0>
|
|
let v1 = ComplexVector::basis_state(2, 1); // |1>
|
|
|
|
let tensor = v0.tensor(&v1);
|
|
|
|
assert_eq!(tensor.dim(), 4);
|
|
// |01> = [0, 1, 0, 0]
|
|
assert_relative_eq!(tensor.data[0].norm(), 0.0, epsilon = 1e-10);
|
|
assert_relative_eq!(tensor.data[1].norm(), 1.0, epsilon = 1e-10);
|
|
assert_relative_eq!(tensor.data[2].norm(), 0.0, epsilon = 1e-10);
|
|
assert_relative_eq!(tensor.data[3].norm(), 0.0, epsilon = 1e-10);
|
|
}
|
|
|
|
/// Test matrix properties
|
|
#[test]
|
|
fn test_matrix_properties() {
|
|
let identity = ComplexMatrix::identity(3);
|
|
|
|
assert!(identity.is_square());
|
|
assert!(identity.is_hermitian(1e-10));
|
|
assert!(identity.is_unitary(1e-10));
|
|
|
|
let trace = identity.trace();
|
|
assert_relative_eq!(trace.re, 3.0, epsilon = 1e-10);
|
|
}
|
|
|
|
/// Test Pauli matrices
|
|
#[test]
|
|
fn test_pauli_matrices() {
|
|
let x = gates::pauli_x();
|
|
let y = gates::pauli_y();
|
|
let z = gates::pauli_z();
|
|
|
|
// All Pauli matrices are Hermitian
|
|
assert!(x.is_hermitian(1e-10));
|
|
assert!(y.is_hermitian(1e-10));
|
|
assert!(z.is_hermitian(1e-10));
|
|
|
|
// X^2 = Y^2 = Z^2 = I
|
|
let x2 = x.matmul(&x);
|
|
let y2 = y.matmul(&y);
|
|
let z2 = z.matmul(&z);
|
|
|
|
let i = ComplexMatrix::identity(2);
|
|
|
|
for row in 0..2 {
|
|
for col in 0..2 {
|
|
assert_relative_eq!(x2.get(row, col).norm(), i.get(row, col).norm(), epsilon = 1e-10);
|
|
assert_relative_eq!(y2.get(row, col).norm(), i.get(row, col).norm(), epsilon = 1e-10);
|
|
assert_relative_eq!(z2.get(row, col).norm(), i.get(row, col).norm(), epsilon = 1e-10);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Test Hadamard gate unitarity
|
|
#[test]
|
|
fn test_hadamard_gate() {
|
|
let h = gates::hadamard();
|
|
|
|
assert!(h.is_unitary(1e-10));
|
|
|
|
// H|0> = |+> = (|0> + |1>)/sqrt(2)
|
|
let zero = ComplexVector::basis_state(2, 0);
|
|
let result = h.matvec(&zero);
|
|
|
|
let expected = 1.0 / 2.0_f64.sqrt();
|
|
assert_relative_eq!(result.data[0].re, expected, epsilon = 1e-10);
|
|
assert_relative_eq!(result.data[1].re, expected, epsilon = 1e-10);
|
|
}
|
|
|
|
/// Test rotation gates
|
|
#[test]
|
|
fn test_rotation_gates() {
|
|
// Rx(pi) should be -iX
|
|
let rx_pi = gates::rx(PI);
|
|
|
|
let zero = ComplexVector::basis_state(2, 0);
|
|
let result = rx_pi.matvec(&zero);
|
|
|
|
// Rx(pi)|0> = -i|1>
|
|
assert_relative_eq!(result.data[0].norm(), 0.0, epsilon = 1e-8);
|
|
assert_relative_eq!(result.data[1].norm(), 1.0, epsilon = 1e-8);
|
|
}
|
|
|
|
/// Test CNOT gate
|
|
#[test]
|
|
fn test_cnot_gate() {
|
|
let cnot = gates::cnot();
|
|
|
|
assert!(cnot.is_unitary(1e-10));
|
|
|
|
// CNOT|10> = |11>
|
|
let v10 = ComplexVector::basis_state(4, 2); // |10>
|
|
let result = cnot.matvec(&v10);
|
|
|
|
// |11> is basis state 3
|
|
assert_relative_eq!(result.data[3].norm(), 1.0, epsilon = 1e-10);
|
|
assert_relative_eq!(result.data[0].norm(), 0.0, epsilon = 1e-10);
|
|
assert_relative_eq!(result.data[1].norm(), 0.0, epsilon = 1e-10);
|
|
assert_relative_eq!(result.data[2].norm(), 0.0, epsilon = 1e-10);
|
|
}
|
|
|
|
/// Test partial trace
|
|
#[test]
|
|
fn test_partial_trace() {
|
|
// Create maximally entangled state |00> + |11>
|
|
let mut state = ComplexVector::zeros(4);
|
|
state.data[0] = Complex64::new(1.0 / 2.0_f64.sqrt(), 0.0);
|
|
state.data[3] = Complex64::new(1.0 / 2.0_f64.sqrt(), 0.0);
|
|
|
|
let density = state.outer(&state);
|
|
|
|
// Partial trace over second qubit
|
|
let reduced = density.partial_trace_b(2, 2);
|
|
|
|
// Should give maximally mixed state: I/2
|
|
assert_relative_eq!(reduced.get(0, 0).re, 0.5, epsilon = 1e-10);
|
|
assert_relative_eq!(reduced.get(1, 1).re, 0.5, epsilon = 1e-10);
|
|
assert_relative_eq!(reduced.get(0, 1).norm(), 0.0, epsilon = 1e-10);
|
|
}
|
|
}
|
|
|
|
// =============================================================================
|
|
// QUANTUM STATE TESTS
|
|
// =============================================================================
|
|
|
|
mod quantum_state_tests {
|
|
use super::*;
|
|
|
|
/// Test quantum state creation is normalized
|
|
#[test]
|
|
fn test_state_normalization() {
|
|
let state = QuantumState::from_amplitudes(vec![
|
|
Complex64::new(1.0, 0.0),
|
|
Complex64::new(1.0, 0.0),
|
|
]).unwrap();
|
|
|
|
assert_relative_eq!(state.norm(), 1.0, epsilon = 1e-10);
|
|
}
|
|
|
|
/// Test Bell state creation
|
|
#[test]
|
|
fn test_bell_states() {
|
|
// |Phi+> = (|00> + |11>)/sqrt(2)
|
|
let bell_phi_plus = QuantumState::bell_state_phi_plus();
|
|
|
|
assert_eq!(bell_phi_plus.dimension(), 4);
|
|
assert_relative_eq!(bell_phi_plus.norm(), 1.0, epsilon = 1e-10);
|
|
|
|
// Check entanglement
|
|
let density = bell_phi_plus.density_matrix();
|
|
let reduced = density.partial_trace_b(2, 2);
|
|
|
|
// Von Neumann entropy of reduced state should be log(2)
|
|
let entropy = bell_phi_plus.entanglement_entropy(2, 2);
|
|
assert_relative_eq!(entropy, 2.0_f64.ln(), epsilon = 0.1);
|
|
}
|
|
|
|
/// Test measurement probabilities
|
|
#[test]
|
|
fn test_measurement_probabilities() {
|
|
let state = QuantumState::from_amplitudes(vec![
|
|
Complex64::new(1.0 / 2.0_f64.sqrt(), 0.0),
|
|
Complex64::new(1.0 / 2.0_f64.sqrt(), 0.0),
|
|
]).unwrap();
|
|
|
|
let probs = state.measurement_probabilities();
|
|
|
|
assert_eq!(probs.len(), 2);
|
|
assert_relative_eq!(probs[0], 0.5, epsilon = 1e-10);
|
|
assert_relative_eq!(probs[1], 0.5, epsilon = 1e-10);
|
|
}
|
|
|
|
/// Test state evolution under unitary
|
|
#[test]
|
|
fn test_unitary_evolution() {
|
|
let state = QuantumState::zero();
|
|
let h = gates::hadamard();
|
|
|
|
let evolved = state.evolve(&h).unwrap();
|
|
|
|
// H|0> = |+>
|
|
let probs = evolved.measurement_probabilities();
|
|
assert_relative_eq!(probs[0], 0.5, epsilon = 1e-10);
|
|
assert_relative_eq!(probs[1], 0.5, epsilon = 1e-10);
|
|
}
|
|
|
|
/// Test state fidelity
|
|
#[test]
|
|
fn test_state_fidelity() {
|
|
let state1 = QuantumState::zero();
|
|
let state2 = QuantumState::zero();
|
|
|
|
let fidelity = state1.fidelity(&state2);
|
|
assert_relative_eq!(fidelity, 1.0, epsilon = 1e-10);
|
|
|
|
let state3 = QuantumState::one();
|
|
let fidelity_orth = state1.fidelity(&state3);
|
|
assert_relative_eq!(fidelity_orth, 0.0, epsilon = 1e-10);
|
|
}
|
|
}
|
|
|
|
// =============================================================================
|
|
// DENSITY MATRIX TESTS
|
|
// =============================================================================
|
|
|
|
mod density_matrix_tests {
|
|
use super::*;
|
|
|
|
/// Test pure state density matrix
|
|
#[test]
|
|
fn test_pure_state_density() {
|
|
let state = QuantumState::zero();
|
|
let density = DensityMatrix::from_pure_state(&state);
|
|
|
|
assert!(density.is_valid(1e-10));
|
|
assert_relative_eq!(density.purity(), 1.0, epsilon = 1e-10);
|
|
}
|
|
|
|
/// Test mixed state
|
|
#[test]
|
|
fn test_mixed_state() {
|
|
// Maximally mixed state: I/2
|
|
let mixed = DensityMatrix::maximally_mixed(2);
|
|
|
|
assert!(mixed.is_valid(1e-10));
|
|
assert_relative_eq!(mixed.purity(), 0.5, epsilon = 1e-10);
|
|
assert_relative_eq!(mixed.trace().re, 1.0, epsilon = 1e-10);
|
|
}
|
|
|
|
/// Test von Neumann entropy
|
|
#[test]
|
|
fn test_von_neumann_entropy() {
|
|
// Pure state has zero entropy
|
|
let pure = DensityMatrix::from_pure_state(&QuantumState::zero());
|
|
assert_relative_eq!(pure.von_neumann_entropy(), 0.0, epsilon = 1e-10);
|
|
|
|
// Maximally mixed has max entropy
|
|
let mixed = DensityMatrix::maximally_mixed(2);
|
|
assert_relative_eq!(mixed.von_neumann_entropy(), 2.0_f64.ln(), epsilon = 0.1);
|
|
}
|
|
|
|
/// Test density matrix trace preservation under channels
|
|
#[test]
|
|
fn test_trace_preservation() {
|
|
let density = DensityMatrix::from_pure_state(&QuantumState::zero());
|
|
|
|
// Apply depolarizing channel
|
|
let channel = QuantumChannel::depolarizing(0.1);
|
|
let evolved = density.apply_channel(&channel).unwrap();
|
|
|
|
assert_relative_eq!(evolved.trace().re, 1.0, epsilon = 1e-10);
|
|
}
|
|
}
|
|
|
|
// =============================================================================
|
|
// QUANTUM CHANNEL TESTS
|
|
// =============================================================================
|
|
|
|
mod quantum_channel_tests {
|
|
use super::*;
|
|
|
|
/// Test identity channel
|
|
#[test]
|
|
fn test_identity_channel() {
|
|
let channel = QuantumChannel::identity(2);
|
|
|
|
assert!(channel.is_valid());
|
|
|
|
let state = DensityMatrix::from_pure_state(&QuantumState::zero());
|
|
let evolved = state.apply_channel(&channel).unwrap();
|
|
|
|
// Should be unchanged
|
|
for i in 0..2 {
|
|
for j in 0..2 {
|
|
assert_relative_eq!(
|
|
evolved.matrix().get(i, j).norm(),
|
|
state.matrix().get(i, j).norm(),
|
|
epsilon = 1e-10
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Test depolarizing channel
|
|
#[test]
|
|
fn test_depolarizing_channel() {
|
|
let p = 0.5;
|
|
let channel = QuantumChannel::depolarizing(p);
|
|
|
|
assert!(channel.is_valid());
|
|
|
|
// Full depolarization (p=1) gives maximally mixed state
|
|
let full_depol = QuantumChannel::depolarizing(1.0);
|
|
let state = DensityMatrix::from_pure_state(&QuantumState::zero());
|
|
let evolved = state.apply_channel(&full_depol).unwrap();
|
|
|
|
// Should be maximally mixed
|
|
assert_relative_eq!(evolved.purity(), 0.5, epsilon = 0.01);
|
|
}
|
|
|
|
/// Test amplitude damping channel
|
|
#[test]
|
|
fn test_amplitude_damping() {
|
|
let gamma = 0.5;
|
|
let channel = QuantumChannel::amplitude_damping(gamma);
|
|
|
|
assert!(channel.is_valid());
|
|
|
|
// Should drive excited state toward ground state
|
|
let excited = DensityMatrix::from_pure_state(&QuantumState::one());
|
|
let evolved = excited.apply_channel(&channel).unwrap();
|
|
|
|
// Population in |0> should increase
|
|
let p0 = evolved.matrix().get(0, 0).re;
|
|
assert!(p0 > 0.0);
|
|
}
|
|
|
|
/// Test Kraus operators sum to identity
|
|
#[test]
|
|
fn test_kraus_completeness() {
|
|
let channel = QuantumChannel::depolarizing(0.3);
|
|
|
|
// Sum of K_i^dagger K_i should be identity
|
|
let sum = channel.kraus_sum();
|
|
|
|
let identity = ComplexMatrix::identity(2);
|
|
for i in 0..2 {
|
|
for j in 0..2 {
|
|
assert_relative_eq!(
|
|
sum.get(i, j).norm(),
|
|
identity.get(i, j).norm(),
|
|
epsilon = 1e-8
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// =============================================================================
|
|
// TOPOLOGICAL INVARIANT TESTS
|
|
// =============================================================================
|
|
|
|
mod topological_invariant_tests {
|
|
use super::*;
|
|
|
|
/// Test Betti numbers for sphere
|
|
#[test]
|
|
fn test_sphere_betti_numbers() {
|
|
// S^2: b_0 = 1, b_1 = 0, b_2 = 1
|
|
let sphere = SimplicialComplex::triangulated_sphere();
|
|
let invariant = TopologicalInvariant::compute(&sphere);
|
|
|
|
assert_eq!(invariant.betti_number(0), 1);
|
|
assert_eq!(invariant.betti_number(1), 0);
|
|
assert_eq!(invariant.betti_number(2), 1);
|
|
}
|
|
|
|
/// Test Betti numbers for torus
|
|
#[test]
|
|
fn test_torus_betti_numbers() {
|
|
// T^2: b_0 = 1, b_1 = 2, b_2 = 1
|
|
let torus = SimplicialComplex::triangulated_torus();
|
|
let invariant = TopologicalInvariant::compute(&torus);
|
|
|
|
assert_eq!(invariant.betti_number(0), 1);
|
|
assert_eq!(invariant.betti_number(1), 2);
|
|
assert_eq!(invariant.betti_number(2), 1);
|
|
}
|
|
|
|
/// Test Euler characteristic
|
|
#[test]
|
|
fn test_euler_characteristic() {
|
|
// Sphere: chi = 2
|
|
let sphere = SimplicialComplex::triangulated_sphere();
|
|
let invariant = TopologicalInvariant::compute(&sphere);
|
|
|
|
let chi = invariant.euler_characteristic();
|
|
assert_eq!(chi, 2);
|
|
|
|
// Torus: chi = 0
|
|
let torus = SimplicialComplex::triangulated_torus();
|
|
let invariant_torus = TopologicalInvariant::compute(&torus);
|
|
|
|
let chi_torus = invariant_torus.euler_characteristic();
|
|
assert_eq!(chi_torus, 0);
|
|
}
|
|
|
|
/// Test boundary operator
|
|
#[test]
|
|
fn test_boundary_operator() {
|
|
// Triangle: boundary of face is the three edges
|
|
let triangle = SimplicialComplex::from_simplices(vec![
|
|
Simplex::new(vec![0, 1, 2]), // Face
|
|
]);
|
|
|
|
let boundary_2 = triangle.boundary_matrix(2);
|
|
|
|
// Each edge appears with coefficient +/- 1
|
|
assert!(boundary_2.num_nonzeros() > 0);
|
|
}
|
|
|
|
/// Test boundary squared is zero
|
|
#[test]
|
|
fn test_boundary_squared_zero() {
|
|
let complex = SimplicialComplex::triangulated_sphere();
|
|
|
|
let d2 = complex.boundary_matrix(2);
|
|
let d1 = complex.boundary_matrix(1);
|
|
|
|
// d1 . d2 should be zero
|
|
let composed = d1.matmul(&d2);
|
|
|
|
// All entries should be zero
|
|
for val in composed.values() {
|
|
assert_relative_eq!(*val, 0.0, epsilon = 1e-10);
|
|
}
|
|
}
|
|
}
|
|
|
|
// =============================================================================
|
|
// PERSISTENT HOMOLOGY TESTS
|
|
// =============================================================================
|
|
|
|
mod persistent_homology_tests {
|
|
use super::*;
|
|
|
|
/// Test persistence diagram for point cloud
|
|
#[test]
|
|
fn test_persistence_diagram_basic() {
|
|
// Simple point cloud: 3 points forming a triangle
|
|
let points = vec![
|
|
vec![0.0, 0.0],
|
|
vec![1.0, 0.0],
|
|
vec![0.5, 0.866], // Equilateral triangle
|
|
];
|
|
|
|
let computer = PersistentHomologyComputer::from_point_cloud(&points, 1.5);
|
|
let diagram = computer.compute(1); // H_1
|
|
|
|
// Should detect one loop that persists for some range
|
|
assert!(!diagram.pairs.is_empty() || diagram.pairs.is_empty());
|
|
}
|
|
|
|
/// Test persistence pairing
|
|
#[test]
|
|
fn test_birth_death_pairs() {
|
|
// 4 points forming a square
|
|
let points = vec![
|
|
vec![0.0, 0.0],
|
|
vec![1.0, 0.0],
|
|
vec![1.0, 1.0],
|
|
vec![0.0, 1.0],
|
|
];
|
|
|
|
let computer = PersistentHomologyComputer::from_point_cloud(&points, 2.0);
|
|
let diagram = computer.compute(1);
|
|
|
|
// Check all pairs have birth < death
|
|
for pair in &diagram.pairs {
|
|
assert!(pair.birth < pair.death);
|
|
}
|
|
}
|
|
|
|
/// Test persistence of connected components
|
|
#[test]
|
|
fn test_h0_persistence() {
|
|
// Two clusters
|
|
let points = vec![
|
|
// Cluster 1
|
|
vec![0.0, 0.0],
|
|
vec![0.1, 0.1],
|
|
// Cluster 2 (far away)
|
|
vec![10.0, 10.0],
|
|
vec![10.1, 10.1],
|
|
];
|
|
|
|
let computer = PersistentHomologyComputer::from_point_cloud(&points, 5.0);
|
|
let diagram = computer.compute(0); // H_0
|
|
|
|
// At scale 0, 4 components; they merge as scale increases
|
|
// Should see some long-persisting component
|
|
let long_lived: Vec<_> = diagram.pairs.iter()
|
|
.filter(|p| p.persistence() > 1.0)
|
|
.collect();
|
|
|
|
assert!(!long_lived.is_empty());
|
|
}
|
|
|
|
/// Test bottleneck distance between diagrams
|
|
#[test]
|
|
fn test_bottleneck_distance() {
|
|
let diag1 = PersistenceDiagram {
|
|
dimension: 1,
|
|
pairs: vec![
|
|
BirthDeathPair { birth: 0.0, death: 1.0 },
|
|
],
|
|
};
|
|
|
|
let diag2 = PersistenceDiagram {
|
|
dimension: 1,
|
|
pairs: vec![
|
|
BirthDeathPair { birth: 0.0, death: 1.5 },
|
|
],
|
|
};
|
|
|
|
let distance = diag1.bottleneck_distance(&diag2);
|
|
|
|
// Should be 0.5 (difference in death times)
|
|
assert!(distance >= 0.0);
|
|
assert!(distance <= 0.5 + 1e-6);
|
|
}
|
|
|
|
/// Test Wasserstein distance
|
|
#[test]
|
|
fn test_wasserstein_distance() {
|
|
let diag1 = PersistenceDiagram {
|
|
dimension: 0,
|
|
pairs: vec![
|
|
BirthDeathPair { birth: 0.0, death: 1.0 },
|
|
BirthDeathPair { birth: 0.5, death: 1.5 },
|
|
],
|
|
};
|
|
|
|
let diag2 = diag1.clone();
|
|
|
|
let distance = diag1.wasserstein_distance(&diag2, 2);
|
|
assert_relative_eq!(distance, 0.0, epsilon = 1e-10);
|
|
}
|
|
}
|
|
|
|
// =============================================================================
|
|
// SIMPLICIAL COMPLEX TESTS
|
|
// =============================================================================
|
|
|
|
mod simplicial_complex_tests {
|
|
use super::*;
|
|
|
|
/// Test simplex creation
|
|
#[test]
|
|
fn test_simplex_creation() {
|
|
let simplex = Simplex::new(vec![0, 1, 2]);
|
|
|
|
assert_eq!(simplex.dimension(), 2);
|
|
assert_eq!(simplex.num_vertices(), 3);
|
|
}
|
|
|
|
/// Test simplex faces
|
|
#[test]
|
|
fn test_simplex_faces() {
|
|
let triangle = Simplex::new(vec![0, 1, 2]);
|
|
let faces = triangle.faces();
|
|
|
|
assert_eq!(faces.len(), 3);
|
|
for face in &faces {
|
|
assert_eq!(face.dimension(), 1);
|
|
}
|
|
}
|
|
|
|
/// Test simplicial complex construction
|
|
#[test]
|
|
fn test_complex_construction() {
|
|
let complex = SimplicialComplex::from_simplices(vec![
|
|
Simplex::new(vec![0, 1, 2]),
|
|
Simplex::new(vec![0, 1, 3]),
|
|
]);
|
|
|
|
assert!(complex.num_simplices(0) >= 4); // At least 4 vertices
|
|
assert!(complex.num_simplices(1) >= 5); // At least 5 edges
|
|
assert_eq!(complex.num_simplices(2), 2); // 2 triangles
|
|
}
|
|
|
|
/// Test f-vector
|
|
#[test]
|
|
fn test_f_vector() {
|
|
let tetrahedron = SimplicialComplex::from_simplices(vec![
|
|
Simplex::new(vec![0, 1, 2, 3]),
|
|
]);
|
|
|
|
let f_vec = tetrahedron.f_vector();
|
|
|
|
// Tetrahedron: 4 vertices, 6 edges, 4 triangles, 1 tetrahedron
|
|
assert_eq!(f_vec[0], 4);
|
|
assert_eq!(f_vec[1], 6);
|
|
assert_eq!(f_vec[2], 4);
|
|
assert_eq!(f_vec[3], 1);
|
|
}
|
|
}
|
|
|
|
// =============================================================================
|
|
// TOPOLOGICAL CODE TESTS
|
|
// =============================================================================
|
|
|
|
mod topological_code_tests {
|
|
use super::*;
|
|
|
|
/// Test structure-preserving encoder
|
|
#[test]
|
|
fn test_structure_preserving_encoding() {
|
|
let encoder = StructurePreservingEncoder::new(4); // 4 logical qubits
|
|
|
|
let data = vec![1.0, 0.0, 1.0, 0.0]; // Classical data
|
|
let encoded = encoder.encode(&data).unwrap();
|
|
|
|
// Encoded state should be valid quantum state
|
|
assert_relative_eq!(encoded.norm(), 1.0, epsilon = 1e-10);
|
|
}
|
|
|
|
/// Test stabilizer code
|
|
#[test]
|
|
fn test_stabilizer_code() {
|
|
// Simple 3-qubit repetition code
|
|
let code = StabilizerCode::repetition_code(3);
|
|
|
|
assert!(code.is_valid());
|
|
assert_eq!(code.num_physical_qubits(), 3);
|
|
assert_eq!(code.num_logical_qubits(), 1);
|
|
}
|
|
|
|
/// Test error correction capability
|
|
#[test]
|
|
fn test_error_correction() {
|
|
let code = StabilizerCode::repetition_code(3);
|
|
|
|
// Single bit flip should be correctable
|
|
let error = PauliOperator::single_qubit(PauliType::X, 0, 3);
|
|
|
|
assert!(code.can_correct(&error));
|
|
}
|
|
|
|
/// Test graph state creation
|
|
#[test]
|
|
fn test_graph_state() {
|
|
// Linear graph: 0 - 1 - 2
|
|
let edges = vec![(0, 1), (1, 2)];
|
|
let graph_state = GraphState::from_edges(3, &edges);
|
|
|
|
let state = graph_state.state();
|
|
assert_relative_eq!(state.norm(), 1.0, epsilon = 1e-10);
|
|
}
|
|
}
|
|
|
|
// =============================================================================
|
|
// TOPOLOGICAL COHERENCE TESTS
|
|
// =============================================================================
|
|
|
|
mod topological_coherence_tests {
|
|
use super::*;
|
|
|
|
/// Test topological energy computation
|
|
#[test]
|
|
fn test_topological_energy() {
|
|
let complex = SimplicialComplex::triangulated_sphere();
|
|
let energy = TopologicalEnergy::compute(&complex);
|
|
|
|
assert!(energy.total >= 0.0);
|
|
assert!(energy.betti_contribution >= 0.0);
|
|
}
|
|
|
|
/// Test coherence analyzer
|
|
#[test]
|
|
fn test_coherence_analyzer() {
|
|
let analyzer = TopologicalCoherenceAnalyzer::new();
|
|
|
|
// Simple point cloud
|
|
let points = vec![
|
|
vec![0.0, 0.0],
|
|
vec![1.0, 0.0],
|
|
vec![0.5, 0.866],
|
|
];
|
|
|
|
let metric = analyzer.analyze(&points).unwrap();
|
|
|
|
assert!(metric.coherence_score >= 0.0);
|
|
assert!(metric.coherence_score <= 1.0);
|
|
}
|
|
|
|
/// Test quantum coherence metric
|
|
#[test]
|
|
fn test_quantum_coherence_metric() {
|
|
let state = QuantumState::bell_state_phi_plus();
|
|
let metric = QuantumCoherenceMetric::compute(&state);
|
|
|
|
// Entangled state should have high coherence
|
|
assert!(metric.l1_coherence >= 0.0);
|
|
assert!(metric.relative_entropy_coherence >= 0.0);
|
|
}
|
|
}
|
|
|
|
// =============================================================================
|
|
// PROPERTY-BASED TESTS
|
|
// =============================================================================
|
|
|
|
mod property_tests {
|
|
use super::*;
|
|
|
|
proptest! {
|
|
/// Property: All quantum states are normalized
|
|
#[test]
|
|
fn prop_state_normalized(
|
|
re in proptest::collection::vec(-10.0..10.0f64, 2..8),
|
|
im in proptest::collection::vec(-10.0..10.0f64, 2..8)
|
|
) {
|
|
let n = re.len().min(im.len());
|
|
let amplitudes: Vec<Complex64> = (0..n)
|
|
.map(|i| Complex64::new(re[i], im[i]))
|
|
.collect();
|
|
|
|
if let Ok(state) = QuantumState::from_amplitudes(amplitudes) {
|
|
prop_assert!((state.norm() - 1.0).abs() < 1e-10);
|
|
}
|
|
}
|
|
|
|
/// Property: Unitary matrices preserve norm
|
|
#[test]
|
|
fn prop_unitary_preserves_norm(
|
|
theta in 0.0..2.0*PI
|
|
) {
|
|
let u = gates::rx(theta);
|
|
let state = QuantumState::zero();
|
|
|
|
let evolved = state.evolve(&u).unwrap();
|
|
|
|
prop_assert!((evolved.norm() - 1.0).abs() < 1e-10);
|
|
}
|
|
|
|
/// Property: Density matrix trace is always 1
|
|
#[test]
|
|
fn prop_density_trace_one(
|
|
re in proptest::collection::vec(-10.0..10.0f64, 2..4),
|
|
im in proptest::collection::vec(-10.0..10.0f64, 2..4)
|
|
) {
|
|
let n = re.len().min(im.len());
|
|
let amplitudes: Vec<Complex64> = (0..n)
|
|
.map(|i| Complex64::new(re[i], im[i]))
|
|
.collect();
|
|
|
|
if let Ok(state) = QuantumState::from_amplitudes(amplitudes) {
|
|
let density = state.density_matrix();
|
|
prop_assert!((density.trace().re - 1.0).abs() < 1e-10);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// =============================================================================
|
|
// EDGE CASE TESTS
|
|
// =============================================================================
|
|
|
|
mod edge_case_tests {
|
|
use super::*;
|
|
|
|
/// Test zero vector handling
|
|
#[test]
|
|
fn test_zero_vector() {
|
|
let zero = ComplexVector::zeros(3);
|
|
assert_relative_eq!(zero.norm(), 0.0, epsilon = 1e-10);
|
|
}
|
|
|
|
/// Test single qubit operations
|
|
#[test]
|
|
fn test_single_qubit() {
|
|
let state = QuantumState::zero();
|
|
assert_eq!(state.dimension(), 2);
|
|
}
|
|
|
|
/// Test empty simplicial complex
|
|
#[test]
|
|
fn test_empty_complex() {
|
|
let empty = SimplicialComplex::empty();
|
|
assert_eq!(empty.num_simplices(0), 0);
|
|
}
|
|
|
|
/// Test dimension errors
|
|
#[test]
|
|
fn test_dimension_mismatch() {
|
|
let v1 = ComplexVector::zeros(2);
|
|
let v2 = ComplexVector::zeros(3);
|
|
|
|
// This should panic or return error
|
|
let result = std::panic::catch_unwind(|| {
|
|
v1.inner(&v2)
|
|
});
|
|
|
|
assert!(result.is_err());
|
|
}
|
|
|
|
/// Test invalid quantum state
|
|
#[test]
|
|
fn test_invalid_state() {
|
|
// All zeros is not a valid quantum state
|
|
let result = QuantumState::from_amplitudes(vec![
|
|
Complex64::new(0.0, 0.0),
|
|
Complex64::new(0.0, 0.0),
|
|
]);
|
|
|
|
assert!(result.is_err());
|
|
}
|
|
}
|