quantrs2-ml 0.1.3

//! Auto-generated module
//!
//! 🤖 Generated with [SplitRS](https://github.com/cool-japan/splitrs)

use crate::error::{MLError, Result};
use crate::qnn::{QNNLayerType, QuantumNeuralNetwork};
use scirs2_core::ndarray::{Array1, Array2, Array3, Axis, s};
use std::collections::HashMap;
use serde::{Serialize, Deserialize};

use std::collections::{HashMap};

/// Quantum privacy techniques
#[derive(Debug, Clone)]
pub enum QuantumPrivacyTechnique {
    /// Quantum differential privacy
    QuantumDP { quantum_epsilon: f64 },
    /// Quantum secure multiparty computation
    QuantumSMPC { parties: usize },
    /// Quantum homomorphic encryption
    QuantumHE { scheme: String },
    /// Quantum oblivious transfer
    QuantumOT,
}
/// Selection criteria for custom client selection
#[derive(Debug, Clone)]
pub struct SelectionCriterion {
    /// Criterion name
    pub name: String,
    /// Weight in selection
    pub weight: f64,
    /// Evaluation function (simplified)
    pub threshold: f64,
}
/// Quantum federated learning server
pub struct QuantumFederatedServer {
    /// Global quantum model
    pub global_model: QuantumNeuralNetwork,
    /// Aggregation strategy
    pub aggregation_strategy: QuantumAggregationStrategy,
    /// Registered clients
    clients: HashMap<String, QuantumFederatedClient>,
    /// Server configuration
    pub server_config: ServerConfig,
    /// Global training history
    training_history: Vec<GlobalTrainingRound>,
    /// Server-side optimizer state
    optimizer_state: Option<ServerOptimizerState>,
}
impl QuantumFederatedServer {
    /// Create a new quantum federated server
    pub fn new(
        global_model: QuantumNeuralNetwork,
        aggregation_strategy: QuantumAggregationStrategy,
        server_config: ServerConfig,
    ) -> Self {
        Self {
            global_model,
            aggregation_strategy,
            clients: HashMap::new(),
            server_config,
            training_history: Vec::new(),
            optimizer_state: None,
        }
    }
    /// Register a new client
    pub fn register_client(&mut self, client: QuantumFederatedClient) {
        self.clients.insert(client.client_id.clone(), client);
    }
    /// Run federated learning for specified number of rounds
    pub fn run_federated_learning(&mut self) -> Result<Vec<f64>> {
        let mut global_losses = Vec::new();
        for round in 0..self.server_config.global_rounds {
            println!("Starting federated round {}", round);
            let selected_clients = self.select_clients_for_round(round)?;
            let client_updates = self.collect_client_updates(&selected_clients, round)?;
            let aggregated_update = self.aggregate_client_updates(&client_updates)?;
            self.update_global_model(&aggregated_update)?;
            let global_loss = self.evaluate_global_model()?;
            global_losses.push(global_loss);
            let round_info = self
                .create_round_info(
                    round,
                    &selected_clients,
                    global_loss,
                    &client_updates,
                )?;
            self.training_history.push(round_info);
            if self.check_convergence(&global_losses)? {
                println!("Convergence achieved at round {}", round);
                break;
            }
            println!("Round {} completed. Global loss: {:.4}", round, global_loss);
        }
        Ok(global_losses)
    }
    /// Select clients for training round
    fn select_clients_for_round(&self, round: usize) -> Result<Vec<String>> {
        let mut selected = Vec::new();
        let client_ids: Vec<_> = self.clients.keys().cloned().collect();
        match &self.server_config.client_selection {
            ClientSelectionStrategy::Random { fraction } => {
                let num_select = (client_ids.len() as f64 * fraction) as usize;
                let num_select = num_select
                    .max(self.server_config.min_clients_per_round);
                for _ in 0..num_select {
                    if !client_ids.is_empty() {
                        let idx = fastrand::usize(0..client_ids.len());
                        selected.push(client_ids[idx].clone());
                    }
                }
            }
            ClientSelectionStrategy::QuantumQuality { quality_threshold } => {
                for client_id in &client_ids {
                    if let Some(client) = self.clients.get(client_id) {
                        let quality = self.compute_client_quality(client)?;
                        if quality >= *quality_threshold {
                            selected.push(client_id.clone());
                        }
                    }
                }
                while selected.len() < self.server_config.min_clients_per_round
                    && selected.len() < client_ids.len()
                {
                    for client_id in &client_ids {
                        if !selected.contains(client_id) {
                            selected.push(client_id.clone());
                            break;
                        }
                    }
                }
            }
            _ => {
                let num_select = self
                    .server_config
                    .min_clients_per_round
                    .min(client_ids.len());
                for i in 0..num_select {
                    selected.push(client_ids[i].clone());
                }
            }
        }
        Ok(selected)
    }
    /// Compute quality score for a client
    fn compute_client_quality(&self, client: &QuantumFederatedClient) -> Result<f64> {
        let coherence_score = (-1.0 / client.device_info.coherence_time).exp();
        let error_score = 1.0
            - client.device_info.gate_error_rates.values().sum::<f64>();
        let readout_score = 1.0 - client.device_info.readout_error;
        Ok((coherence_score + error_score + readout_score) / 3.0)
    }
    /// Collect updates from selected clients
    fn collect_client_updates(
        &mut self,
        selected_clients: &[String],
        round: usize,
    ) -> Result<Vec<LocalTrainingUpdate>> {
        let mut updates = Vec::new();
        let global_params = self.global_model.parameters.clone();
        for client_id in selected_clients {
            if let Some(client) = self.clients.get_mut(client_id) {
                let update = client.local_training_round(&global_params, round)?;
                updates.push(update);
            }
        }
        Ok(updates)
    }
    /// Aggregate client updates using specified strategy
    fn aggregate_client_updates(
        &mut self,
        updates: &[LocalTrainingUpdate],
    ) -> Result<Array1<f64>> {
        match &self.aggregation_strategy {
            QuantumAggregationStrategy::QuantumFedAvg { weight_type } => {
                self.quantum_fedavg(updates, weight_type)
            }
            QuantumAggregationStrategy::QuantumFedProx { mu } => {
                self.quantum_fedprox(updates, *mu)
            }
            QuantumAggregationStrategy::QuantumFedNova { tau_eff } => {
                self.quantum_fednova(updates, *tau_eff)
            }
            QuantumAggregationStrategy::QuantumSCAFFOLD { learning_rate } => {
                self.quantum_scaffold(updates, *learning_rate)
            }
            QuantumAggregationStrategy::QuantumFedOpt { server_optimizer, momentum } => {
                self.quantum_fedopt(updates, server_optimizer, *momentum)
            }
            QuantumAggregationStrategy::QuantumDP { epsilon, delta, sensitivity } => {
                self.quantum_dp_aggregation(updates, *epsilon, *delta, *sensitivity)
            }
            QuantumAggregationStrategy::QuantumHomomorphic { encryption_scheme } => {
                self.quantum_homomorphic_aggregation(updates, encryption_scheme)
            }
            QuantumAggregationStrategy::QuantumByzantine {
                byzantine_fraction,
                robust_method,
            } => {
                self.quantum_byzantine_aggregation(
                    updates,
                    *byzantine_fraction,
                    robust_method,
                )
            }
        }
    }
    /// Quantum FedAvg aggregation
    fn quantum_fedavg(
        &self,
        updates: &[LocalTrainingUpdate],
        weight_type: &WeightingType,
    ) -> Result<Array1<f64>> {
        if updates.is_empty() {
            return Err(
                MLError::MLOperationError("No client updates to aggregate".to_string()),
            );
        }
        let param_size = updates[0].parameter_update.len();
        let mut aggregated = Array1::zeros(param_size);
        let mut total_weight = 0.0;
        for update in updates {
            let weight = match weight_type {
                WeightingType::Uniform => 1.0,
                WeightingType::DataSize => update.num_samples as f64,
                WeightingType::QuantumCoherence => {
                    update.quantum_metrics.coherence_preservation
                }
                WeightingType::QuantumFidelity => update.quantum_metrics.avg_fidelity,
                WeightingType::QuantumErrorRate => {
                    1.0 - update.quantum_metrics.gate_error_accumulation
                }
                WeightingType::Custom(weights) => weights.get(0).copied().unwrap_or(1.0),
            };
            aggregated = aggregated + weight * &update.parameter_update;
            total_weight += weight;
        }
        if total_weight > 0.0 {
            aggregated = aggregated / total_weight;
        }
        Ok(aggregated)
    }
    /// Quantum FedProx aggregation
    fn quantum_fedprox(
        &self,
        updates: &[LocalTrainingUpdate],
        mu: f64,
    ) -> Result<Array1<f64>> {
        let fedavg_result = self.quantum_fedavg(updates, &WeightingType::DataSize)?;
        let regularization_factor = 1.0 / (1.0 + mu);
        Ok(fedavg_result * regularization_factor)
    }
    /// Quantum FedNova aggregation
    fn quantum_fednova(
        &self,
        updates: &[LocalTrainingUpdate],
        tau_eff: f64,
    ) -> Result<Array1<f64>> {
        let mut normalized_updates = Vec::new();
        for update in updates {
            let normalized = &update.parameter_update / tau_eff;
            normalized_updates
                .push(LocalTrainingUpdate {
                    parameter_update: normalized,
                    ..update.clone()
                });
        }
        self.quantum_fedavg(&normalized_updates, &WeightingType::DataSize)
    }
    /// Quantum SCAFFOLD aggregation
    fn quantum_scaffold(
        &mut self,
        updates: &[LocalTrainingUpdate],
        learning_rate: f64,
    ) -> Result<Array1<f64>> {
        let fedavg_result = self.quantum_fedavg(updates, &WeightingType::DataSize)?;
        let control_variate_update = &fedavg_result * learning_rate;
        Ok(fedavg_result + control_variate_update)
    }
    /// Quantum FedOpt aggregation
    fn quantum_fedopt(
        &mut self,
        updates: &[LocalTrainingUpdate],
        server_optimizer: &ServerOptimizerType,
        momentum: f64,
    ) -> Result<Array1<f64>> {
        let aggregated = self.quantum_fedavg(updates, &WeightingType::DataSize)?;
        if self.optimizer_state.is_none() {
            self.optimizer_state = Some(ServerOptimizerState {
                momentum: Array1::zeros(aggregated.len()),
                second_moment: Array1::zeros(aggregated.len()),
                step_count: 0,
                learning_rate: 0.01,
                quantum_state: QuantumOptimizerState {
                    fisher_information: Array2::eye(aggregated.len()),
                    natural_gradient_correction: Array1::zeros(aggregated.len()),
                    parameter_covariance: Array2::eye(aggregated.len()),
                    noise_estimates: Array1::zeros(aggregated.len()),
                },
            });
        }
        if let Some(ref mut state) = self.optimizer_state {
            match server_optimizer {
                ServerOptimizerType::QuantumAdam { beta1, beta2, epsilon } => {
                    state.step_count += 1;
                    state.momentum = *beta1 * &state.momentum
                        + (1.0 - beta1) * &aggregated;
                    state.second_moment = *beta2 * &state.second_moment
                        + (1.0 - beta2) * aggregated.mapv(|x| x * x);
                    let bias_correction1 = 1.0 - beta1.powi(state.step_count as i32);
                    let bias_correction2 = 1.0 - beta2.powi(state.step_count as i32);
                    let corrected_momentum = &state.momentum / bias_correction1;
                    let corrected_second_moment = &state.second_moment
                        / bias_correction2;
                    let update = corrected_momentum
                        / (corrected_second_moment.mapv(|x| x.sqrt()) + *epsilon);
                    Ok(update)
                }
                _ => Ok(aggregated),
            }
        } else {
            Ok(aggregated)
        }
    }
    /// Quantum differential privacy aggregation
    fn quantum_dp_aggregation(
        &self,
        updates: &[LocalTrainingUpdate],
        epsilon: f64,
        delta: f64,
        sensitivity: f64,
    ) -> Result<Array1<f64>> {
        let aggregated = self.quantum_fedavg(updates, &WeightingType::DataSize)?;
        let noise_scale = 2.0 * sensitivity * (2.0 * (1.25 / delta).ln()).sqrt()
            / epsilon;
        let mut private_aggregated = aggregated;
        for param in private_aggregated.iter_mut() {
            *param += noise_scale * random_gaussian();
        }
        Ok(private_aggregated)
    }
    /// Quantum homomorphic aggregation
    fn quantum_homomorphic_aggregation(
        &self,
        updates: &[LocalTrainingUpdate],
        _encryption_scheme: &QuantumEncryptionScheme,
    ) -> Result<Array1<f64>> {
        self.quantum_fedavg(updates, &WeightingType::DataSize)
    }
    /// Quantum Byzantine-robust aggregation
    fn quantum_byzantine_aggregation(
        &self,
        updates: &[LocalTrainingUpdate],
        byzantine_fraction: f64,
        robust_method: &ByzantineRobustMethod,
    ) -> Result<Array1<f64>> {
        let num_byzantine = (updates.len() as f64 * byzantine_fraction) as usize;
        let num_honest = updates.len() - num_byzantine;
        match robust_method {
            ByzantineRobustMethod::QuantumKrum => {
                let mut best_update = None;
                let mut best_score = f64::INFINITY;
                for (i, update) in updates.iter().enumerate() {
                    let mut score = 0.0;
                    let mut distances = Vec::new();
                    for (j, other_update) in updates.iter().enumerate() {
                        if i != j {
                            let distance = (&update.parameter_update
                                - &other_update.parameter_update)
                                .mapv(|x| x * x)
                                .sum()
                                .sqrt();
                            distances.push(distance);
                        }
                    }
                    distances
                        .sort_by(|a, b| {
                            a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal)
                        });
                    score = distances.iter().take(num_honest - 1).sum();
                    if score < best_score {
                        best_score = score;
                        best_update = Some(update.parameter_update.clone());
                    }
                }
                best_update
                    .ok_or_else(|| MLError::MLOperationError(
                        "No valid update found".to_string(),
                    ))
            }
            ByzantineRobustMethod::QuantumTrimmedMean => {
                let param_size = updates[0].parameter_update.len();
                let mut trimmed_aggregated = Array1::zeros(param_size);
                for param_idx in 0..param_size {
                    let mut values: Vec<f64> = updates
                        .iter()
                        .map(|u| u.parameter_update[param_idx])
                        .collect();
                    values
                        .sort_by(|a, b| {
                            a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal)
                        });
                    let trim_count = (values.len() as f64 * byzantine_fraction / 2.0)
                        as usize;
                    let trimmed_values = &values[trim_count..values.len() - trim_count];
                    if !trimmed_values.is_empty() {
                        trimmed_aggregated[param_idx] = trimmed_values
                            .iter()
                            .sum::<f64>() / trimmed_values.len() as f64;
                    }
                }
                Ok(trimmed_aggregated)
            }
            _ => self.quantum_fedavg(updates, &WeightingType::DataSize),
        }
    }
    /// Update global model with aggregated update
    fn update_global_model(&mut self, aggregated_update: &Array1<f64>) -> Result<()> {
        self.global_model.parameters = &self.global_model.parameters + aggregated_update;
        Ok(())
    }
    /// Evaluate global model
    fn evaluate_global_model(&self) -> Result<f64> {
        Ok(0.5 + 0.4 * fastrand::f64())
    }
    /// Check convergence criteria
    fn check_convergence(&self, losses: &[f64]) -> Result<bool> {
        if losses.len() < 2 {
            return Ok(false);
        }
        let current_loss = losses[losses.len() - 1];
        let prev_loss = losses[losses.len() - 2];
        let improvement = (prev_loss - current_loss).abs();
        Ok(improvement < self.server_config.convergence_criteria.loss_threshold)
    }
    /// Create round information record
    fn create_round_info(
        &self,
        round: usize,
        selected_clients: &[String],
        global_loss: f64,
        client_updates: &[LocalTrainingUpdate],
    ) -> Result<GlobalTrainingRound> {
        let aggregation_metrics = self.compute_aggregation_metrics(client_updates)?;
        let quantum_consensus = self.compute_quantum_consensus_metrics(client_updates)?;
        let security_metrics = self.compute_security_metrics(client_updates)?;
        Ok(GlobalTrainingRound {
            round,
            participating_clients: selected_clients.to_vec(),
            global_loss,
            aggregation_metrics,
            quantum_consensus,
            security_metrics,
        })
    }
    /// Compute aggregation quality metrics
    fn compute_aggregation_metrics(
        &self,
        updates: &[LocalTrainingUpdate],
    ) -> Result<AggregationMetrics> {
        if updates.is_empty() {
            return Ok(AggregationMetrics {
                parameter_disagreement: 0.0,
                quantum_state_overlap: 1.0,
                aggregation_efficiency: 1.0,
                weight_entropy: 0.0,
            });
        }
        let mut total_disagreement = 0.0;
        for i in 0..updates.len() {
            for j in i + 1..updates.len() {
                let disagreement = (&updates[i].parameter_update
                    - &updates[j].parameter_update)
                    .mapv(|x| x * x)
                    .sum()
                    .sqrt();
                total_disagreement += disagreement;
            }
        }
        let num_pairs = updates.len() * (updates.len() - 1) / 2;
        let parameter_disagreement = if num_pairs > 0 {
            total_disagreement / num_pairs as f64
        } else {
            0.0
        };
        let quantum_state_overlap = 0.8 + 0.15 * fastrand::f64();
        let aggregation_efficiency = 0.7 + 0.25 * fastrand::f64();
        let weight_entropy = 1.0 + fastrand::f64();
        Ok(AggregationMetrics {
            parameter_disagreement,
            quantum_state_overlap,
            aggregation_efficiency,
            weight_entropy,
        })
    }
    /// Compute quantum consensus metrics
    fn compute_quantum_consensus_metrics(
        &self,
        updates: &[LocalTrainingUpdate],
    ) -> Result<QuantumConsensusMetrics> {
        if updates.is_empty() {
            return Ok(QuantumConsensusMetrics {
                consensus_fidelity: 1.0,
                entanglement_preservation: 1.0,
                quantum_error_rate: 0.0,
                decoherence_impact: 0.0,
            });
        }
        let avg_fidelity = updates
            .iter()
            .map(|u| u.quantum_metrics.avg_fidelity)
            .sum::<f64>() / updates.len() as f64;
        let avg_coherence = updates
            .iter()
            .map(|u| u.quantum_metrics.coherence_preservation)
            .sum::<f64>() / updates.len() as f64;
        let avg_error_rate = updates
            .iter()
            .map(|u| u.quantum_metrics.gate_error_accumulation)
            .sum::<f64>() / updates.len() as f64;
        let decoherence_impact = 1.0 - avg_coherence;
        Ok(QuantumConsensusMetrics {
            consensus_fidelity: avg_fidelity,
            entanglement_preservation: avg_coherence,
            quantum_error_rate: avg_error_rate,
            decoherence_impact,
        })
    }
    /// Compute security metrics
    fn compute_security_metrics(
        &self,
        updates: &[LocalTrainingUpdate],
    ) -> Result<SecurityMetrics> {
        let privacy_budget_consumed = updates.iter().map(|_| 0.01).sum::<f64>();
        Ok(SecurityMetrics {
            privacy_budget_consumed,
            detected_anomalies: 0,
            encryption_overhead: 0.05,
            authentication_failures: 0,
        })
    }
}
/// Communication overhead metrics
#[derive(Debug, Clone)]
pub struct CommunicationOverhead {
    /// Bytes sent
    pub bytes_sent: usize,
    /// Bytes received
    pub bytes_received: usize,
    /// Communication time
    pub comm_time: f64,
    /// Compression efficiency
    pub compression_efficiency: f64,
}
/// Local training round information
#[derive(Debug, Clone)]
pub struct LocalTrainingRound {
    /// Round number
    pub round: usize,
    /// Local loss achieved
    pub local_loss: f64,
    /// Training time (seconds)
    pub training_time: f64,
    /// Quantum fidelity metrics
    pub quantum_metrics: QuantumTrainingMetrics,
    /// Communication overhead
    pub comm_overhead: CommunicationOverhead,
    /// Privacy metrics
    pub privacy_metrics: PrivacyMetrics,
}
/// Malicious client detection configuration
#[derive(Debug, Clone)]
pub struct MaliciousDetectionConfig {
    /// Enable Byzantine detection
    pub byzantine_detection: bool,
    /// Statistical anomaly detection
    pub statistical_detection: bool,
    /// Quantum signature verification
    pub quantum_signature_verification: bool,
    /// Reputation system
    pub reputation_system: bool,
}
/// Server optimizer state
#[derive(Debug, Clone)]
pub struct ServerOptimizerState {
    /// Momentum terms
    pub momentum: Array1<f64>,
    /// Second moment estimates
    pub second_moment: Array1<f64>,
    /// Step count
    pub step_count: usize,
    /// Learning rate schedule
    pub learning_rate: f64,
    /// Quantum-specific optimizer state
    pub quantum_state: QuantumOptimizerState,
}
/// Security metrics for federated round
#[derive(Debug, Clone)]
pub struct SecurityMetrics {
    /// Privacy budget consumed
    pub privacy_budget_consumed: f64,
    /// Detected anomalies
    pub detected_anomalies: usize,
    /// Encryption overhead
    pub encryption_overhead: f64,
    /// Authentication failures
    pub authentication_failures: usize,
}
/// Quantum compression methods
#[derive(Debug, Clone)]
pub enum QuantumCompressionMethod {
    /// Quantum state compression
    StateCompression { fidelity_threshold: f64 },
    /// Quantum circuit compression
    CircuitCompression { gate_reduction_target: f64 },
    /// Quantum parameter quantization
    ParameterQuantization { quantum_levels: usize },
}
/// Convergence criteria
#[derive(Debug, Clone)]
pub struct ConvergenceCriteria {
    /// Loss improvement threshold
    pub loss_threshold: f64,
    /// Patience (rounds without improvement)
    pub patience: usize,
    /// Quantum fidelity convergence
    pub quantum_fidelity_threshold: f64,
    /// Parameter change threshold
    pub parameter_change_threshold: f64,
    /// Early stopping based on quantum metrics
    pub quantum_early_stopping: bool,
}
/// Local training configuration
#[derive(Debug, Clone)]
pub struct LocalTrainingConfig {
    /// Number of local epochs
    pub local_epochs: usize,
    /// Local batch size
    pub batch_size: usize,
    /// Local learning rate
    pub learning_rate: f64,
    /// Quantum circuit optimization level
    pub circuit_optimization: CircuitOptimizationLevel,
    /// Error mitigation techniques
    pub error_mitigation: Vec<ErrorMitigationType>,
    /// Quantum noise handling
    pub noise_handling: NoiseHandlingStrategy,
}
/// Quantum communication protocols
#[derive(Debug, Clone)]
pub enum QuantumCommProtocol {
    /// Quantum teleportation for parameter transfer
    QuantumTeleportation,
    /// Quantum key distribution for secure communication
    QKD { protocol: String },
    /// Quantum superdense coding
    SuperdenseCoding,
    /// Quantum error correction for communication
    QuantumErrorCorrection { code: String },
}
/// Quantum federated learning aggregation strategies
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum QuantumAggregationStrategy {
    /// Quantum FedAvg - Average quantum parameters
    QuantumFedAvg { weight_type: WeightingType },
    /// Quantum FedProx - Proximal term for quantum parameters
    QuantumFedProx { mu: f64 },
    /// Quantum FedNova - Normalized averaging for quantum models
    QuantumFedNova { tau_eff: f64 },
    /// Quantum SCAFFOLD - Control variates for quantum gradients
    QuantumSCAFFOLD { learning_rate: f64 },
    /// Quantum FedOpt - Adaptive optimization for quantum parameters
    QuantumFedOpt { server_optimizer: ServerOptimizerType, momentum: f64 },
    /// Quantum Differential Privacy aggregation
    QuantumDP { epsilon: f64, delta: f64, sensitivity: f64 },
    /// Quantum Homomorphic aggregation
    QuantumHomomorphic { encryption_scheme: QuantumEncryptionScheme },
    /// Quantum Byzantine-robust aggregation
    QuantumByzantine { byzantine_fraction: f64, robust_method: ByzantineRobustMethod },
}
/// Server configuration
#[derive(Debug, Clone)]
pub struct ServerConfig {
    /// Global training rounds
    pub global_rounds: usize,
    /// Minimum clients per round
    pub min_clients_per_round: usize,
    /// Client selection strategy
    pub client_selection: ClientSelectionStrategy,
    /// Model validation settings
    pub validation_config: ValidationConfig,
    /// Convergence criteria
    pub convergence_criteria: ConvergenceCriteria,
    /// Security settings
    pub security_config: ServerSecurityConfig,
}
/// Quantum encryption schemes for secure aggregation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum QuantumEncryptionScheme {
    /// Quantum key distribution based encryption
    QKD { key_length: usize },
    /// Quantum homomorphic encryption
    QHE { security_parameter: usize },
    /// Classical encryption with quantum-safe algorithms
    PostQuantum { algorithm: String },
}
/// Quantum-specific training metrics
#[derive(Debug, Clone)]
pub struct QuantumTrainingMetrics {
    /// Average quantum fidelity
    pub avg_fidelity: f64,
    /// Quantum coherence preservation
    pub coherence_preservation: f64,
    /// Gate error accumulation
    pub gate_error_accumulation: f64,
    /// Circuit depth efficiency
    pub circuit_depth_efficiency: f64,
    /// Quantum advantage metric
    pub quantum_advantage: f64,
}
/// Server-side optimizers for quantum federated learning
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ServerOptimizerType {
    /// Quantum Adam optimizer
    QuantumAdam { beta1: f64, beta2: f64, epsilon: f64 },
    /// Quantum AdaGrad optimizer
    QuantumAdaGrad { epsilon: f64 },
    /// Quantum RMSprop optimizer
    QuantumRMSprop { decay: f64, epsilon: f64 },
    /// Quantum Natural Gradient optimizer
    QuantumNatural { regularization: f64 },
}
/// Validation configuration
#[derive(Debug, Clone)]
pub struct ValidationConfig {
    /// Validation frequency (every N rounds)
    pub validation_frequency: usize,
    /// Validation dataset info
    pub validation_data: ValidationDataConfig,
    /// Quantum benchmarks
    pub quantum_benchmarks: Vec<QuantumBenchmark>,
    /// Classical benchmarks for comparison
    pub classical_benchmarks: Vec<String>,
}
/// Validation data configuration
#[derive(Debug, Clone)]
pub enum ValidationDataConfig {
    /// Use server-side validation data
    ServerSide,
    /// Federated validation across clients
    Federated { client_fraction: f64 },
    /// External benchmark datasets
    External { dataset_names: Vec<String> },
}
/// Server security configuration
#[derive(Debug, Clone)]
pub struct ServerSecurityConfig {
    /// Client authentication required
    pub require_authentication: bool,
    /// Malicious client detection
    pub malicious_detection: MaliciousDetectionConfig,
    /// Audit logging
    pub audit_logging: bool,
    /// Secure aggregation protocols
    pub secure_aggregation_protocols: Vec<String>,
}
/// Byzantine-robust methods for quantum federated learning
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ByzantineRobustMethod {
    /// Quantum Krum - Select most consistent quantum models
    QuantumKrum,
    /// Quantum Trimmed Mean - Remove outlier quantum parameters
    QuantumTrimmedMean,
    /// Quantum Median - Median-based aggregation
    QuantumMedian,
    /// Quantum Clustering - Cluster-based robust aggregation
    QuantumClustering { num_clusters: usize },
}
/// Weighting strategies for quantum federated averaging
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum WeightingType {
    /// Equal weights for all clients
    Uniform,
    /// Weight by local dataset size
    DataSize,
    /// Weight by quantum coherence quality
    QuantumCoherence,
    /// Weight by quantum fidelity of local models
    QuantumFidelity,
    /// Weight by quantum gate error rates
    QuantumErrorRate,
    /// Custom weights
    Custom(Vec<f64>),
}
/// Privacy configuration
#[derive(Debug, Clone)]
pub struct PrivacyConfig {
    /// Enable differential privacy
    pub differential_privacy: bool,
    /// Privacy budget (epsilon)
    pub privacy_budget: f64,
    /// Delta parameter for (epsilon, delta)-DP
    pub delta: f64,
    /// Secure aggregation
    pub secure_aggregation: bool,
    /// Quantum privacy techniques
    pub quantum_privacy: Vec<QuantumPrivacyTechnique>,
    /// Data minimization
    pub data_minimization: bool,
}
/// Error mitigation techniques
#[derive(Debug, Clone)]
pub enum ErrorMitigationType {
    /// Zero-noise extrapolation
    ZeroNoiseExtrapolation,
    /// Readout error mitigation
    ReadoutErrorMitigation,
    /// Symmetry verification
    SymmetryVerification,
    /// Clifford data regression
    CliffordDataRegression,
    /// Virtual distillation
    VirtualDistillation,
}
/// Global training round information
#[derive(Debug, Clone)]
pub struct GlobalTrainingRound {
    /// Round number
    pub round: usize,
    /// Participating clients
    pub participating_clients: Vec<String>,
    /// Global loss
    pub global_loss: f64,
    /// Aggregation metrics
    pub aggregation_metrics: AggregationMetrics,
    /// Quantum consensus metrics
    pub quantum_consensus: QuantumConsensusMetrics,
    /// Security metrics
    pub security_metrics: SecurityMetrics,
}
/// Quantum-specific optimizer state
#[derive(Debug, Clone)]
pub struct QuantumOptimizerState {
    /// Quantum Fisher information matrix
    pub fisher_information: Array2<f64>,
    /// Natural gradient correction
    pub natural_gradient_correction: Array1<f64>,
    /// Quantum parameter covariance
    pub parameter_covariance: Array2<f64>,
    /// Quantum noise estimates
    pub noise_estimates: Array1<f64>,
}
/// Circuit optimization levels
#[derive(Debug, Clone)]
pub enum CircuitOptimizationLevel {
    /// No optimization
    None,
    /// Basic gate simplification
    Basic,
    /// Advanced optimization
    Advanced { max_depth_reduction: usize },
    /// Hardware-specific optimization
    HardwareSpecific { device_constraints: HashMap<String, f64> },
}
/// Noise handling strategies
#[derive(Debug, Clone)]
pub enum NoiseHandlingStrategy {
    /// Ignore noise
    Ignore,
    /// Model noise explicitly
    ExplicitModeling { noise_params: Array1<f64> },
    /// Noise-aware training
    NoiseAware { adaptation_rate: f64 },
    /// Quantum error correction
    ErrorCorrection { code_type: String, threshold: f64 },
}
/// Compression configuration
#[derive(Debug, Clone)]
pub struct CompressionConfig {
    /// Enable parameter compression
    pub enabled: bool,
    /// Compression ratio
    pub compression_ratio: f64,
    /// Quantization bits
    pub quantization_bits: usize,
    /// Sparsification threshold
    pub sparsification_threshold: f64,
    /// Quantum-specific compression
    pub quantum_compression: Option<QuantumCompressionMethod>,
}
/// Client selection strategies
#[derive(Debug, Clone)]
pub enum ClientSelectionStrategy {
    /// Random selection
    Random { fraction: f64 },
    /// Select based on quantum device quality
    QuantumQuality { quality_threshold: f64 },
    /// Select based on data distribution
    DataDiversity { diversity_metric: String },
    /// Select based on communication constraints
    CommunicationBased { latency_threshold: f64 },
    /// Custom selection criteria
    Custom { criteria: Vec<SelectionCriterion> },
}
/// Quantum device information
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QuantumDeviceInfo {
    /// Number of physical qubits
    pub num_qubits: usize,
    /// Quantum coherence time (microseconds)
    pub coherence_time: f64,
    /// Gate error rates
    pub gate_error_rates: HashMap<String, f64>,
    /// Readout error rate
    pub readout_error: f64,
    /// Connectivity graph
    pub connectivity: Vec<(usize, usize)>,
    /// Device type
    pub device_type: QuantumDeviceType,
    /// Calibration timestamp
    pub last_calibration: u64,
}
/// Quantum benchmarks for model validation
#[derive(Debug, Clone)]
pub struct QuantumBenchmark {
    /// Benchmark name
    pub name: String,
    /// Quantum task type
    pub task_type: QuantumTaskType,
    /// Expected quantum advantage
    pub expected_advantage: f64,
    /// Benchmark configuration
    pub config: HashMap<String, f64>,
}
/// Classical security configuration
#[derive(Debug, Clone)]
pub struct ClassicalSecurityConfig {
    /// Encryption algorithm
    pub encryption: String,
    /// Key length
    pub key_length: usize,
    /// Authentication method
    pub authentication: String,
    /// Certificate validation
    pub cert_validation: bool,
}
/// Aggregation quality metrics
#[derive(Debug, Clone)]
pub struct AggregationMetrics {
    /// Parameter disagreement measure
    pub parameter_disagreement: f64,
    /// Quantum state overlap
    pub quantum_state_overlap: f64,
    /// Aggregation efficiency
    pub aggregation_efficiency: f64,
    /// Weight distribution entropy
    pub weight_entropy: f64,
}
/// Communication constraints for quantum federated learning
#[derive(Debug, Clone)]
pub struct CommunicationConstraints {
    /// Maximum communication rounds
    pub max_comm_rounds: usize,
    /// Bandwidth limitations (MB/s)
    pub bandwidth_limit: f64,
    /// Latency constraints (ms)
    pub max_latency: f64,
    /// Compression settings
    pub compression: CompressionConfig,
    /// Quantum communication protocols
    pub quantum_protocols: Vec<QuantumCommProtocol>,
    /// Classical communication security
    pub classical_security: ClassicalSecurityConfig,
}
/// Quantum federated learning client
#[derive(Debug, Clone)]
pub struct QuantumFederatedClient {
    /// Client ID
    pub client_id: String,
    /// Local quantum model
    pub local_model: QuantumNeuralNetwork,
    /// Local training data
    local_data: Option<Array2<f64>>,
    local_labels: Option<Array1<usize>>,
    /// Quantum device characteristics
    pub device_info: QuantumDeviceInfo,
    /// Local training configuration
    pub local_config: LocalTrainingConfig,
    /// Communication constraints
    pub comm_constraints: CommunicationConstraints,
    /// Privacy preferences
    pub privacy_config: PrivacyConfig,
    /// Local training history
    training_history: Vec<LocalTrainingRound>,
}
impl QuantumFederatedClient {
    /// Create a new quantum federated client
    pub fn new(
        client_id: String,
        local_model: QuantumNeuralNetwork,
        device_info: QuantumDeviceInfo,
        local_config: LocalTrainingConfig,
    ) -> Self {
        Self {
            client_id,
            local_model,
            local_data: None,
            local_labels: None,
            device_info,
            local_config,
            comm_constraints: CommunicationConstraints::default(),
            privacy_config: PrivacyConfig::default(),
            training_history: Vec::new(),
        }
    }
    /// Set local training data
    pub fn set_local_data(&mut self, data: Array2<f64>, labels: Array1<usize>) {
        self.local_data = Some(data);
        self.local_labels = Some(labels);
    }
    /// Perform local training for one round
    pub fn local_training_round(
        &mut self,
        global_model_params: &Array1<f64>,
        round: usize,
    ) -> Result<LocalTrainingUpdate> {
        self.local_model.parameters = global_model_params.clone();
        let start_time = std::time::Instant::now();
        let mut local_loss = 0.0;
        let data = self
            .local_data
            .as_ref()
            .ok_or_else(|| MLError::MLOperationError(
                "No local data available".to_string(),
            ))?;
        let labels = self
            .local_labels
            .as_ref()
            .ok_or_else(|| MLError::MLOperationError(
                "No local labels available".to_string(),
            ))?;
        for epoch in 0..self.local_config.local_epochs {
            let epoch_loss = self.train_one_epoch(data, labels)?;
            local_loss = epoch_loss;
            self.apply_error_mitigation()?;
        }
        let training_time = start_time.elapsed().as_secs_f64();
        let quantum_metrics = self.compute_quantum_metrics()?;
        let parameter_update = &self.local_model.parameters - global_model_params;
        let private_update = if self.privacy_config.differential_privacy {
            self.apply_differential_privacy(&parameter_update)?
        } else {
            parameter_update
        };
        let compressed_update = if self.comm_constraints.compression.enabled {
            self.compress_update(&private_update)?
        } else {
            private_update
        };
        let training_round = LocalTrainingRound {
            round,
            local_loss,
            training_time,
            quantum_metrics: quantum_metrics.clone(),
            comm_overhead: CommunicationOverhead {
                bytes_sent: compressed_update.len() * 8,
                bytes_received: global_model_params.len() * 8,
                comm_time: 0.1,
                compression_efficiency: if self.comm_constraints.compression.enabled {
                    self.comm_constraints.compression.compression_ratio
                } else {
                    1.0
                },
            },
            privacy_metrics: PrivacyMetrics {
                privacy_budget_consumed: if self.privacy_config.differential_privacy {
                    self.privacy_config.privacy_budget
                        / self.local_config.local_epochs as f64
                } else {
                    0.0
                },
                information_leakage: 0.01,
                quantum_privacy_fidelity: 0.95,
            },
        };
        self.training_history.push(training_round);
        Ok(LocalTrainingUpdate {
            client_id: self.client_id.clone(),
            parameter_update: compressed_update,
            num_samples: data.nrows(),
            local_loss,
            quantum_metrics,
            device_info: self.device_info.clone(),
        })
    }
    /// Train for one epoch
    fn train_one_epoch(
        &mut self,
        data: &Array2<f64>,
        labels: &Array1<usize>,
    ) -> Result<f64> {
        let mut total_loss = 0.0;
        let num_batches = (data.nrows() + self.local_config.batch_size - 1)
            / self.local_config.batch_size;
        for batch_idx in 0..num_batches {
            let start_idx = batch_idx * self.local_config.batch_size;
            let end_idx = (start_idx + self.local_config.batch_size).min(data.nrows());
            let batch_data = data.slice(s![start_idx..end_idx, ..]).to_owned();
            let batch_labels = labels.slice(s![start_idx..end_idx]).to_owned();
            let mut batch_loss = 0.0;
            for (input, &label) in batch_data.outer_iter().zip(batch_labels.iter()) {
                let output = self.local_model.forward(&input.to_owned())?;
                let loss = self.compute_loss(&output, label);
                batch_loss += loss;
            }
            batch_loss /= batch_data.nrows() as f64;
            total_loss += batch_loss;
            for param in self.local_model.parameters.iter_mut() {
                *param -= self.local_config.learning_rate * 0.01 * fastrand::f64();
            }
        }
        Ok(total_loss / num_batches as f64)
    }
    /// Compute loss for a single sample
    fn compute_loss(&self, output: &Array1<f64>, label: usize) -> f64 {
        if label < output.len() { -output[label].ln().max(-10.0) } else { 10.0 }
    }
    /// Apply error mitigation techniques
    fn apply_error_mitigation(&mut self) -> Result<()> {
        for mitigation_type in &self.local_config.error_mitigation.clone() {
            match mitigation_type {
                ErrorMitigationType::ZeroNoiseExtrapolation => {
                    for param in self.local_model.parameters.iter_mut() {
                        *param *= 1.02;
                    }
                }
                ErrorMitigationType::ReadoutErrorMitigation => {
                    let correction_factor = 1.0 - self.device_info.readout_error;
                    for param in self.local_model.parameters.iter_mut() {
                        *param *= correction_factor;
                    }
                }
                _ => {}
            }
        }
        Ok(())
    }
    /// Compute quantum-specific metrics
    fn compute_quantum_metrics(&self) -> Result<QuantumTrainingMetrics> {
        let avg_fidelity = 0.95
            - self.device_info.gate_error_rates.values().sum::<f64>() / 10.0;
        let coherence_preservation = (-1.0 / self.device_info.coherence_time).exp();
        let gate_error_accumulation = self
            .device_info
            .gate_error_rates
            .values()
            .sum::<f64>();
        let circuit_depth_efficiency = 0.8;
        let quantum_advantage = (avg_fidelity * coherence_preservation).max(0.0);
        Ok(QuantumTrainingMetrics {
            avg_fidelity,
            coherence_preservation,
            gate_error_accumulation,
            circuit_depth_efficiency,
            quantum_advantage,
        })
    }
    /// Apply differential privacy to parameter update
    fn apply_differential_privacy(&self, update: &Array1<f64>) -> Result<Array1<f64>> {
        let mut private_update = update.clone();
        let sensitivity = self.estimate_sensitivity();
        let noise_scale = 2.0 * sensitivity
            * (2.0 * (1.25 / self.privacy_config.delta).ln()).sqrt()
            / self.privacy_config.privacy_budget;
        for param in private_update.iter_mut() {
            let noise = noise_scale * random_gaussian();
            *param += noise;
        }
        Ok(private_update)
    }
    /// Estimate parameter sensitivity for differential privacy
    fn estimate_sensitivity(&self) -> f64 {
        2.0 * self.local_config.learning_rate
    }
    /// Compress parameter update
    fn compress_update(&self, update: &Array1<f64>) -> Result<Array1<f64>> {
        let mut compressed = update.clone();
        if self.comm_constraints.compression.quantization_bits < 32 {
            let levels = 1 << self.comm_constraints.compression.quantization_bits;
            let max_val = update.iter().cloned().fold(f64::NEG_INFINITY, f64::max);
            let min_val = update.iter().cloned().fold(f64::INFINITY, f64::min);
            let range = max_val - min_val;
            for param in compressed.iter_mut() {
                let normalized = (*param - min_val) / range;
                let quantized = (normalized * (levels - 1) as f64).round()
                    / (levels - 1) as f64;
                *param = quantized * range + min_val;
            }
        }
        if self.comm_constraints.compression.sparsification_threshold > 0.0 {
            let threshold = self.comm_constraints.compression.sparsification_threshold;
            for param in compressed.iter_mut() {
                if param.abs() < threshold {
                    *param = 0.0;
                }
            }
        }
        Ok(compressed)
    }
}
/// Privacy preservation metrics
#[derive(Debug, Clone)]
pub struct PrivacyMetrics {
    /// Privacy budget consumed
    pub privacy_budget_consumed: f64,
    /// Information leakage estimate
    pub information_leakage: f64,
    /// Quantum privacy fidelity
    pub quantum_privacy_fidelity: f64,
}
/// Types of quantum tasks for benchmarking
#[derive(Debug, Clone)]
pub enum QuantumTaskType {
    /// Quantum state classification
    StateClassification,
    /// Quantum process tomography
    ProcessTomography,
    /// Quantum error syndrome decoding
    ErrorSyndrome,
    /// Quantum optimization
    QuantumOptimization,
    /// Quantum simulation
    QuantumSimulation,
}
/// Quantum consensus metrics
#[derive(Debug, Clone)]
pub struct QuantumConsensusMetrics {
    /// Quantum consensus fidelity
    pub consensus_fidelity: f64,
    /// Entanglement preservation
    pub entanglement_preservation: f64,
    /// Quantum error rate
    pub quantum_error_rate: f64,
    /// Decoherence impact
    pub decoherence_impact: f64,
}
/// Local training update from client
#[derive(Debug, Clone)]
pub struct LocalTrainingUpdate {
    /// Client identifier
    pub client_id: String,
    /// Parameter update (compressed/private)
    pub parameter_update: Array1<f64>,
    /// Number of local samples
    pub num_samples: usize,
    /// Local loss achieved
    pub local_loss: f64,
    /// Quantum training metrics
    pub quantum_metrics: QuantumTrainingMetrics,
    /// Device information
    pub device_info: QuantumDeviceInfo,
}
/// Types of quantum devices
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum QuantumDeviceType {
    /// Superconducting transmon qubits
    Superconducting { frequency_range: (f64, f64) },
    /// Trapped ion qubits
    TrappedIon { ion_species: String },
    /// Photonic qubits
    Photonic { wavelength: f64 },
    /// Neutral atom qubits
    NeutralAtom { atom_species: String },
    /// Silicon spin qubits
    SiliconSpin { temperature: f64 },
    /// Quantum simulator
    Simulator { noise_model: Option<String> },
}