Crate quantrs2_anneal 

Quantum annealing support for the QuantRS2 framework.

This crate provides types and functions for quantum annealing, including Ising model representation, QUBO problem formulation, simulated quantum annealing, and cloud quantum annealing services.

Features

• Ising model representation with biases and couplings
• QUBO problem formulation with constraints
• Simulated quantum annealing using path integral Monte Carlo
• Classical simulated annealing using Metropolis algorithm
• D-Wave API client for connecting to quantum annealing hardware
• AWS Braket client for accessing Amazon’s quantum computing services

Recent Updates (v0.1.2)

• Enhanced performance using `SciRS2 v0.1.2 Stable Release’s parallel algorithms
• Improved minor graph embedding with refined SciRS2 graph algorithms
• Memory-efficient sparse matrix operations via SciRS2
• Stable APIs for D-Wave, AWS Braket, and Fujitsu integrations

Example

use quantrs2_anneal::{
    ising::IsingModel,
    simulator::{ClassicalAnnealingSimulator, AnnealingParams}
};

// Create a simple 3-qubit Ising model
let mut model = IsingModel::new(3);
model.set_bias(0, 1.0).unwrap();
model.set_coupling(0, 1, -1.0).unwrap();

// Configure annealing parameters
let mut params = AnnealingParams::new();
params.num_sweeps = 1000;
params.num_repetitions = 10;

// Create an annealing simulator and solve the model
let simulator = ClassicalAnnealingSimulator::new(params).unwrap();
let result = simulator.solve(&model).unwrap();

println!("Best energy: {}", result.best_energy);
println!("Best solution: {:?}", result.best_spins);

Re-exports

pub use active_learning_decomposition::ActiveLearningConfig;

pub use active_learning_decomposition::ActiveLearningDecomposer;

pub use active_learning_decomposition::BoundaryEdge;

pub use active_learning_decomposition::DecompositionMetadata;

pub use active_learning_decomposition::DecompositionResult;

pub use active_learning_decomposition::DecompositionStrategy as ActiveDecompositionStrategy;

pub use active_learning_decomposition::ProblemAnalysis;

pub use active_learning_decomposition::Subproblem;

pub use active_learning_decomposition::SubproblemMetadata;

pub use adaptive_constraint_handling::AdaptiveConstraintConfig;

pub use adaptive_constraint_handling::AdaptiveConstraintHandler;

pub use adaptive_constraint_handling::Constraint as AdaptiveConstraint;

pub use adaptive_constraint_handling::ConstraintPriority;

pub use adaptive_constraint_handling::ConstraintStatistics;

pub use adaptive_constraint_handling::ConstraintType as AdaptiveConstraintType;

pub use adaptive_constraint_handling::PenaltyStrategy;

pub use adaptive_constraint_handling::RelaxationStrategy;

pub use adaptive_constraint_handling::ViolationRecord;

pub use adaptive_schedules::AdaptiveScheduleError;

pub use adaptive_schedules::AdaptiveScheduleResult;

pub use adaptive_schedules::CouplingStatistics;

pub use adaptive_schedules::LandscapeFeatures;

pub use adaptive_schedules::NeuralAnnealingScheduler as AdaptiveNeuralScheduler;

pub use adaptive_schedules::PerformanceMetrics as AdaptivePerformanceMetrics;

pub use adaptive_schedules::PerformancePoint;

pub use adaptive_schedules::PerformanceStatistics;

pub use adaptive_schedules::ProblemContext;

pub use adaptive_schedules::ProblemFeatures as AdaptiveProblemFeatures;

pub use adaptive_schedules::ProblemType as AdaptiveProblemType;

pub use adaptive_schedules::RLAgentConfig;

pub use adaptive_schedules::RLStats;

pub use adaptive_schedules::ScheduleParameters;

pub use adaptive_schedules::SchedulePredictionNetwork;

pub use adaptive_schedules::ScheduleRLAgent;

pub use adaptive_schedules::ScheduleType;

pub use adaptive_schedules::SchedulerConfig;

pub use adaptive_schedules::TrainingHistory as AdaptiveTrainingHistory;

pub use advanced_quantum_algorithms::create_custom_infinite_qaoa;

pub use advanced_quantum_algorithms::create_custom_zeno_annealer;

pub use advanced_quantum_algorithms::create_infinite_qaoa_optimizer;

pub use advanced_quantum_algorithms::create_quantum_zeno_annealer;

pub use advanced_quantum_algorithms::AdiabaticShortcutsOptimizer;

pub use advanced_quantum_algorithms::AdvancedQuantumError;

pub use advanced_quantum_algorithms::AdvancedQuantumResult;

pub use advanced_quantum_algorithms::ControlOptimizationMethod;

pub use advanced_quantum_algorithms::ConvergenceMetrics;

pub use advanced_quantum_algorithms::CounterdiabaticApproximation;

pub use advanced_quantum_algorithms::CounterdiabaticConfig;

pub use advanced_quantum_algorithms::CounterdiabaticDrivingOptimizer;

pub use advanced_quantum_algorithms::CounterdiabaticMetrics;

pub use advanced_quantum_algorithms::DepthIncrementStrategy;

pub use advanced_quantum_algorithms::InfiniteDepthQAOA;

pub use advanced_quantum_algorithms::InfiniteQAOAConfig;

pub use advanced_quantum_algorithms::InfiniteQAOAStats;

pub use advanced_quantum_algorithms::ParameterInitializationMethod;

pub use advanced_quantum_algorithms::QuantumZenoAnnealer;

pub use advanced_quantum_algorithms::ShortcutMethod;

pub use advanced_quantum_algorithms::ShortcutsConfig;

pub use advanced_quantum_algorithms::ShortcutsPerformanceStats;

pub use advanced_quantum_algorithms::ZenoAdaptiveStrategy;

pub use advanced_quantum_algorithms::ZenoConfig;

pub use advanced_quantum_algorithms::ZenoPerformanceMetrics;

pub use advanced_quantum_algorithms::ZenoSubspaceProjection;

pub use applications::create_benchmark_suite;

pub use applications::energy;

pub use applications::finance;

pub use applications::generate_performance_report;

pub use applications::healthcare;

pub use applications::logistics;

pub use applications::manufacturing;

pub use applications::quantum_computational_chemistry::create_example_molecular_systems;

pub use applications::quantum_computational_chemistry::BasisSet;

pub use applications::quantum_computational_chemistry::CatalysisOptimization;

pub use applications::quantum_computational_chemistry::ElectronicStructureMethod;

pub use applications::quantum_computational_chemistry::MolecularSystem;

pub use applications::quantum_computational_chemistry::QuantumChemistryConfig;

pub use applications::quantum_computational_chemistry::QuantumChemistryOptimizer;

pub use applications::quantum_computational_chemistry::QuantumChemistryResult;

pub use applications::telecommunications;

pub use applications::transportation;

pub use applications::validate_constraints;

pub use applications::ApplicationError;

pub use applications::ApplicationResult;

pub use applications::Benchmarkable;

pub use applications::IndustryConstraint;

pub use applications::IndustryObjective;

pub use applications::IndustrySolution;

pub use applications::OptimizationProblem;

pub use applications::ProblemCategory as ApplicationProblemCategory;

pub use bayesian_hyperopt::create_annealing_parameter_space;

pub use bayesian_hyperopt::create_bayesian_optimizer;

pub use bayesian_hyperopt::create_custom_bayesian_optimizer;

pub use bayesian_hyperopt::AcquisitionFunction;

pub use bayesian_hyperopt::AcquisitionFunctionType;

pub use bayesian_hyperopt::BayesianHyperoptimizer;

pub use bayesian_hyperopt::BayesianOptConfig;

pub use bayesian_hyperopt::BayesianOptError;

pub use bayesian_hyperopt::BayesianOptMetrics;

pub use bayesian_hyperopt::BayesianOptResult;

pub use bayesian_hyperopt::ConstraintHandlingMethod;

pub use bayesian_hyperopt::GaussianProcessSurrogate;

pub use bayesian_hyperopt::KernelFunction;

pub use bayesian_hyperopt::ObjectiveFunction;

pub use bayesian_hyperopt::OptimizationHistory;

pub use bayesian_hyperopt::Parameter;

pub use bayesian_hyperopt::ParameterBounds;

pub use bayesian_hyperopt::ParameterSpace;

pub use bayesian_hyperopt::ParameterType;

pub use bayesian_hyperopt::ParameterValue;

pub use bayesian_hyperopt::ScalarizationMethod;

pub use braket::is_available as is_braket_available;

pub use braket::AdvancedAnnealingParams;

pub use braket::BatchTaskResult;

pub use braket::BraketClient;

pub use braket::BraketDevice;

pub use braket::BraketError;

pub use braket::BraketResult;

pub use braket::CostTracker as BraketCostTracker;

pub use braket::DeviceSelector;

pub use braket::DeviceStatus as BraketDeviceStatus;

pub use braket::DeviceType;

pub use braket::TaskMetrics;

pub use braket::TaskResult;

pub use braket::TaskStatus;

pub use chain_break::ChainBreakResolver;

pub use chain_break::ChainBreakStats;

pub use chain_break::ChainStrengthOptimizer;

pub use chain_break::HardwareSolution;

pub use chain_break::LogicalProblem;

pub use chain_break::ResolutionMethod;

pub use chain_break::ResolvedSolution;

pub use climate_modeling_optimization::create_example_climate_optimizer;

pub use climate_modeling_optimization::AtmosphericDynamicsOptimizer;

pub use climate_modeling_optimization::AtmosphericTarget;

pub use climate_modeling_optimization::CarbonCycleOptimizer;

pub use climate_modeling_optimization::ClimateModelingOptimizer;

pub use climate_modeling_optimization::ClimateOptimizationConfig;

pub use climate_modeling_optimization::ClimateOptimizationResult;

pub use climate_modeling_optimization::ClimateParameterSpace;

pub use climate_modeling_optimization::ClimatePerformanceMetrics;

pub use climate_modeling_optimization::ConvectionScheme;

pub use climate_modeling_optimization::CouplingMethod;

pub use climate_modeling_optimization::EnergyBalanceOptimizer;

pub use climate_modeling_optimization::GlobalClimateModel;

pub use climate_modeling_optimization::LandSurfaceScheme;

pub use climate_modeling_optimization::OceanDynamicsOptimizer;

pub use climate_modeling_optimization::OptimizationMethod;

pub use climate_modeling_optimization::ParameterInfo;

pub use climate_modeling_optimization::RadiationScheme;

pub use climate_modeling_optimization::UncertaintyEstimates;

pub use climate_modeling_optimization::ValidationMetric;

pub use climate_modeling_optimization::ValidationResults;

pub use coherent_ising_machine::create_low_noise_cim_config;

pub use coherent_ising_machine::create_realistic_cim_config;

pub use coherent_ising_machine::create_standard_cim_config;

pub use coherent_ising_machine::CimConfig;

pub use coherent_ising_machine::CimError;

pub use coherent_ising_machine::CimPerformanceMetrics;

pub use coherent_ising_machine::CimResult;

pub use coherent_ising_machine::CimResults;

pub use coherent_ising_machine::CoherentIsingMachine;

pub use coherent_ising_machine::Complex;

pub use coherent_ising_machine::ConvergenceConfig;

pub use coherent_ising_machine::MeasurementConfig;

pub use coherent_ising_machine::NetworkTopology;

pub use coherent_ising_machine::NoiseConfig;

pub use coherent_ising_machine::OpticalCoupling;

pub use coherent_ising_machine::OpticalParametricOscillator;

pub use coherent_ising_machine::OpticalStatistics;

pub use coherent_ising_machine::PumpSchedule;

pub use comprehensive_integration_testing::create_example_integration_testing;

pub use comprehensive_integration_testing::BenchmarkConfig;

pub use comprehensive_integration_testing::ComponentIntegrationResults;

pub use comprehensive_integration_testing::ComprehensiveIntegrationTesting;

pub use comprehensive_integration_testing::EnvironmentRequirements;

pub use comprehensive_integration_testing::ExpectedOutcomes;

pub use comprehensive_integration_testing::FaultInjectionConfig;

pub use comprehensive_integration_testing::IntegrationTestCase;

pub use comprehensive_integration_testing::IntegrationTestConfig;

pub use comprehensive_integration_testing::IntegrationTestResult;

pub use comprehensive_integration_testing::IntegrationValidationResult;

pub use comprehensive_integration_testing::PerformanceTestResult;

pub use comprehensive_integration_testing::StressTestConfig;

pub use comprehensive_integration_testing::StressTestResult;

pub use comprehensive_integration_testing::SystemIntegrationResults;

pub use comprehensive_integration_testing::TestCategory;

pub use comprehensive_integration_testing::TestExecutionSpec;

pub use comprehensive_integration_testing::TestMetadata;

pub use comprehensive_integration_testing::TestPriority;

pub use comprehensive_integration_testing::TestRegistry;

pub use comprehensive_integration_testing::TestStorageConfig;

pub use comprehensive_integration_testing::ValidationStatus as TestValidationStatus;

pub use compression::BlockDetector;

pub use compression::CompressedQubo;

pub use compression::CompressionStats;

pub use compression::CooCompressor;

pub use compression::ReductionMapping;

pub use compression::VariableReducer;

pub use continuous_variable::create_quadratic_problem;

pub use continuous_variable::ContinuousAnnealingConfig;

pub use continuous_variable::ContinuousConstraint;

pub use continuous_variable::ContinuousOptimizationProblem;

pub use continuous_variable::ContinuousOptimizationStats;

pub use continuous_variable::ContinuousSolution;

pub use continuous_variable::ContinuousVariable;

pub use continuous_variable::ContinuousVariableAnnealer;

pub use continuous_variable::ContinuousVariableError;

pub use continuous_variable::ContinuousVariableResult;

pub use csp_compiler::ComparisonOp;

pub use csp_compiler::CompilationParams;

pub use csp_compiler::CspCompilationInfo;

pub use csp_compiler::CspConstraint;

pub use csp_compiler::CspError;

pub use csp_compiler::CspObjective;

pub use csp_compiler::CspProblem;

pub use csp_compiler::CspResult;

pub use csp_compiler::CspSolution;

pub use csp_compiler::CspValue;

pub use csp_compiler::CspVariable;

pub use csp_compiler::Domain;

pub use dsl::patterns;

pub use dsl::BooleanExpression;

pub use dsl::Constraint;

pub use dsl::DslError;

pub use dsl::DslResult;

pub use dsl::Expression;

pub use dsl::ModelSummary;

pub use dsl::Objective;

pub use dsl::ObjectiveDirection;

pub use dsl::OptimizationModel;

pub use dsl::Variable;

pub use dsl::VariableType;

pub use dsl::VariableVector;

pub use dwave::is_available as is_dwave_available;

pub use dwave::AdvancedProblemParams;

pub use dwave::AnnealingSchedule;

pub use dwave::BatchSubmissionResult;

pub use dwave::ChainStrengthMethod;

pub use dwave::DWaveClient;

pub use dwave::DWaveError;

pub use dwave::DWaveResult;

pub use dwave::EmbeddingConfig;

pub use dwave::HybridSolverParams;

pub use dwave::LeapSolverInfo;

pub use dwave::ProblemInfo;

pub use dwave::ProblemMetrics;

pub use dwave::ProblemParams;

pub use dwave::ProblemStatus;

pub use dwave::SolverCategory;

pub use dwave::SolverSelector;

pub use dwave::SolverType;

pub use dynamic_topology_reconfiguration::CouplerStatus;

pub use dynamic_topology_reconfiguration::DynamicTopologyConfig;

pub use dynamic_topology_reconfiguration::DynamicTopologyManager;

pub use dynamic_topology_reconfiguration::EnvironmentalConditions;

pub use dynamic_topology_reconfiguration::HardwarePerformanceMetrics;

pub use dynamic_topology_reconfiguration::HardwareState;

pub use dynamic_topology_reconfiguration::HardwareStateMonitor;

pub use dynamic_topology_reconfiguration::PerformanceImpact;

pub use dynamic_topology_reconfiguration::PredictedEvent;

pub use dynamic_topology_reconfiguration::PredictionOutcome;

pub use dynamic_topology_reconfiguration::QubitStatus;

pub use dynamic_topology_reconfiguration::ReconfigurationDecision;

pub use dynamic_topology_reconfiguration::ReconfigurationStrategy;

pub use dynamic_topology_reconfiguration::ReconfigurationTrigger;

pub use dynamic_topology_reconfiguration::TopologyPredictionEngine;

pub use embedding::Embedding;

pub use embedding::HardwareGraph;

pub use embedding::HardwareTopology;

pub use embedding::MinorMiner;

pub use enterprise_monitoring::create_example_enterprise_monitoring;

pub use enterprise_monitoring::EnterpriseMonitoringConfig;

pub use enterprise_monitoring::EnterpriseMonitoringDashboard;

pub use enterprise_monitoring::EnterpriseMonitoringSystem;

pub use enterprise_monitoring::LogLevel;

pub use enterprise_monitoring::SecurityEvent;

pub use enterprise_monitoring::ServiceLevelObjective;

pub use enterprise_monitoring::ThreatLevel;

pub use flux_bias::CalibrationData;

pub use flux_bias::FluxBiasConfig;

pub use flux_bias::FluxBiasOptimizer;

pub use flux_bias::FluxBiasResult;

pub use flux_bias::MLFluxBiasOptimizer;

pub use hardware_compilation::create_chimera_target;

pub use hardware_compilation::create_ideal_target;

pub use hardware_compilation::CompilationResult;

pub use hardware_compilation::CompilationTarget;

pub use hardware_compilation::CompilerConfig;

pub use hardware_compilation::ConnectivityPattern;

pub use hardware_compilation::CouplingUtilization;

pub use hardware_compilation::EmbeddingAlgorithm;

pub use hardware_compilation::EmbeddingInfo;

pub use hardware_compilation::HardwareCharacteristics;

pub use hardware_compilation::HardwareCompilationError;

pub use hardware_compilation::HardwareCompilationResult;

pub use hardware_compilation::HardwareCompiler;

pub use hardware_compilation::HardwareMapping;

pub use hardware_compilation::HardwareType;

pub use hardware_compilation::OptimizationObjective;

pub use hardware_compilation::ParallelizationStrategy;

pub use hardware_compilation::PerformancePrediction;

pub use hardware_compilation::QubitAllocationStrategy;

pub use hardware_compilation::TopologyType;

pub use heterogeneous_hybrid_engine::create_example_hybrid_engine;

pub use heterogeneous_hybrid_engine::ActiveExecution;

pub use heterogeneous_hybrid_engine::ComputeResource;

pub use heterogeneous_hybrid_engine::ConsensusAlgorithm;

pub use heterogeneous_hybrid_engine::ConsensusResult;

pub use heterogeneous_hybrid_engine::CostTracker as HybridCostTracker;

pub use heterogeneous_hybrid_engine::ExecutionMetadata;

pub use heterogeneous_hybrid_engine::ExecutionPlan;

pub use heterogeneous_hybrid_engine::ExecutionStatus;

pub use heterogeneous_hybrid_engine::ExecutionStrategy;

pub use heterogeneous_hybrid_engine::GeographicConstraints;

pub use heterogeneous_hybrid_engine::HeterogeneousHybridEngine;

pub use heterogeneous_hybrid_engine::HybridEngineConfig;

pub use heterogeneous_hybrid_engine::HybridExecutionResult;

pub use heterogeneous_hybrid_engine::HybridExecutionTask;

pub use heterogeneous_hybrid_engine::HybridFaultToleranceConfig;

pub use heterogeneous_hybrid_engine::HybridMonitoringConfig;

pub use heterogeneous_hybrid_engine::HybridPerformanceMonitor;

pub use heterogeneous_hybrid_engine::HybridSystemMetrics;

pub use heterogeneous_hybrid_engine::IndividualResult;

pub use heterogeneous_hybrid_engine::LoadBalancingDecisions;

pub use heterogeneous_hybrid_engine::OptimizationSettings;

pub use heterogeneous_hybrid_engine::PerformanceEntry;

pub use heterogeneous_hybrid_engine::PerformanceRequirements;

pub use heterogeneous_hybrid_engine::ProblemComplexity;

pub use heterogeneous_hybrid_engine::QualityAssessmentMethod;

pub use heterogeneous_hybrid_engine::QualityAssessor;

pub use heterogeneous_hybrid_engine::QualityMeasurement;

pub use heterogeneous_hybrid_engine::QualityRequirements;

pub use heterogeneous_hybrid_engine::ResourceAllocationStrategy;

pub use heterogeneous_hybrid_engine::ResourceAvailability;

pub use heterogeneous_hybrid_engine::ResourceConnection;

pub use heterogeneous_hybrid_engine::ResourceConstraints;

pub use heterogeneous_hybrid_engine::ResourceCost;

pub use heterogeneous_hybrid_engine::ResourceMetrics;

pub use heterogeneous_hybrid_engine::ResourcePerformance;

pub use heterogeneous_hybrid_engine::ResourceRequirements;

pub use heterogeneous_hybrid_engine::ResourceScheduler;

pub use heterogeneous_hybrid_engine::ResourceType;

pub use heterogeneous_hybrid_engine::ResourceUtilization as HybridResourceUtilization;

pub use heterogeneous_hybrid_engine::ResourceWorkload;

pub use heterogeneous_hybrid_engine::ResultAggregationStrategy;

pub use heterogeneous_hybrid_engine::ResultAggregator;

pub use heterogeneous_hybrid_engine::SchedulingDecision;

pub use heterogeneous_hybrid_engine::TaskPriority;

pub use hobo::AuxiliaryVariable;

pub use hobo::ConstraintViolations;

pub use hobo::HigherOrderTerm;

pub use hobo::HoboAnalyzer;

pub use hobo::HoboProblem;

pub use hobo::HoboStats;

pub use hobo::QuboReduction;

pub use hobo::ReductionMethod;

pub use hobo::ReductionType;

pub use hybrid_solvers::HybridQuantumClassicalSolver;

pub use hybrid_solvers::HybridSolverConfig;

pub use hybrid_solvers::HybridSolverResult;

pub use hybrid_solvers::VariationalHybridSolver;

pub use ising::IsingError;

pub use ising::IsingModel;

pub use ising::IsingResult;

pub use ising::QuboModel;

pub use layout_embedding::LayoutAwareEmbedder;

pub use layout_embedding::LayoutConfig;

pub use layout_embedding::LayoutStats;

pub use layout_embedding::MultiLevelEmbedder;

pub use meta_learning_optimization::create_meta_learning_optimizer;

pub use meta_learning_optimization::AdaptationMechanism;

pub use meta_learning_optimization::AlgorithmPerformanceStats;

pub use meta_learning_optimization::AlgorithmType as MetaAlgorithmType;

pub use meta_learning_optimization::AlternativeStrategy;

pub use meta_learning_optimization::ApplicabilityConditions;

pub use meta_learning_optimization::ArchitectureCandidate;

pub use meta_learning_optimization::ArchitectureSpec as MetaArchitectureSpec;

pub use meta_learning_optimization::ConvergenceMetrics as MetaConvergenceMetrics;

pub use meta_learning_optimization::CrossValidationStrategy;

pub use meta_learning_optimization::DecisionMaker;

pub use meta_learning_optimization::DomainCharacteristics;

pub use meta_learning_optimization::EvaluationMetric;

pub use meta_learning_optimization::ExperienceDatabase;

pub use meta_learning_optimization::FeatureExtractor as MetaFeatureExtractor;

pub use meta_learning_optimization::FeatureVector;

pub use meta_learning_optimization::FrontierStatistics;

pub use meta_learning_optimization::FrontierUpdate;

pub use meta_learning_optimization::GenerationMethod as MetaGenerationMethod;

pub use meta_learning_optimization::Knowledge;

pub use meta_learning_optimization::MetaLearner;

pub use meta_learning_optimization::MetaLearningAlgorithm;

pub use meta_learning_optimization::MetaLearningConfig;

pub use meta_learning_optimization::MetaLearningOptimizer as MetaOptimizer;

pub use meta_learning_optimization::MetaLearningStatistics;

pub use meta_learning_optimization::MetaOptimizationResult;

pub use meta_learning_optimization::ModelType;

pub use meta_learning_optimization::NeuralArchitectureSearch as MetaNAS;

pub use meta_learning_optimization::OptimizationConfiguration as MetaOptimizationConfiguration;

pub use meta_learning_optimization::OptimizationExperience;

pub use meta_learning_optimization::OptimizationResults as MetaOptimizationResults;

pub use meta_learning_optimization::ParetoFrontier as MetaParetoFrontier;

pub use meta_learning_optimization::PerformanceEvaluator;

pub use meta_learning_optimization::PerformanceGuarantee;

pub use meta_learning_optimization::PerformancePredictor as MetaPerformancePredictor;

pub use meta_learning_optimization::PerformanceRecord as MetaPerformanceRecord;

pub use meta_learning_optimization::ProblemDomain as MetaProblemDomain;

pub use meta_learning_optimization::ProblemFeatures as MetaProblemFeatures;

pub use meta_learning_optimization::QualityMetrics as MetaQualityMetrics;

pub use meta_learning_optimization::RecommendedStrategy;

pub use meta_learning_optimization::ResourceAllocation as MetaResourceAllocation;

pub use meta_learning_optimization::ResourceRequirements as MetaResourceRequirements;

pub use meta_learning_optimization::ResourceUsage;

pub use meta_learning_optimization::SearchIteration;

pub use meta_learning_optimization::SimilarityMethod;

pub use meta_learning_optimization::SimilarityMetric;

pub use meta_learning_optimization::SourceDomain;

pub use meta_learning_optimization::StatisticalTest;

pub use meta_learning_optimization::SuccessMetrics;

pub use meta_learning_optimization::TrainingEpisode;

pub use meta_learning_optimization::TransferLearner as MetaTransferLearner;

pub use meta_learning_optimization::TransferRecord;

pub use meta_learning_optimization::TransferStrategy;

pub use meta_learning_optimization::TransferableModel;

pub use meta_learning_optimization::UpdateReason;

pub use meta_learning_optimization::UserPreferences;

pub use multi_chip_embedding::create_example_multi_chip_system;

pub use multi_chip_embedding::ChipMetrics;

pub use multi_chip_embedding::ChipPerformance;

pub use multi_chip_embedding::ChipStatus;

pub use multi_chip_embedding::ChipWorkload;

pub use multi_chip_embedding::CommunicationChannel as ChipCommunicationChannel;

pub use multi_chip_embedding::CommunicationProtocol;

pub use multi_chip_embedding::ConnectionStatus;

pub use multi_chip_embedding::FaultToleranceConfig;

pub use multi_chip_embedding::LoadBalancer;

pub use multi_chip_embedding::LoadBalancingDecision;

pub use multi_chip_embedding::LoadBalancingStrategy;

pub use multi_chip_embedding::Message;

pub use multi_chip_embedding::MessageType as ChipMessageType;

pub use multi_chip_embedding::MonitoringConfig as ChipMonitoringConfig;

pub use multi_chip_embedding::MultiChipConfig;

pub use multi_chip_embedding::MultiChipCoordinator;

pub use multi_chip_embedding::PerformanceMonitor;

pub use multi_chip_embedding::PerformanceSnapshot;

pub use multi_chip_embedding::PerformanceThresholds;

pub use multi_chip_embedding::ProblemPartition;

pub use multi_chip_embedding::QuantumChip;

pub use multi_chip_embedding::RecoveryStrategy;

pub use multi_chip_embedding::ResourceUtilization as ChipResourceUtilization;

pub use multi_chip_embedding::SystemMetrics;

pub use multi_chip_embedding::WorkTransfer;

pub use multi_objective::MultiObjectiveError;

pub use multi_objective::MultiObjectiveFunction;

pub use multi_objective::MultiObjectiveOptimizer;

pub use multi_objective::MultiObjectiveResult;

pub use multi_objective::MultiObjectiveResults;

pub use multi_objective::MultiObjectiveSolution;

pub use multi_objective::MultiObjectiveStats;

pub use multi_objective::QualityMetrics;

pub use neural_annealing_schedules::ActivationFunction;

pub use neural_annealing_schedules::AnnealingSchedule as NeuralAnnealingSchedule;

pub use neural_annealing_schedules::AttentionMechanism;

pub use neural_annealing_schedules::DatabaseStatistics;

pub use neural_annealing_schedules::DenseLayer;

pub use neural_annealing_schedules::FeatureExtractor as NeuralFeatureExtractor;

pub use neural_annealing_schedules::GenerationMethod;

pub use neural_annealing_schedules::LearningRateSchedule;

pub use neural_annealing_schedules::NetworkArchitecture;

pub use neural_annealing_schedules::NeuralAnnealingScheduler;

pub use neural_annealing_schedules::NeuralSchedulerConfig;

pub use neural_annealing_schedules::OptimizerType;

pub use neural_annealing_schedules::PerformanceMetric;

pub use neural_annealing_schedules::PerformanceRecord;

pub use neural_annealing_schedules::PerformanceTarget;

pub use neural_annealing_schedules::ProblemEncoderNetwork;

pub use neural_annealing_schedules::ScheduleConstraints;

pub use neural_annealing_schedules::ScheduleDatabase;

pub use neural_annealing_schedules::ScheduleGenerationNetwork;

pub use neural_annealing_schedules::TrainingConfig;

pub use neural_annealing_schedules::TrainingManager;

pub use neural_annealing_schedules::ValidationStatus as NeuralValidationStatus;

pub use non_stoquastic::create_frustrated_xy_triangle;

pub use non_stoquastic::create_tfxy_model;

pub use non_stoquastic::create_xy_chain;

pub use non_stoquastic::is_hamiltonian_stoquastic;

pub use non_stoquastic::xy_to_ising_approximation;

pub use non_stoquastic::ComplexCoupling;

pub use non_stoquastic::ConvergenceInfo;

pub use non_stoquastic::HamiltonianType;

pub use non_stoquastic::InteractionType;

pub use non_stoquastic::NonStoquasticError;

pub use non_stoquastic::NonStoquasticHamiltonian;

pub use non_stoquastic::NonStoquasticQMCConfig;

pub use non_stoquastic::NonStoquasticResult;

pub use non_stoquastic::NonStoquasticResults;

pub use non_stoquastic::NonStoquasticSimulator;

pub use non_stoquastic::QMCStatistics;

pub use non_stoquastic::QuantumState as NonStoquasticQuantumState;

pub use non_stoquastic::SignMitigationStrategy;

pub use partitioning::BipartitionMethod;

pub use partitioning::KernighanLinPartitioner;

pub use partitioning::Partition;

pub use partitioning::RecursiveBisectionPartitioner;

pub use partitioning::SpectralPartitioner;

pub use penalty_optimization::AdvancedPenaltyOptimizer;

pub use penalty_optimization::Constraint as PenaltyConstraint;

pub use penalty_optimization::ConstraintPenaltyOptimizer;

pub use penalty_optimization::ConstraintType;

pub use penalty_optimization::PenaltyConfig;

pub use penalty_optimization::PenaltyOptimizer;

pub use penalty_optimization::PenaltyStats;

pub use photonic_annealing::create_coherent_state_config;

pub use photonic_annealing::create_low_noise_config;

pub use photonic_annealing::create_measurement_based_config;

pub use photonic_annealing::create_realistic_config;

pub use photonic_annealing::create_squeezed_state_config;

pub use photonic_annealing::create_temporal_multiplexing_config;

pub use photonic_annealing::ConnectivityType;

pub use photonic_annealing::EvolutionHistory;

pub use photonic_annealing::InitialStateType;

pub use photonic_annealing::MeasurementOutcome;

pub use photonic_annealing::MeasurementStrategy;

pub use photonic_annealing::MeasurementType;

pub use photonic_annealing::PhotonicAnnealer;

pub use photonic_annealing::PhotonicAnnealingConfig;

pub use photonic_annealing::PhotonicAnnealingResults;

pub use photonic_annealing::PhotonicArchitecture;

pub use photonic_annealing::PhotonicComponent;

pub use photonic_annealing::PhotonicError;

pub use photonic_annealing::PhotonicMetrics;

pub use photonic_annealing::PhotonicResult;

pub use photonic_annealing::PhotonicState;

pub use photonic_annealing::PumpPowerSchedule;

pub use population_annealing::EnergyStatistics;

pub use population_annealing::MpiConfig;

pub use population_annealing::PopulationAnnealingConfig;

pub use population_annealing::PopulationAnnealingError;

pub use population_annealing::PopulationAnnealingSimulator;

pub use population_annealing::PopulationAnnealingSolution;

pub use population_annealing::PopulationMember;

pub use problem_schedules::AdaptiveScheduleOptimizer;

pub use problem_schedules::ProblemSpecificScheduler;

pub use problem_schedules::ProblemType;

pub use problem_schedules::ScheduleTemplate;

pub use qaoa::create_constrained_qaoa_config;

pub use qaoa::create_qaoa_plus_config;

pub use qaoa::create_standard_qaoa_config;

pub use qaoa::create_warm_start_qaoa_config;

pub use qaoa::MixerType as QaoaMixerType;

pub use qaoa::ParameterInitialization as QaoaParameterInitialization;

pub use qaoa::ProblemEncoding;

pub use qaoa::QaoaCircuit;

pub use qaoa::QaoaCircuitStats;

pub use qaoa::QaoaClassicalOptimizer;

pub use qaoa::QaoaConfig;

pub use qaoa::QaoaError;

pub use qaoa::QaoaLayer;

pub use qaoa::QaoaOptimizer;

pub use qaoa::QaoaPerformanceMetrics;

pub use qaoa::QaoaResult;

pub use qaoa::QaoaResults;

pub use qaoa::QaoaVariant;

pub use qaoa::QuantumGate as QaoaQuantumGate;

pub use qaoa::QuantumState as QaoaQuantumState;

pub use qaoa::QuantumStateStats;

pub use qaoa_anneal_bridge::create_example_max_cut_problem;

pub use qaoa_anneal_bridge::BridgeConfig as QaoaBridgeConfig;

pub use qaoa_anneal_bridge::HybridOptimizationResult as QaoaHybridResult;

pub use qaoa_anneal_bridge::MixingType;

pub use qaoa_anneal_bridge::OptimizationStrategy as QaoaStrategy;

pub use qaoa_anneal_bridge::PerformanceMetrics as QaoaBridgeMetrics;

pub use qaoa_anneal_bridge::ProblemFormulation;

pub use qaoa_anneal_bridge::ProblemMetadata as QaoaProblemMeta;

pub use qaoa_anneal_bridge::QaoaAnnealBridge;

pub use qaoa_anneal_bridge::QaoaClause;

pub use qaoa_anneal_bridge::QaoaParameters as QaoaBridgeParameters;

pub use qaoa_anneal_bridge::QaoaProblem as QaoaBridgeProblem;

pub use qaoa_anneal_bridge::UnifiedProblem;

pub use qaoa_circuit_bridge::create_qaoa_bridge_for_problem;

pub use qaoa_circuit_bridge::qaoa_parameters_to_circuit_parameters;

pub use qaoa_circuit_bridge::validate_circuit_compatibility;

pub use qaoa_circuit_bridge::BridgeError;

pub use qaoa_circuit_bridge::BridgeResult;

pub use qaoa_circuit_bridge::CircuitBridgeRepresentation;

pub use qaoa_circuit_bridge::CircuitCostEstimate;

pub use qaoa_circuit_bridge::CircuitProblemRepresentation;

pub use qaoa_circuit_bridge::EnhancedQaoaOptimizer;

pub use qaoa_circuit_bridge::LinearTerm;

pub use qaoa_circuit_bridge::OptimizationLevel;

pub use qaoa_circuit_bridge::OptimizationMetrics;

pub use qaoa_circuit_bridge::ParameterReference;

pub use qaoa_circuit_bridge::QaoaCircuitBridge;

pub use qaoa_circuit_bridge::QuadraticTerm;

pub use quantum_advantage_demonstration::create_example_advantage_demonstrator;

pub use quantum_advantage_demonstration::AdvantageCertification;

pub use quantum_advantage_demonstration::AdvantageConfig;

pub use quantum_advantage_demonstration::AdvantageDemonstrationResult;

pub use quantum_advantage_demonstration::AdvantageMetric;

pub use quantum_advantage_demonstration::BenchmarkSuite;

pub use quantum_advantage_demonstration::CertificationLevel;

pub use quantum_advantage_demonstration::ClassicalAlgorithm;

pub use quantum_advantage_demonstration::ClassicalBaselineOptimizer;

pub use quantum_advantage_demonstration::ProblemCategory as AdvantageProblemCategory;

pub use quantum_advantage_demonstration::QuantumAdvantageDemonstrator;

pub use quantum_advantage_demonstration::QuantumDevice;

pub use quantum_advantage_demonstration::QuantumPerformanceAnalyzer;

pub use quantum_advantage_demonstration::QuantumPerformanceMetrics;

pub use quantum_advantage_demonstration::ResultsDatabase;

pub use quantum_advantage_demonstration::StatisticalAnalyzer;

pub use quantum_boltzmann_machine::create_binary_rbm;

pub use quantum_boltzmann_machine::create_gaussian_bernoulli_rbm;

pub use quantum_boltzmann_machine::LayerConfig;

pub use quantum_boltzmann_machine::QbmError;

pub use quantum_boltzmann_machine::QbmInferenceResult;

pub use quantum_boltzmann_machine::QbmResult;

pub use quantum_boltzmann_machine::QbmTrainingConfig;

pub use quantum_boltzmann_machine::QbmTrainingStats;

pub use quantum_boltzmann_machine::QuantumRestrictedBoltzmannMachine;

pub use quantum_boltzmann_machine::QuantumSamplingStats;

pub use quantum_boltzmann_machine::TrainingSample;

pub use quantum_boltzmann_machine::UnitType;

pub use quantum_error_correction::ErrorCorrectionCode;

pub use quantum_error_correction::ErrorMitigationConfig;

pub use quantum_error_correction::ErrorMitigationManager;

pub use quantum_error_correction::LogicalAnnealingEncoder;

pub use quantum_error_correction::MitigationResult;

pub use quantum_error_correction::MitigationTechnique;

pub use quantum_error_correction::NoiseResilientAnnealingProtocol;

pub use quantum_error_correction::QECConfig;

pub use quantum_error_correction::QuantumErrorCorrectionError;

pub use quantum_error_correction::SyndromeDetector;

pub use quantum_machine_learning::create_binary_classifier;

pub use quantum_machine_learning::create_quantum_svm;

pub use quantum_machine_learning::create_zz_feature_map;

pub use quantum_machine_learning::evaluate_qml_model;

pub use quantum_machine_learning::ActivationType;

pub use quantum_machine_learning::EntanglementType;

pub use quantum_machine_learning::Experience;

pub use quantum_machine_learning::FeatureMapType;

pub use quantum_machine_learning::KernelMethodType;

pub use quantum_machine_learning::QAutoencoderConfig;

pub use quantum_machine_learning::QGanConfig;

pub use quantum_machine_learning::QGanTrainingHistory;

pub use quantum_machine_learning::QRLConfig;

pub use quantum_machine_learning::QRLStats;

pub use quantum_machine_learning::QmlError;

pub use quantum_machine_learning::QmlMetrics;

pub use quantum_machine_learning::QmlResult;

pub use quantum_machine_learning::QnnConfig;

pub use quantum_machine_learning::QuantumAutoencoder;

pub use quantum_machine_learning::QuantumCircuit;

pub use quantum_machine_learning::QuantumFeatureMap;

pub use quantum_machine_learning::QuantumGAN;

pub use quantum_machine_learning::QuantumGate as QmlQuantumGate;

pub use quantum_machine_learning::QuantumKernelMethod;

pub use quantum_machine_learning::QuantumLayer;

pub use quantum_machine_learning::QuantumNeuralLayer;

pub use quantum_machine_learning::QuantumNeuralNetwork;

pub use quantum_machine_learning::QuantumRLAgent;

pub use quantum_machine_learning::TrainingHistory;

pub use quantum_machine_learning::TrainingSample as QmlTrainingSample;

pub use quantum_machine_learning::VariationalQuantumClassifier;

pub use quantum_machine_learning::VqcConfig;

pub use quantum_walk::AdiabaticHamiltonian;

pub use quantum_walk::CoinOperator;

pub use quantum_walk::QuantumState as QuantumWalkState;

pub use quantum_walk::QuantumWalkAlgorithm;

pub use quantum_walk::QuantumWalkConfig;

pub use quantum_walk::QuantumWalkError;

pub use quantum_walk::QuantumWalkOptimizer;

pub use quantum_walk::QuantumWalkResult;

pub use qubo::QuboBuilder;

pub use qubo::QuboError;

pub use qubo::QuboFormulation;

pub use qubo::QuboResult;

pub use qubo_decomposition::DecomposedSolution;

pub use qubo_decomposition::DecompositionConfig;

pub use qubo_decomposition::DecompositionError;

pub use qubo_decomposition::DecompositionStats;

pub use qubo_decomposition::DecompositionStrategy as QuboDecompositionStrategy;

pub use qubo_decomposition::QuboDecomposer;

pub use qubo_decomposition::SubProblem;

pub use qubo_decomposition::SubSolution;

pub use realtime_adaptive_qec::create_example_adaptive_qec;

pub use realtime_adaptive_qec::AdaptationAction;

pub use realtime_adaptive_qec::AdaptationCondition;

pub use realtime_adaptive_qec::AdaptationDecision;

pub use realtime_adaptive_qec::AdaptationRule;

pub use realtime_adaptive_qec::AdaptiveProtocol;

pub use realtime_adaptive_qec::AdaptiveProtocolManager;

pub use realtime_adaptive_qec::AdaptiveQecConfig;

pub use realtime_adaptive_qec::AdaptiveQecMetrics;

pub use realtime_adaptive_qec::AdaptiveResourceManager;

pub use realtime_adaptive_qec::AdaptiveStrategyConfig;

pub use realtime_adaptive_qec::AnalysisAlgorithm;

pub use realtime_adaptive_qec::AnalysisType;

pub use realtime_adaptive_qec::CommunicationChannel as QecCommunicationChannel;

pub use realtime_adaptive_qec::CommunicationStatistics;

pub use realtime_adaptive_qec::CoordinationAlgorithm;

pub use realtime_adaptive_qec::CoordinationStrategy;

pub use realtime_adaptive_qec::CorrectedProblem;

pub use realtime_adaptive_qec::CorrectionConfig;

pub use realtime_adaptive_qec::CorrectionMetadata;

pub use realtime_adaptive_qec::CorrectionResult;

pub use realtime_adaptive_qec::DetectionAction;

pub use realtime_adaptive_qec::DetectionConfig;

pub use realtime_adaptive_qec::DetectionMethod;

pub use realtime_adaptive_qec::ErrorCorrectionStrategy;

pub use realtime_adaptive_qec::ErrorInfo;

pub use realtime_adaptive_qec::FeatureConfig;

pub use realtime_adaptive_qec::FeatureDefinition;

pub use realtime_adaptive_qec::FeatureExtractor as QecFeatureExtractor;

pub use realtime_adaptive_qec::FeatureNormalization;

pub use realtime_adaptive_qec::FeatureSelection;

pub use realtime_adaptive_qec::FeatureType;

pub use realtime_adaptive_qec::HierarchyConfig;

pub use realtime_adaptive_qec::HierarchyCoordinator;

pub use realtime_adaptive_qec::HierarchyLevel;

pub use realtime_adaptive_qec::HierarchyMessage;

pub use realtime_adaptive_qec::HybridConfig;

pub use realtime_adaptive_qec::MLNoiseConfig;

pub use realtime_adaptive_qec::MessagePayload;

pub use realtime_adaptive_qec::MessageType as QecMessageType;

pub use realtime_adaptive_qec::ModelEnsemble;

pub use realtime_adaptive_qec::NeuralArchitecture;

pub use realtime_adaptive_qec::NoiseAnalyzer;

pub use realtime_adaptive_qec::NoiseAssessment;

pub use realtime_adaptive_qec::NoiseCharacteristics;

pub use realtime_adaptive_qec::NoiseDataPoint;

pub use realtime_adaptive_qec::NoiseMonitor;

pub use realtime_adaptive_qec::NoisePrediction;

pub use realtime_adaptive_qec::NoisePredictionModel;

pub use realtime_adaptive_qec::NoisePredictionSystem;

pub use realtime_adaptive_qec::NoiseSensor;

pub use realtime_adaptive_qec::NoiseSeverity;

pub use realtime_adaptive_qec::NoiseType;

pub use realtime_adaptive_qec::PredictionConfig;

pub use realtime_adaptive_qec::PredictionResult;

pub use realtime_adaptive_qec::RealTimeAdaptiveQec;

pub use realtime_adaptive_qec::ResourceAllocationStrategy as QecResourceAllocationStrategy;

pub use realtime_adaptive_qec::ResourceConstraints as QecResourceConstraints;

pub use realtime_adaptive_qec::ResourceOptimizer;

pub use realtime_adaptive_qec::ResourceReallocation;

pub use realtime_adaptive_qec::SensorType;

pub use realtime_adaptive_qec::StrategyPerformance;

pub use realtime_adaptive_qec::SwitchingCriteria;

pub use realtime_adaptive_qec::TrendDirection as QecTrendDirection;

pub use realtime_hardware_monitoring::create_example_hardware_monitor;

pub use realtime_hardware_monitoring::AdaptationStatus;

pub use realtime_hardware_monitoring::AdaptiveAction;

pub use realtime_hardware_monitoring::AdaptiveActionType;

pub use realtime_hardware_monitoring::AdaptiveCompiler;

pub use realtime_hardware_monitoring::AdaptiveCompilerConfig;

pub use realtime_hardware_monitoring::Alert;

pub use realtime_hardware_monitoring::AlertHandler;

pub use realtime_hardware_monitoring::AlertLevel;

pub use realtime_hardware_monitoring::AlertSystem;

pub use realtime_hardware_monitoring::AlertThresholds;

pub use realtime_hardware_monitoring::CalibrationData as MonitorCalibrationData;

pub use realtime_hardware_monitoring::ChangeType;

pub use realtime_hardware_monitoring::CoherenceCharacteristics;

pub use realtime_hardware_monitoring::DecoherenceSource;

pub use realtime_hardware_monitoring::DeviceConnection;

pub use realtime_hardware_monitoring::DeviceInfo;

pub use realtime_hardware_monitoring::DevicePerformanceMetrics;

pub use realtime_hardware_monitoring::DeviceStatus as MonitorDeviceStatus;

pub use realtime_hardware_monitoring::FailureDetectionConfig;

pub use realtime_hardware_monitoring::FailurePrediction;

pub use realtime_hardware_monitoring::FailureSeverity;

pub use realtime_hardware_monitoring::FailureType;

pub use realtime_hardware_monitoring::MetricType;

pub use realtime_hardware_monitoring::MonitoredDevice;

pub use realtime_hardware_monitoring::MonitoringConfig as HardwareMonitoringConfig;

pub use realtime_hardware_monitoring::MonitoringSnapshot;

pub use realtime_hardware_monitoring::NoiseModel;

pub use realtime_hardware_monitoring::NoiseProfile;

pub use realtime_hardware_monitoring::PredictiveFailureDetector;

pub use realtime_hardware_monitoring::QuantumOperation;

pub use realtime_hardware_monitoring::RealTimeHardwareMonitor;

pub use realtime_hardware_monitoring::RealTimePerformanceOptimizer;

pub use realtime_hardware_monitoring::TrendDirection as MonitorTrendDirection;

pub use reverse_annealing::ReverseAnnealingParams;

pub use reverse_annealing::ReverseAnnealingSchedule;

pub use reverse_annealing::ReverseAnnealingScheduleBuilder;

pub use reverse_annealing::ReverseAnnealingSimulator;

pub use rl_embedding_optimizer::create_custom_rl_embedding_optimizer;

pub use rl_embedding_optimizer::create_rl_embedding_optimizer;

pub use rl_embedding_optimizer::ContinuousEmbeddingAction;

pub use rl_embedding_optimizer::DiscreteEmbeddingAction;

pub use rl_embedding_optimizer::EmbeddingAction;

pub use rl_embedding_optimizer::EmbeddingDQN;

pub use rl_embedding_optimizer::EmbeddingExperience;

pub use rl_embedding_optimizer::EmbeddingPolicyNetwork;

pub use rl_embedding_optimizer::EmbeddingQualityMetrics;

pub use rl_embedding_optimizer::EmbeddingState;

pub use rl_embedding_optimizer::HardwareFeatures;

pub use rl_embedding_optimizer::ObjectiveWeights;

pub use rl_embedding_optimizer::ProblemGraphFeatures;

pub use rl_embedding_optimizer::RLEmbeddingConfig;

pub use rl_embedding_optimizer::RLEmbeddingError;

pub use rl_embedding_optimizer::RLEmbeddingOptimizer;

pub use rl_embedding_optimizer::RLEmbeddingResult;

pub use rl_embedding_optimizer::RLPerformanceMetrics;

pub use rl_embedding_optimizer::RLTrainingStats;

pub use scientific_performance_optimization::create_example_performance_optimizer;

pub use scientific_performance_optimization::AlgorithmOptimizationConfig;

pub use scientific_performance_optimization::ApproximationConfig;

pub use scientific_performance_optimization::BottleneckAnalysis;

pub use scientific_performance_optimization::CachingConfig;

pub use scientific_performance_optimization::ComprehensivePerformanceReport;

pub use scientific_performance_optimization::CompressionConfig;

pub use scientific_performance_optimization::DecompositionConfig as PerfDecompositionConfig;

pub use scientific_performance_optimization::DistributedComputingConfig;

pub use scientific_performance_optimization::GPUAccelerationConfig;

pub use scientific_performance_optimization::HierarchicalMemoryManager;

pub use scientific_performance_optimization::LoadBalancingConfig;

pub use scientific_performance_optimization::MemoryOptimizationConfig;

pub use scientific_performance_optimization::OptimizationCategory;

pub use scientific_performance_optimization::OptimizationImpact;

pub use scientific_performance_optimization::OptimizationRecommendation as PerfOptimizationRecommendation;

pub use scientific_performance_optimization::OptimizedDrugDiscoveryResult;

pub use scientific_performance_optimization::OptimizedMaterialsScienceResult;

pub use scientific_performance_optimization::OptimizedProteinFoldingResult;

pub use scientific_performance_optimization::ParallelProcessingConfig;

pub use scientific_performance_optimization::PerformanceOptimizationConfig;

pub use scientific_performance_optimization::ProfilingConfig;

pub use scientific_performance_optimization::ResourceUtilizationAnalysis;

pub use scientific_performance_optimization::ScientificPerformanceOptimizer;

pub use scientific_performance_optimization::StreamingConfig;

pub use scientific_performance_optimization::SystemPerformanceMetrics;

pub use scientific_performance_optimization::ThreadPoolConfig;

pub use scirs2_integration::EmbeddingDifficulty;

pub use scirs2_integration::GraphAnalysisResult;

pub use scirs2_integration::GraphMetrics;

pub use scirs2_integration::PlottingConfig;

pub use scirs2_integration::QualityAssessment;

pub use scirs2_integration::QuboStatistics;

pub use scirs2_integration::SciRS2EnergyPlotter;

pub use scirs2_integration::SciRS2GraphAnalyzer;

pub use scirs2_integration::SciRS2QuboModel;

pub use scirs2_integration::SciRS2SolutionAnalyzer;

pub use scirs2_integration::SolutionAnalysisResult;

pub use scirs2_integration::SolutionStatistics;

pub use simulator::AnnealingError;

pub use simulator::AnnealingParams;

pub use simulator::AnnealingResult;

pub use simulator::AnnealingSolution;

pub use simulator::ClassicalAnnealingSimulator;

pub use simulator::QuantumAnnealingSimulator;

pub use simulator::TemperatureSchedule;

pub use simulator::TransverseFieldSchedule;

pub use solution_clustering::analyze_solution_diversity;

pub use solution_clustering::create_basic_clustering_config;

pub use solution_clustering::create_comprehensive_clustering_config;

pub use solution_clustering::find_representative_solution;

pub use solution_clustering::AnalysisDepth;

pub use solution_clustering::ClusteringAlgorithm;

pub use solution_clustering::ClusteringConfig;

pub use solution_clustering::ClusteringError;

pub use solution_clustering::ClusteringResult;

pub use solution_clustering::ClusteringResults;

pub use solution_clustering::DimensionalityReduction;

pub use solution_clustering::DistanceMetric;

pub use solution_clustering::FeatureExtractionMethod;

pub use solution_clustering::LandscapeAnalysis;

pub use solution_clustering::LinkageType;

pub use solution_clustering::OptimizationRecommendation as ClusteringOptimizationRecommendation;

pub use solution_clustering::SolutionCluster;

pub use solution_clustering::SolutionClusteringAnalyzer;

pub use solution_clustering::SolutionPoint;

pub use solution_clustering::StatisticalSummary;

pub use variational_quantum_annealing::create_adiabatic_vqa_config;

pub use variational_quantum_annealing::create_hardware_efficient_vqa_config;

pub use variational_quantum_annealing::create_qaoa_vqa_config;

pub use variational_quantum_annealing::AnsatzType;

pub use variational_quantum_annealing::ClassicalOptimizer;

pub use variational_quantum_annealing::EntanglingGateType;

pub use variational_quantum_annealing::MixerType as VqaMixerType;

pub use variational_quantum_annealing::OptimizerStatistics;

pub use variational_quantum_annealing::ParameterRef;

pub use variational_quantum_annealing::ParameterStatistics;

pub use variational_quantum_annealing::QuantumCircuit as VqaQuantumCircuit;

pub use variational_quantum_annealing::QuantumGate as VqaQuantumGate;

pub use variational_quantum_annealing::VariationalQuantumAnnealer;

pub use variational_quantum_annealing::VqaConfig;

pub use variational_quantum_annealing::VqaError;

pub use variational_quantum_annealing::VqaResult;

pub use variational_quantum_annealing::VqaResults;

pub use variational_quantum_annealing::VqaStatistics;

pub use visualization::calculate_landscape_stats;

pub use visualization::plot_energy_histogram;

pub use visualization::plot_energy_landscape;

pub use visualization::BasinAnalyzer;

pub use visualization::LandscapeAnalyzer;

pub use visualization::LandscapePoint;

pub use visualization::LandscapeStats;

pub use visualization::VisualizationError;

pub use visualization::VisualizationResult;

Modules

active_learning_decomposition

Active Learning for Problem Decomposition

adaptive_constraint_handling

Adaptive Constraint Handling for Quantum Annealing

adaptive_schedules

Neural Network Guided Annealing Schedules

advanced_meta_optimizer

Advanced Meta-Learning Optimization System

advanced_quantum_algorithms

Advanced Quantum Algorithms for Annealing Optimization

advanced_testing_framework

Advanced Testing Infrastructure for Quantum Annealing Systems

applications

Industry-Specific Optimization Libraries

bayesian_hyperopt

Bayesian Optimization for Hyperparameter Tuning

braket

AWS Braket quantum annealing client

chain_break

Chain break resolution algorithms for quantum annealing

climate_modeling_optimization

Climate Modeling Parameter Optimization Framework

coherent_ising_machine

Coherent Ising Machine simulation for photonic quantum annealing

comprehensive_integration_testing

Comprehensive Integration Testing Framework for Quantum Annealing Systems

compression

QUBO matrix compression algorithms

continuous_variable

Continuous variable annealing for optimization problems

csp_compiler

Constraint Satisfaction Problem (CSP) compiler

dsl

Domain-Specific Language (DSL) for Optimization Problems

dwave

D-Wave Leap cloud service client

dynamic_topology_reconfiguration

Dynamic Topology Reconfiguration for Quantum Annealing Systems

embedding

Graph embedding algorithms for quantum annealing hardware

enterprise_monitoring

Enterprise Monitoring and Observability System

flux_bias

Flux bias optimization for D-Wave quantum annealing

hardware_compilation

Hardware-Aware Compilation System for Quantum Annealing

heterogeneous_hybrid_engine

Heterogeneous Quantum-Classical Hybrid Execution Engine

hobo

Higher-Order Binary Optimization (HOBO) support

hybrid_solvers

Quantum-Classical Hybrid Solvers

ising

Ising model representation for quantum annealing

layout_embedding

Layout-aware graph embedding algorithms

meta_learning

Meta-Learning Optimization Engine for Quantum Annealing Systems

meta_learning_optimization

Meta-Learning Optimization Engine for Quantum Annealing Systems

multi_chip_embedding

Multi-Chip Embedding and Parallelization for Quantum Annealing

multi_objective

Multi-objective optimization framework for quantum annealing

neural_annealing_schedules

Neural Network Guided Annealing Schedules

non_stoquastic

Non-Stoquastic Hamiltonian Support for Quantum Annealing

partitioning

Graph partitioning algorithms for quantum annealing

penalty_optimization

Penalty function optimization for quantum annealing

photonic_annealing

Photonic Annealing Systems Support

population_annealing

Population annealing with MPI support

problem_schedules

Problem-specific annealing schedules

qaoa

Quantum Approximate Optimization Algorithm (QAOA) implementation

qaoa_anneal_bridge

QAOA-Annealing Bridge Module

qaoa_circuit_bridge

Bridge between QAOA and Circuit modules

quantum_advantage_demonstration

Quantum Advantage Demonstration and Benchmarking Suite

quantum_boltzmann_machine

Quantum Boltzmann Machines for machine learning with quantum annealing

quantum_error_correction

Quantum Error Correction for Annealing Systems

quantum_machine_learning

Quantum Machine Learning with Annealing

quantum_walk

Quantum walk-based optimization algorithms

qubo

QUBO problem formulation for quantum annealing

qubo_decomposition

Large-scale QUBO decomposition for efficient solving

realtime_adaptive_qec

Real-Time Adaptive Quantum Error Correction for Annealing Systems

realtime_hardware_monitoring

Real-Time Hardware Monitoring and Adaptive Compilation

reverse_annealing

Reverse annealing support for quantum annealing

rl_embedding_optimizer

Reinforcement Learning for Embedding Optimization

scientific_performance_optimization

Scientific Performance Optimization for Large-Scale Applications

scirs2_integration

SciRS2 Integration Module

simulator

Simulated quantum annealing simulator

solution_clustering

Advanced Solution Clustering and Analysis for Quantum Annealing

universal_annealing_compiler

Universal Annealing Compiler for Any Quantum Platform

variational_quantum_annealing

Variational Quantum Annealing for advanced optimization

visualization

Energy landscape visualization for quantum annealing problems

Functions

is_available

Check if quantum annealing support is available

is_hardware_available

Check if hardware quantum annealing is available