use crate::gate_translation::GateType;
use crate::parallel_ops_stubs::*;
use crate::resource_estimator::{
ErrorCorrectionCode, EstimationMode, HardwarePlatform, QuantumGate, ResourceEstimationConfig,
};
use std::collections::{BTreeMap, HashMap, HashSet, VecDeque};
use super::enhancedresourceestimator_type::EnhancedResourceEstimator;
use super::types::{
BasicResourceAnalysis, CircuitTopology, CloudPlatform, ComplexityMetrics, CostAnalyzer,
EnhancedResourceEstimate, ErrorBudget, EstimationOptions, GateStatistics, MLResourcePredictor,
MemoryRequirements, OptimizationLevel, ReadinessLevel, ReportFormat, ResourceRequirements,
ResourceScores, TopologyType,
};
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_enhanced_estimator_creation() {
let estimator = EnhancedResourceEstimator::new();
assert!(estimator.config.enable_ml_prediction);
assert!(estimator.config.enable_cost_analysis);
}
#[test]
fn test_basic_resource_analysis() {
let estimator = EnhancedResourceEstimator::new();
let circuit = vec![
QuantumGate::new(GateType::H, vec![0], None),
QuantumGate::new(GateType::CNOT, vec![0, 1], None),
QuantumGate::new(GateType::T, vec![0], None),
];
let analysis = estimator
.perform_basic_analysis(&circuit, 2)
.expect("Failed to perform basic analysis in test_basic_resource_analysis");
assert_eq!(analysis.gate_statistics.total_gates, 3);
assert_eq!(analysis.num_qubits, 2);
}
#[test]
fn test_gate_pattern_detection() {
let estimator = EnhancedResourceEstimator::new();
let circuit = vec![
QuantumGate::new(GateType::H, vec![0], None),
QuantumGate::new(GateType::CNOT, vec![0, 1], None),
QuantumGate::new(GateType::CNOT, vec![1, 2], None),
QuantumGate::new(GateType::CNOT, vec![2, 3], None),
];
let patterns = estimator
.detect_gate_patterns(&circuit)
.expect("Failed to detect gate patterns in test_gate_pattern_detection");
assert!(!patterns.is_empty());
}
#[test]
fn test_ml_predictions() {
let predictor = MLResourcePredictor::new();
let basic = BasicResourceAnalysis {
gate_statistics: GateStatistics {
total_gates: 10,
gate_counts: HashMap::new(),
gate_depths: HashMap::new(),
gate_patterns: Vec::new(),
clifford_count: 8,
non_clifford_count: 2,
two_qubit_count: 3,
multi_qubit_count: 0,
},
circuit_topology: CircuitTopology {
num_qubits: 4,
connectivity_matrix: vec![vec![0; 4]; 4],
connectivity_density: 0.3,
max_connections: 2,
critical_qubits: vec![],
topology_type: TopologyType::Regular,
},
resource_requirements: ResourceRequirements {
logical_qubits: 4,
physical_qubits: 100,
code_distance: 5,
execution_time: 1e-3,
memory_requirements: MemoryRequirements {
state_vector_memory: 256,
gate_storage_memory: 640,
workspace_memory: 128,
total_memory: 1024,
memory_bandwidth: 10.0,
},
magic_states: 20,
error_budget: ErrorBudget {
total_budget: 1e-6,
gate_errors: 4e-7,
measurement_errors: 2e-7,
idle_errors: 2e-7,
crosstalk_errors: 1e-7,
readout_errors: 1e-7,
},
},
complexity_metrics: ComplexityMetrics {
t_complexity: 2,
t_depth: 2,
circuit_volume: 40,
communication_complexity: 1.2,
entanglement_complexity: 0.3,
algorithmic_complexity: "Low".to_string(),
},
num_qubits: 4,
circuit_size: 10,
};
let predictions = predictor
.predict_resources(&[], &basic)
.expect("Failed to predict resources in test_ml_predictions");
assert!(predictions.predicted_success_rate > 0.9);
}
#[test]
fn test_cost_analysis() {
let analyzer = CostAnalyzer::new();
let basic = BasicResourceAnalysis {
gate_statistics: GateStatistics {
total_gates: 10,
gate_counts: HashMap::new(),
gate_depths: HashMap::new(),
gate_patterns: Vec::new(),
clifford_count: 8,
non_clifford_count: 2,
two_qubit_count: 3,
multi_qubit_count: 0,
},
circuit_topology: CircuitTopology {
num_qubits: 4,
connectivity_matrix: vec![vec![0; 4]; 4],
connectivity_density: 0.3,
max_connections: 2,
critical_qubits: vec![],
topology_type: TopologyType::Regular,
},
resource_requirements: ResourceRequirements {
logical_qubits: 4,
physical_qubits: 100,
code_distance: 5,
execution_time: 1e-3,
memory_requirements: MemoryRequirements {
state_vector_memory: 256,
gate_storage_memory: 640,
workspace_memory: 128,
total_memory: 1024,
memory_bandwidth: 10.0,
},
magic_states: 20,
error_budget: ErrorBudget {
total_budget: 1e-6,
gate_errors: 4e-7,
measurement_errors: 2e-7,
idle_errors: 2e-7,
crosstalk_errors: 1e-7,
readout_errors: 1e-7,
},
},
complexity_metrics: ComplexityMetrics {
t_complexity: 2,
t_depth: 2,
circuit_volume: 40,
communication_complexity: 1.2,
entanglement_complexity: 0.3,
algorithmic_complexity: "Low".to_string(),
},
num_qubits: 4,
circuit_size: 10,
};
let options = EstimationOptions {
target_platforms: vec![CloudPlatform::IBMQ],
optimization_level: OptimizationLevel::Basic,
include_alternatives: false,
max_alternatives: 3,
};
let costs = analyzer
.analyze_costs(&[], &basic, &options)
.expect("Failed to analyze costs in test_cost_analysis");
assert!(costs.total_estimated_cost > 0.0);
}
#[test]
fn test_resource_scores() {
let estimator = EnhancedResourceEstimator::new();
let basic = BasicResourceAnalysis {
gate_statistics: GateStatistics {
total_gates: 10,
gate_counts: HashMap::new(),
gate_depths: HashMap::new(),
gate_patterns: Vec::new(),
clifford_count: 8,
non_clifford_count: 2,
two_qubit_count: 3,
multi_qubit_count: 0,
},
circuit_topology: CircuitTopology {
num_qubits: 4,
connectivity_matrix: vec![vec![0; 4]; 4],
connectivity_density: 0.3,
max_connections: 2,
critical_qubits: vec![],
topology_type: TopologyType::Regular,
},
resource_requirements: ResourceRequirements {
logical_qubits: 4,
physical_qubits: 100,
code_distance: 5,
execution_time: 1e-3,
memory_requirements: MemoryRequirements {
state_vector_memory: 256,
gate_storage_memory: 640,
workspace_memory: 128,
total_memory: 1024,
memory_bandwidth: 10.0,
},
magic_states: 20,
error_budget: ErrorBudget {
total_budget: 1e-6,
gate_errors: 4e-7,
measurement_errors: 2e-7,
idle_errors: 2e-7,
crosstalk_errors: 1e-7,
readout_errors: 1e-7,
},
},
complexity_metrics: ComplexityMetrics {
t_complexity: 2,
t_depth: 2,
circuit_volume: 40,
communication_complexity: 1.2,
entanglement_complexity: 0.3,
algorithmic_complexity: "Low".to_string(),
},
num_qubits: 4,
circuit_size: 10,
};
let scores = estimator.calculate_resource_scores(&basic, &None);
assert!(scores.overall_score > 0.0);
assert!(scores.overall_score <= 1.0);
}
#[test]
fn test_export_report() {
let estimator = EnhancedResourceEstimator::new();
let estimate = EnhancedResourceEstimate {
basic_resources: BasicResourceAnalysis {
gate_statistics: GateStatistics {
total_gates: 10,
gate_counts: HashMap::new(),
gate_depths: HashMap::new(),
gate_patterns: Vec::new(),
clifford_count: 8,
non_clifford_count: 2,
two_qubit_count: 3,
multi_qubit_count: 0,
},
circuit_topology: CircuitTopology {
num_qubits: 4,
connectivity_matrix: vec![vec![0; 4]; 4],
connectivity_density: 0.3,
max_connections: 2,
critical_qubits: vec![],
topology_type: TopologyType::Regular,
},
resource_requirements: ResourceRequirements {
logical_qubits: 4,
physical_qubits: 100,
code_distance: 5,
execution_time: 1e-3,
memory_requirements: MemoryRequirements {
state_vector_memory: 256,
gate_storage_memory: 640,
workspace_memory: 128,
total_memory: 1024,
memory_bandwidth: 10.0,
},
magic_states: 20,
error_budget: ErrorBudget {
total_budget: 1e-6,
gate_errors: 4e-7,
measurement_errors: 2e-7,
idle_errors: 2e-7,
crosstalk_errors: 1e-7,
readout_errors: 1e-7,
},
},
complexity_metrics: ComplexityMetrics {
t_complexity: 2,
t_depth: 2,
circuit_volume: 40,
communication_complexity: 1.2,
entanglement_complexity: 0.3,
algorithmic_complexity: "Low".to_string(),
},
num_qubits: 4,
circuit_size: 10,
},
ml_predictions: None,
cost_analysis: None,
optimization_strategies: None,
comparative_results: None,
hardware_recommendations: None,
scaling_predictions: None,
visual_representations: HashMap::new(),
tracking_data: None,
resource_scores: ResourceScores {
overall_score: 0.8,
efficiency_score: 0.85,
scalability_score: 0.75,
feasibility_score: 0.8,
optimization_potential: 0.3,
readiness_level: ReadinessLevel::Experimental,
},
recommendations: Vec::new(),
estimation_time: std::time::Duration::from_millis(100),
platform_optimizations: Vec::new(),
};
let json_report = estimator
.export_report(&estimate, ReportFormat::JSON)
.expect("Failed to export JSON report in test_export_report");
assert!(json_report.contains("resource_scores"));
let md_report = estimator
.export_report(&estimate, ReportFormat::Markdown)
.expect("Failed to export Markdown report in test_export_report");
assert!(md_report.contains("# Enhanced Resource Estimation Report"));
}
}