quantrs2_sim/quantum_gravity_simulation/
functions.rs1use crate::error::{Result, SimulatorError};
6use scirs2_core::random::prelude::*;
7use std::collections::HashMap;
8
9use super::quantumgravitysimulator_type::QuantumGravitySimulator;
10use super::types::{
11 AdSCFTConfig, AsymptoticSafetyConfig, CDTConfig, ConvergenceInfo, GeometryMeasurements,
12 GravityApproach, GravityBenchmarkResults, GravitySimulationResult, LQGConfig,
13 QuantumGravityConfig, QuantumGravityUtils, SpacetimeVertex, TopologyMeasurements,
14};
15
16pub fn benchmark_quantum_gravity_simulation() -> Result<GravityBenchmarkResults> {
18 let approaches = vec![
19 GravityApproach::LoopQuantumGravity,
20 GravityApproach::CausalDynamicalTriangulation,
21 GravityApproach::AsymptoticSafety,
22 GravityApproach::HolographicGravity,
23 ];
24 let mut results = Vec::new();
25 let mut timings = HashMap::new();
26 for approach in approaches {
27 let config = QuantumGravityConfig {
28 gravity_approach: approach,
29 ..Default::default()
30 };
31 let start_time = std::time::Instant::now();
32 let mut simulator = QuantumGravitySimulator::new(config);
33 let result = simulator.simulate()?;
34 let elapsed = start_time.elapsed().as_secs_f64();
35 results.push(result);
36 timings.insert(format!("{approach:?}"), elapsed);
37 }
38 Ok(GravityBenchmarkResults {
39 approach_results: results,
40 timing_comparisons: timings,
41 memory_usage: std::mem::size_of::<QuantumGravitySimulator>(),
42 accuracy_metrics: HashMap::new(),
43 })
44}
45#[cfg(test)]
46#[allow(clippy::field_reassign_with_default)]
47mod tests {
48 use super::*;
49 #[test]
50 fn test_quantum_gravity_config_creation() {
51 let config = QuantumGravityConfig::default();
52 assert_eq!(config.spatial_dimensions, 3);
53 assert_eq!(config.gravity_approach, GravityApproach::LoopQuantumGravity);
54 assert!(config.quantum_corrections);
55 }
56 #[test]
57 fn test_lqg_config_creation() {
58 let lqg_config = LQGConfig::default();
59 assert_eq!(lqg_config.barbero_immirzi_parameter, 0.2375);
60 assert_eq!(lqg_config.max_spin, 5.0);
61 assert!(lqg_config.spin_foam_dynamics);
62 }
63 #[test]
64 fn test_cdt_config_creation() {
65 let cdt_config = CDTConfig::default();
66 assert_eq!(cdt_config.num_simplices, 10_000);
67 assert!(cdt_config.monte_carlo_moves);
68 }
69 #[test]
70 fn test_asymptotic_safety_config() {
71 let as_config = AsymptoticSafetyConfig::default();
72 assert_eq!(as_config.truncation_order, 4);
73 assert!(as_config.higher_derivatives);
74 }
75 #[test]
76 fn test_ads_cft_config() {
77 let ads_cft_config = AdSCFTConfig::default();
78 assert_eq!(ads_cft_config.ads_dimension, 5);
79 assert_eq!(ads_cft_config.cft_dimension, 4);
80 assert!(ads_cft_config.holographic_entanglement);
81 }
82 #[test]
83 fn test_quantum_gravity_simulator_creation() {
84 let config = QuantumGravityConfig::default();
85 let simulator = QuantumGravitySimulator::new(config);
86 assert!(simulator.spacetime_state.is_none());
87 assert!(simulator.spin_network.is_none());
88 }
89 #[test]
90 fn test_spacetime_initialization() {
91 let config = QuantumGravityConfig::default();
92 let mut simulator = QuantumGravitySimulator::new(config);
93 assert!(simulator.initialize_spacetime().is_ok());
94 assert!(simulator.spacetime_state.is_some());
95 let spacetime = simulator
96 .spacetime_state
97 .as_ref()
98 .expect("spacetime state should be initialized");
99 assert_eq!(spacetime.metric_field.ndim(), 4);
100 }
101 #[test]
102 fn test_lqg_spin_network_initialization() {
103 let mut config = QuantumGravityConfig::default();
104 config.lqg_config = Some(LQGConfig {
105 num_nodes: 10,
106 num_edges: 20,
107 ..LQGConfig::default()
108 });
109 let mut simulator = QuantumGravitySimulator::new(config);
110 assert!(simulator.initialize_lqg_spin_network().is_ok());
111 assert!(simulator.spin_network.is_some());
112 let spin_network = simulator
113 .spin_network
114 .as_ref()
115 .expect("spin network should be initialized");
116 assert_eq!(spin_network.nodes.len(), 10);
117 assert!(spin_network.edges.len() <= 20);
118 }
119 #[test]
120 fn test_cdt_initialization() {
121 let mut config = QuantumGravityConfig::default();
122 config.cdt_config = Some(CDTConfig {
123 num_simplices: 100,
124 ..CDTConfig::default()
125 });
126 let mut simulator = QuantumGravitySimulator::new(config);
127 assert!(simulator.initialize_cdt().is_ok());
128 assert!(simulator.simplicial_complex.is_some());
129 let complex = simulator
130 .simplicial_complex
131 .as_ref()
132 .expect("simplicial complex should be initialized");
133 assert_eq!(complex.simplices.len(), 100);
134 assert!(!complex.vertices.is_empty());
135 assert!(!complex.time_slices.is_empty());
136 }
137 #[test]
138 fn test_asymptotic_safety_initialization() {
139 let mut config = QuantumGravityConfig::default();
140 config.asymptotic_safety_config = Some(AsymptoticSafetyConfig {
141 rg_flow_steps: 10,
142 ..AsymptoticSafetyConfig::default()
143 });
144 let mut simulator = QuantumGravitySimulator::new(config);
145 assert!(simulator.initialize_asymptotic_safety().is_ok());
146 assert!(simulator.rg_trajectory.is_some());
147 let trajectory = simulator
148 .rg_trajectory
149 .as_ref()
150 .expect("RG trajectory should be initialized");
151 assert_eq!(trajectory.energy_scales.len(), 10);
152 assert!(!trajectory.coupling_evolution.is_empty());
153 }
154 #[test]
155 fn test_ads_cft_initialization() {
156 let config = QuantumGravityConfig::default();
157 let mut simulator = QuantumGravitySimulator::new(config);
158 assert!(simulator.initialize_ads_cft().is_ok());
159 assert!(simulator.holographic_duality.is_some());
160 let duality = simulator
161 .holographic_duality
162 .as_ref()
163 .expect("holographic duality should be initialized");
164 assert_eq!(duality.bulk_geometry.ads_radius, 1.0);
165 assert_eq!(duality.boundary_theory.central_charge, 100.0);
166 assert!(!duality.entanglement_structure.rt_surfaces.is_empty());
167 }
168 #[test]
169 fn test_su2_element_generation() {
170 let config = QuantumGravityConfig::default();
171 let simulator = QuantumGravitySimulator::new(config);
172 let su2_element = simulator
173 .generate_su2_element()
174 .expect("SU(2) element generation should succeed");
175 assert_eq!(su2_element.shape(), [2, 2]);
176 let determinant =
177 su2_element[[0, 0]] * su2_element[[1, 1]] - su2_element[[0, 1]] * su2_element[[1, 0]];
178 assert!((determinant.norm() - 1.0).abs() < 1e-10);
179 }
180 #[test]
181 fn test_pauli_coefficient_extraction() {
182 let config = QuantumGravityConfig::default();
183 let simulator = QuantumGravitySimulator::new(config);
184 let su2_element = simulator
185 .generate_su2_element()
186 .expect("SU(2) element generation should succeed");
187 let coeffs = simulator.extract_pauli_coefficients(&su2_element);
188 assert_eq!(coeffs.len(), 4);
189 let trace = su2_element[[0, 0]] + su2_element[[1, 1]];
190 assert!((coeffs[0] - trace / 2.0).norm() < 1e-10);
191 }
192 #[test]
193 fn test_simplex_volume_calculation() {
194 let config = QuantumGravityConfig::default();
195 let simulator = QuantumGravitySimulator::new(config);
196 let vertices = vec![
197 SpacetimeVertex {
198 id: 0,
199 coordinates: vec![0.0, 0.0, 0.0, 0.0],
200 time: 0.0,
201 coordination: 4,
202 },
203 SpacetimeVertex {
204 id: 1,
205 coordinates: vec![1.0, 1.0, 0.0, 0.0],
206 time: 1.0,
207 coordination: 4,
208 },
209 ];
210 let simplex_vertices = vec![0, 1];
211 let volume = simulator
212 .calculate_simplex_volume(&vertices, &simplex_vertices)
213 .expect("simplex volume calculation should succeed");
214 assert!(volume > 0.0);
215 }
216 #[test]
217 fn test_causal_connection() {
218 let config = QuantumGravityConfig::default();
219 let simulator = QuantumGravitySimulator::new(config);
220 let v1 = SpacetimeVertex {
221 id: 0,
222 coordinates: vec![0.0, 0.0, 0.0, 0.0],
223 time: 0.0,
224 coordination: 4,
225 };
226 let v2 = SpacetimeVertex {
227 id: 1,
228 coordinates: vec![1.0, 1.0, 0.0, 0.0],
229 time: 1.0,
230 coordination: 4,
231 };
232 let is_connected = simulator
233 .is_causally_connected(&v1, &v2)
234 .expect("causal connection check should succeed");
235 assert!(is_connected);
236 }
237 #[test]
238 fn test_beta_function_calculation() {
239 let config = QuantumGravityConfig::default();
240 let simulator = QuantumGravitySimulator::new(config);
241 let beta_g = simulator
242 .calculate_beta_function("newton_constant", 0.1, &1.0)
243 .expect("beta function calculation should succeed");
244 let beta_lambda = simulator
245 .calculate_beta_function("cosmological_constant", 0.01, &1.0)
246 .expect("beta function calculation should succeed");
247 assert!(beta_g.is_finite());
248 assert!(beta_lambda.is_finite());
249 }
250 #[test]
251 fn test_rt_surface_generation() {
252 let config = QuantumGravityConfig::default();
253 let simulator = QuantumGravitySimulator::new(config);
254 let ads_cft_config = AdSCFTConfig::default();
255 let surfaces = simulator
256 .generate_rt_surfaces(&ads_cft_config)
257 .expect("RT surface generation should succeed");
258 assert!(!surfaces.is_empty());
259 for surface in &surfaces {
260 assert!(surface.area > 0.0);
261 assert_eq!(surface.coordinates.ncols(), ads_cft_config.ads_dimension);
262 }
263 }
264 #[test]
265 fn test_lqg_simulation() {
266 let mut config = QuantumGravityConfig::default();
267 config.gravity_approach = GravityApproach::LoopQuantumGravity;
268 config.lqg_config = Some(LQGConfig {
269 num_nodes: 5,
270 num_edges: 10,
271 ..LQGConfig::default()
272 });
273 let mut simulator = QuantumGravitySimulator::new(config);
274 let result = simulator.simulate();
275 assert!(result.is_ok());
276 let simulation_result = result.expect("LQG simulation should succeed");
277 assert_eq!(
278 simulation_result.approach,
279 GravityApproach::LoopQuantumGravity
280 );
281 assert!(simulation_result.spacetime_volume > 0.0);
282 assert!(!simulation_result.observables.is_empty());
283 }
284 #[test]
285 fn test_cdt_simulation() {
286 let mut config = QuantumGravityConfig::default();
287 config.gravity_approach = GravityApproach::CausalDynamicalTriangulation;
288 config.cdt_config = Some(CDTConfig {
289 num_simplices: 50,
290 mc_sweeps: 10,
291 ..CDTConfig::default()
292 });
293 let mut simulator = QuantumGravitySimulator::new(config);
294 let result = simulator.simulate();
295 assert!(result.is_ok());
296 let simulation_result = result.expect("CDT simulation should succeed");
297 assert_eq!(
298 simulation_result.approach,
299 GravityApproach::CausalDynamicalTriangulation
300 );
301 assert!(simulation_result.spacetime_volume > 0.0);
302 }
303 #[test]
304 fn test_asymptotic_safety_simulation() {
305 let mut config = QuantumGravityConfig::default();
306 config.gravity_approach = GravityApproach::AsymptoticSafety;
307 config.asymptotic_safety_config = Some(AsymptoticSafetyConfig {
308 rg_flow_steps: 5,
309 ..AsymptoticSafetyConfig::default()
310 });
311 let mut simulator = QuantumGravitySimulator::new(config);
312 let result = simulator.simulate();
313 assert!(result.is_ok());
314 let simulation_result = result.expect("Asymptotic Safety simulation should succeed");
315 assert_eq!(
316 simulation_result.approach,
317 GravityApproach::AsymptoticSafety
318 );
319 assert!(simulation_result.ground_state_energy.is_finite());
320 }
321 #[test]
322 fn test_ads_cft_simulation() {
323 let mut config = QuantumGravityConfig::default();
324 config.gravity_approach = GravityApproach::HolographicGravity;
325 let mut simulator = QuantumGravitySimulator::new(config);
326 let result = simulator.simulate();
327 assert!(result.is_ok());
328 let simulation_result = result.expect("Holographic Gravity simulation should succeed");
329 assert_eq!(
330 simulation_result.approach,
331 GravityApproach::HolographicGravity
332 );
333 assert!(simulation_result.spacetime_volume > 0.0);
334 assert!(simulation_result
335 .observables
336 .contains_key("holographic_complexity"));
337 }
338 #[test]
339 fn test_planck_units() {
340 let units = QuantumGravityUtils::planck_units();
341 assert!(units.contains_key("length"));
342 assert!(units.contains_key("time"));
343 assert!(units.contains_key("mass"));
344 assert!(units.contains_key("energy"));
345 assert_eq!(units["length"], 1.616e-35);
346 assert_eq!(units["time"], 5.391e-44);
347 }
348 #[test]
349 fn test_approach_comparison() {
350 let results = vec![GravitySimulationResult {
351 approach: GravityApproach::LoopQuantumGravity,
352 ground_state_energy: 1e-10,
353 spacetime_volume: 1e-105,
354 geometry_measurements: GeometryMeasurements {
355 area_spectrum: vec![1e-70],
356 volume_spectrum: vec![1e-105],
357 length_spectrum: vec![1e-35],
358 discrete_curvature: 1e70,
359 topology_measurements: TopologyMeasurements {
360 euler_characteristic: 1,
361 betti_numbers: vec![1],
362 homology_groups: vec!["Z".to_string()],
363 fundamental_group: "trivial".to_string(),
364 },
365 },
366 convergence_info: ConvergenceInfo {
367 iterations: 100,
368 final_residual: 1e-8,
369 converged: true,
370 convergence_history: vec![1e-2, 1e-8],
371 },
372 observables: HashMap::new(),
373 computation_time: 1.0,
374 }];
375 let comparison = QuantumGravityUtils::compare_approaches(&results);
376 assert!(comparison.contains("LoopQuantumGravity"));
377 assert!(comparison.contains("Energy"));
378 assert!(comparison.contains("Volume"));
379 }
380 #[test]
381 fn test_physical_constraints_validation() {
382 let result = GravitySimulationResult {
383 approach: GravityApproach::LoopQuantumGravity,
384 ground_state_energy: -1.0,
385 spacetime_volume: 0.0,
386 geometry_measurements: GeometryMeasurements {
387 area_spectrum: vec![1e-70],
388 volume_spectrum: vec![1e-105],
389 length_spectrum: vec![1e-35],
390 discrete_curvature: 1e15,
391 topology_measurements: TopologyMeasurements {
392 euler_characteristic: 1,
393 betti_numbers: vec![1],
394 homology_groups: vec!["Z".to_string()],
395 fundamental_group: "trivial".to_string(),
396 },
397 },
398 convergence_info: ConvergenceInfo {
399 iterations: 100,
400 final_residual: 1e-8,
401 converged: true,
402 convergence_history: vec![1e-2, 1e-8],
403 },
404 observables: HashMap::new(),
405 computation_time: 1.0,
406 };
407 let violations = QuantumGravityUtils::validate_physical_constraints(&result);
408 assert_eq!(violations.len(), 3);
409 assert!(violations
410 .iter()
411 .any(|v| v.contains("Negative ground state energy")));
412 assert!(violations.iter().any(|v| v.contains("volume")));
413 assert!(violations.iter().any(|v| v.contains("curvature")));
414 }
415 #[test]
416 #[ignore]
417 pub(super) fn test_benchmark_quantum_gravity() {
418 let result = benchmark_quantum_gravity_simulation();
419 assert!(result.is_ok());
420 let benchmark = result.expect("benchmark should complete successfully");
421 assert!(!benchmark.approach_results.is_empty());
422 assert!(!benchmark.timing_comparisons.is_empty());
423 assert!(benchmark.memory_usage > 0);
424 }
425}