quantrs2_sim/quantum_algorithms/
functions.rs1use crate::error::{Result, SimulatorError};
6use crate::statevector::StateVectorSimulator;
7use scirs2_core::ndarray::{Array1, Array2};
8use scirs2_core::Complex64;
9use std::collections::HashMap;
10
11use super::types::{
12 AlgorithmResourceStats, EnhancedPhaseEstimation, OptimizationLevel, OptimizedGroverAlgorithm,
13 OptimizedShorAlgorithm, QuantumAlgorithmConfig,
14};
15
16pub fn benchmark_quantum_algorithms() -> Result<HashMap<String, f64>> {
18 let mut results = HashMap::new();
19 let shor_start = std::time::Instant::now();
20 let config = QuantumAlgorithmConfig::default();
21 let mut shor = OptimizedShorAlgorithm::new(config)?;
22 let _shor_result = shor.factor(15)?;
23 results.insert(
24 "shor_15".to_string(),
25 shor_start.elapsed().as_secs_f64() * 1000.0,
26 );
27 let grover_start = std::time::Instant::now();
28 let config = QuantumAlgorithmConfig::default();
29 let mut grover = OptimizedGroverAlgorithm::new(config)?;
30 let oracle = |x: usize| x == 5 || x == 10;
31 let _grover_result = grover.search(4, oracle, 2)?;
32 results.insert(
33 "grover_4qubits".to_string(),
34 grover_start.elapsed().as_secs_f64() * 1000.0,
35 );
36 let qpe_start = std::time::Instant::now();
37 let config = QuantumAlgorithmConfig::default();
38 let mut qpe = EnhancedPhaseEstimation::new(config)?;
39 let eigenstate = Array1::from_vec(vec![Complex64::new(1.0, 0.0), Complex64::new(0.0, 0.0)]);
40 let unitary = |sim: &mut StateVectorSimulator, target_qubit: usize| -> Result<()> {
41 sim.apply_z_public(target_qubit)?;
42 Ok(())
43 };
44 let _qpe_result = qpe.estimate_eigenvalues(unitary, &eigenstate, 1e-3)?;
45 results.insert(
46 "phase_estimation".to_string(),
47 qpe_start.elapsed().as_secs_f64() * 1000.0,
48 );
49 Ok(results)
50}
51#[cfg(test)]
52mod tests {
53 use super::*;
54 #[test]
55 fn test_shor_algorithm_creation() {
56 let config = QuantumAlgorithmConfig::default();
57 let shor = OptimizedShorAlgorithm::new(config);
58 assert!(shor.is_ok());
59 }
60 #[test]
61 fn test_shor_trivial_cases() {
62 let config = QuantumAlgorithmConfig::default();
63 let mut shor =
64 OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
65 let result = shor.factor(14).expect("Factoring 14 should succeed");
66 assert!(result.factors.contains(&2));
67 assert!(result.factors.contains(&7));
68 }
69 #[test]
70 fn test_grover_algorithm_creation() {
71 let config = QuantumAlgorithmConfig::default();
72 let grover = OptimizedGroverAlgorithm::new(config);
73 assert!(grover.is_ok());
74 }
75 #[test]
76 fn test_grover_optimal_iterations() {
77 let config = QuantumAlgorithmConfig::default();
78 let grover = OptimizedGroverAlgorithm::new(config)
79 .expect("Grover algorithm creation should succeed");
80 let num_items = 16;
81 let num_targets = 1;
82 let iterations = grover.calculate_optimal_iterations(num_items, num_targets);
83 assert!((3..=4).contains(&iterations));
84 }
85 #[test]
86 fn test_phase_estimation_creation() {
87 let config = QuantumAlgorithmConfig::default();
88 let qpe = EnhancedPhaseEstimation::new(config);
89 assert!(qpe.is_ok());
90 }
91 #[test]
92 fn test_continued_fractions() {
93 let config = QuantumAlgorithmConfig::default();
94 let _shor =
95 OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
96 let convergents = OptimizedShorAlgorithm::continued_fractions(0.375, 100);
97 assert!(!convergents.is_empty());
98 assert!(convergents.iter().any(|&(num, den)| num == 3 && den == 8));
99 }
100 #[test]
101 fn test_modular_exponentiation() {
102 let config = QuantumAlgorithmConfig::default();
103 let _shor =
104 OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
105 assert_eq!(OptimizedShorAlgorithm::mod_exp(2, 3, 5), 3);
106 assert_eq!(OptimizedShorAlgorithm::mod_exp(3, 4, 7), 4);
107 }
108 #[test]
109 fn test_phase_estimation_simple() {
110 let config = QuantumAlgorithmConfig::default();
111 let mut qpe =
112 EnhancedPhaseEstimation::new(config).expect("Phase estimation creation should succeed");
113 let eigenstate = Array1::from_vec(vec![Complex64::new(1.0, 0.0), Complex64::new(0.0, 0.0)]);
114 let z_unitary =
115 |sim: &mut StateVectorSimulator, _target_qubit: usize| -> Result<()> { Ok(()) };
116 let result = qpe.estimate_eigenvalues(z_unitary, &eigenstate, 1e-2);
117 assert!(result.is_ok());
118 let qpe_result = result.expect("Phase estimation should succeed");
119 assert!(!qpe_result.eigenvalues.is_empty());
120 assert_eq!(qpe_result.eigenvalues.len(), qpe_result.precisions.len());
121 }
122 #[test]
123 fn test_grover_search_functionality() {
124 let config = QuantumAlgorithmConfig::default();
125 let mut grover = OptimizedGroverAlgorithm::new(config)
126 .expect("Grover algorithm creation should succeed");
127 let oracle = |x: usize| x == 3;
128 let result = grover.search(3, oracle, 1);
129 if let Err(e) = &result {
130 eprintln!("Grover search failed: {e:?}");
131 }
132 assert!(result.is_ok());
133 let grover_result = result.expect("Grover search should succeed");
134 assert_eq!(grover_result.iterations, grover_result.optimal_iterations);
135 assert!(grover_result.success_probability >= 0.0);
136 assert!(grover_result.success_probability <= 1.0);
137 }
138 #[test]
139 fn test_shor_algorithm_classical_cases() {
140 let config = QuantumAlgorithmConfig::default();
141 let mut shor =
142 OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
143 let result = shor.factor(10).expect("Factoring 10 should succeed");
144 assert!(!result.factors.is_empty());
145 assert!(result.factors.contains(&2) || result.factors.contains(&5));
146 let result = shor.factor(7).expect("Factoring 7 should succeed");
147 if !result.factors.is_empty() {
148 let product: u64 = result.factors.iter().product();
149 assert_eq!(product, 7);
150 }
151 }
152 #[test]
153 fn test_quantum_algorithm_benchmarks() {
154 let benchmarks = benchmark_quantum_algorithms();
155 assert!(benchmarks.is_ok());
156 let results = benchmarks.expect("Benchmarks should succeed");
157 assert!(results.contains_key("shor_15"));
158 assert!(results.contains_key("grover_4qubits"));
159 assert!(results.contains_key("phase_estimation"));
160 for (algorithm, time) in results {
161 assert!(
162 time >= 0.0,
163 "Algorithm {algorithm} had negative execution time"
164 );
165 }
166 }
167 #[test]
168 fn test_grover_optimal_iterations_calculation() {
169 let config = QuantumAlgorithmConfig::default();
170 let grover = OptimizedGroverAlgorithm::new(config)
171 .expect("Grover algorithm creation should succeed");
172 assert_eq!(grover.calculate_optimal_iterations(4, 1), 1);
173 assert_eq!(grover.calculate_optimal_iterations(16, 1), 3);
174 let iterations_64_1 = grover.calculate_optimal_iterations(64, 1);
175 assert!((6..=8).contains(&iterations_64_1));
176 }
177 #[test]
178 fn test_phase_estimation_precision_control() {
179 let config = QuantumAlgorithmConfig {
180 precision_tolerance: 1e-3,
181 ..Default::default()
182 };
183 let mut qpe =
184 EnhancedPhaseEstimation::new(config).expect("Phase estimation creation should succeed");
185 let eigenstate = Array1::from_vec(vec![Complex64::new(1.0, 0.0)]);
186 let identity_op =
187 |_sim: &mut StateVectorSimulator, _target: usize| -> Result<()> { Ok(()) };
188 let result = qpe.estimate_eigenvalues(identity_op, &eigenstate, 1e-3);
189 assert!(result.is_ok());
190 let qpe_result = result.expect("Phase estimation should succeed");
191 assert!(qpe_result.precisions[0] <= 1e-3);
192 assert!(qpe_result.phase_qubits >= 3);
193 }
194 #[test]
195 fn test_grover_multiple_targets() {
196 let config = QuantumAlgorithmConfig::default();
197 let mut grover = OptimizedGroverAlgorithm::new(config)
198 .expect("Grover algorithm creation should succeed");
199 let oracle = |x: usize| x == 2 || x == 5;
200 let result = grover.search(3, oracle, 2);
201 assert!(result.is_ok());
202 let grover_result = result.expect("Grover search should succeed");
203 assert!(grover_result.success_probability >= 0.0);
204 assert!(grover_result.success_probability <= 1.0);
205 assert!(grover_result.iterations > 0);
206 }
207 #[test]
208 fn test_grover_four_qubits() {
209 let config = QuantumAlgorithmConfig::default();
210 let mut grover = OptimizedGroverAlgorithm::new(config)
211 .expect("Grover algorithm creation should succeed");
212 let oracle = |x: usize| x == 7;
213 let result = grover.search(4, oracle, 1);
214 assert!(result.is_ok());
215 let grover_result = result.expect("Grover search should succeed");
216 assert!(grover_result.resource_stats.qubits_used >= 4);
217 assert!(grover_result.iterations >= 2 && grover_result.iterations <= 5);
218 }
219 #[test]
220 fn test_shor_perfect_square() {
221 let config = QuantumAlgorithmConfig::default();
222 let mut shor =
223 OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
224 let result = shor.factor(16).expect("Factoring 16 should succeed");
225 assert!(result.factors.contains(&4) || result.factors.contains(&2));
226 }
227 #[test]
228 fn test_shor_semiprime() {
229 let config = QuantumAlgorithmConfig::default();
230 let mut shor =
231 OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
232 let result = shor.factor(15).expect("Factoring 15 should succeed");
233 assert!(result.execution_time_ms >= 0.0);
234 if !result.factors.is_empty() {
235 for &factor in &result.factors {
236 assert!(15 % factor == 0 || factor == 15);
237 }
238 }
239 }
240 #[test]
241 fn test_optimization_levels() {
242 let levels = vec![
243 OptimizationLevel::Basic,
244 OptimizationLevel::Memory,
245 OptimizationLevel::Speed,
246 OptimizationLevel::Hardware,
247 OptimizationLevel::Maximum,
248 ];
249 for level in levels {
250 let config = QuantumAlgorithmConfig {
251 optimization_level: level,
252 ..Default::default()
253 };
254 let grover = OptimizedGroverAlgorithm::new(config.clone());
255 assert!(grover.is_ok());
256 let shor = OptimizedShorAlgorithm::new(config.clone());
257 assert!(shor.is_ok());
258 let qpe = EnhancedPhaseEstimation::new(config);
259 assert!(qpe.is_ok());
260 }
261 }
262 #[test]
263 fn test_resource_stats() {
264 let config = QuantumAlgorithmConfig::default();
265 let mut shor =
266 OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
267 let result = shor.factor(6).expect("Factoring 6 should succeed");
268 let stats = &result.resource_stats;
269 assert!(!result.factors.is_empty() || stats.qubits_used == 0);
270 }
271 #[test]
272 fn test_grover_resource_stats() {
273 let config = QuantumAlgorithmConfig::default();
274 let mut grover = OptimizedGroverAlgorithm::new(config)
275 .expect("Grover algorithm creation should succeed");
276 let oracle = |x: usize| x == 1;
277 let result = grover
278 .search(2, oracle, 1)
279 .expect("Grover search should succeed");
280 assert!(result.resource_stats.qubits_used > 0);
281 assert!(result.resource_stats.gate_count > 0);
282 }
283 #[test]
284 fn test_phase_estimation_resource_stats() {
285 let config = QuantumAlgorithmConfig::default();
286 let mut qpe =
287 EnhancedPhaseEstimation::new(config).expect("Phase estimation creation should succeed");
288 let eigenstate = Array1::from_vec(vec![Complex64::new(1.0, 0.0)]);
289 let identity_op =
290 |_sim: &mut StateVectorSimulator, _target: usize| -> Result<()> { Ok(()) };
291 let result = qpe
292 .estimate_eigenvalues(identity_op, &eigenstate, 1e-2)
293 .expect("Phase estimation should succeed");
294 assert!(result.resource_stats.qubits_used > 0);
295 }
296 #[test]
297 fn test_config_defaults() {
298 let config = QuantumAlgorithmConfig::default();
299 assert_eq!(config.optimization_level, OptimizationLevel::Maximum);
300 assert!(config.use_classical_preprocessing);
301 assert!(config.enable_error_mitigation);
302 assert_eq!(config.max_circuit_depth, 1000);
303 assert!((config.precision_tolerance - 1e-10).abs() < 1e-15);
304 assert!(config.enable_parallel);
305 }
306 #[test]
307 fn test_shor_result_structure() {
308 let config = QuantumAlgorithmConfig::default();
309 let mut shor =
310 OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
311 let result = shor.factor(6).expect("Factoring 6 should succeed");
312 assert_eq!(result.n, 6);
313 assert!(result.execution_time_ms >= 0.0);
314 assert!(result.classical_preprocessing_ms >= 0.0);
315 assert!(result.quantum_computation_ms >= 0.0);
316 assert!(result.success_probability >= 0.0);
317 assert!(result.success_probability <= 1.0);
318 }
319 #[test]
320 fn test_grover_result_structure() {
321 let config = QuantumAlgorithmConfig::default();
322 let mut grover = OptimizedGroverAlgorithm::new(config)
323 .expect("Grover algorithm creation should succeed");
324 let oracle = |x: usize| x == 0;
325 let result = grover
326 .search(2, oracle, 1)
327 .expect("Grover search should succeed");
328 assert!(result.resource_stats.qubits_used > 0);
329 assert!(result.success_probability >= 0.0);
330 assert!(result.success_probability <= 1.0);
331 assert!(result.execution_time_ms >= 0.0);
332 }
333 #[test]
334 fn test_modular_exponentiation_edge_cases() {
335 let config = QuantumAlgorithmConfig::default();
336 let _shor =
337 OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
338 assert_eq!(OptimizedShorAlgorithm::mod_exp(1, 100, 7), 1);
339 assert_eq!(OptimizedShorAlgorithm::mod_exp(5, 0, 7), 1);
340 assert_eq!(OptimizedShorAlgorithm::mod_exp(2, 10, 1024), 0);
341 }
342 #[test]
343 fn test_continued_fractions_edge_cases() {
344 let config = QuantumAlgorithmConfig::default();
345 let _shor =
346 OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
347 let convergents = OptimizedShorAlgorithm::continued_fractions(0.5, 10);
348 assert!(convergents.iter().any(|&(num, den)| num == 1 && den == 2));
349 let convergents = OptimizedShorAlgorithm::continued_fractions(1.0 / 3.0, 20);
350 assert!(convergents.iter().any(|&(num, den)| num == 1 && den == 3));
351 }
352 #[test]
353 fn test_grover_iterations_scaling() {
354 let config = QuantumAlgorithmConfig::default();
355 let grover = OptimizedGroverAlgorithm::new(config)
356 .expect("Grover algorithm creation should succeed");
357 let iter_8 = grover.calculate_optimal_iterations(8, 1);
358 let iter_32 = grover.calculate_optimal_iterations(32, 1);
359 let ratio = iter_32 as f64 / iter_8 as f64;
360 assert!((1.5..=2.5).contains(&ratio));
361 }
362 #[test]
363 fn test_error_mitigation_disabled() {
364 let config = QuantumAlgorithmConfig {
365 enable_error_mitigation: false,
366 ..Default::default()
367 };
368 let mut grover = OptimizedGroverAlgorithm::new(config)
369 .expect("Grover algorithm creation should succeed");
370 let oracle = |x: usize| x == 1;
371 let result = grover.search(2, oracle, 1);
372 assert!(result.is_ok());
373 }
374 #[test]
375 fn test_parallel_disabled() {
376 let config = QuantumAlgorithmConfig {
377 enable_parallel: false,
378 ..Default::default()
379 };
380 let mut shor =
381 OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
382 let result = shor.factor(6);
383 assert!(result.is_ok());
384 }
385 #[test]
386 fn test_algorithm_resource_stats_default() {
387 let stats = AlgorithmResourceStats::default();
388 assert_eq!(stats.qubits_used, 0);
389 assert_eq!(stats.gate_count, 0);
390 assert_eq!(stats.circuit_depth, 0);
391 assert_eq!(stats.cnot_count, 0);
392 assert_eq!(stats.t_gate_count, 0);
393 assert_eq!(stats.memory_usage_bytes, 0);
394 assert_eq!(stats.measurement_count, 0);
395 }
396 #[test]
397 fn test_shor_small_numbers() {
398 let config = QuantumAlgorithmConfig::default();
399 let mut shor =
400 OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
401 for n in [4, 6, 8, 9, 10, 12] {
402 let result = shor.factor(n);
403 assert!(result.is_ok(), "Failed to factor {n}");
404 }
405 }
406 #[test]
407 fn test_grover_single_qubit() {
408 let config = QuantumAlgorithmConfig::default();
409 let mut grover = OptimizedGroverAlgorithm::new(config)
410 .expect("Grover algorithm creation should succeed");
411 let oracle = |x: usize| x == 1;
412 let result = grover.search(1, oracle, 1);
413 assert!(result.is_ok());
414 }
415}