Crate ruqu_qflg 

ruqu-qflg - Quantum Federated Learning with Byzantine Tolerance

A privacy-preserving distributed quantum machine learning framework that combines:

• Federated Learning: Distributed training without sharing raw data
• Byzantine Tolerance: Robust aggregation against malicious participants
• Differential Privacy: Formal privacy guarantees for gradient updates
• Quantum Enhancement: Quantum-inspired features for security and randomness

Architecture

┌─────────────────────────────────────────────────────────────────┐
│                    Federated Coordinator                         │
│  (Round management, model synchronization, aggregation)         │
└───────────────────────────┬─────────────────────────────────────┘
                            │
    ┌───────────────────────┼───────────────────────┐
    ▼                       ▼                       ▼
┌─────────┐           ┌───────────┐           ┌───────────┐
│Byzantine│           │  Privacy  │           │  Quantum  │
│Detection│           │ Mechanism │           │Enhancement│
└─────────┘           └───────────┘           └───────────┘
Krum/Median           Gaussian/DP              QRNG/PQ-Sig
Bulyan/Trim           Budget Track             Bell Pairs

Quick Start

use ruqu_qflg::prelude::*;
use ndarray::Array1;

// Create coordinator
let config = CoordinatorConfig::default();
let coordinator = FederatedCoordinator::new(config);

// Register clients
let client = ClientInfo::new("client_1".to_string(), vec![0u8; 32]);
coordinator.register_client(client).unwrap();

// Byzantine detection on gradients (need 2f+3 clients for Krum)
let detector_config = DetectorConfig::new(3, 0.2);
let detector = KrumDetector::new(detector_config);

let gradients = vec![
    Array1::from_vec(vec![1.0, 1.0]),
    Array1::from_vec(vec![1.1, 0.9]),
    Array1::from_vec(vec![0.9, 1.1]),
    Array1::from_vec(vec![1.0, 1.0]),
    Array1::from_vec(vec![1.0, 1.0]),
    Array1::from_vec(vec![100.0, -100.0]), // Byzantine!
];

let (honest, byzantine) = detector.detect(&gradients).unwrap();
assert!(byzantine.len() >= 1);

Tier 2 Capability (Score 83)

This crate enables privacy-preserving distributed quantum machine learning as a Tier 2 capability in the RuVector ecosystem. Key features:

• Two-Week Test: Gradient aggregation compiles, Byzantine detection works
• Integration: Works with ruQu and other quantum components
• Performance: Designed for high-throughput federated scenarios

Feature Flags

• simd - SIMD acceleration for gradient operations
• wasm - WASM-compatible mode
• parallel - Multi-threaded aggregation
• tracing - Observability and metrics
• full - All features enabled (default)

Modules

• aggregation - Gradient aggregation algorithms (FedAvg, Secure, Momentum)
• byzantine - Byzantine detection (Krum, Multi-Krum, Trimmed Mean, Median)
• privacy - Differential privacy (Gaussian, Laplace, Budget tracking)
• protocol - Federated protocol (Registration, Rounds, Sync)
• quantum - Quantum features (QRNG, PQ signatures, Bell pairs)
• error - Error types

Re-exports

pub use error::AggregationError;

pub use error::ByzantineError;

pub use error::PrivacyError;

pub use error::ProtocolError;

pub use error::QflgError;

pub use error::QuantumError;

pub use error::Result;

pub use aggregation::AggregationStats;

pub use aggregation::AggregatorConfig;

pub use aggregation::GradientAggregator;

pub use aggregation::MomentumAggregator;

pub use aggregation::SecureAggregator;

pub use aggregation::WeightedAverageAggregator;

pub use aggregation::gradient_norm;

pub use aggregation::gradient_similarity;

pub use aggregation::pairwise_distances;

pub use byzantine::BulyanDetector;

pub use byzantine::ByzantineDetector;

pub use byzantine::ByzantineStats;

pub use byzantine::DetectionResult;

pub use byzantine::DetectorConfig;

pub use byzantine::KrumDetector;

pub use byzantine::MedianDetector;

pub use byzantine::MultiKrumDetector;

pub use byzantine::TrimmedMeanDetector;

pub use privacy::AdaptiveClipper;

pub use privacy::GaussianMechanism;

pub use privacy::GradientClipper;

pub use privacy::LaplaceMechanism;

pub use privacy::MomentsAccountant;

pub use privacy::PrivacyBudget;

pub use privacy::PrivacyConfig;

pub use privacy::PrivacyLoss;

pub use privacy::PrivacyMechanism;

pub use privacy::PrivacyStats;

pub use protocol::ClientConfig;

pub use protocol::ClientInfo;

pub use protocol::CoordinatorConfig;

pub use protocol::FederatedClient;

pub use protocol::FederatedCoordinator;

pub use protocol::GradientSubmission;

pub use protocol::ProtocolStats;

pub use protocol::RoundInfo;

pub use protocol::RoundState;

pub use quantum::BellPair;

pub use quantum::CoherenceMonitor;

pub use quantum::PostQuantumSignature;

pub use quantum::QKDSimulator;

pub use quantum::QuantumRng;

pub use quantum::QuantumState;

Modules

aggregation

Gradient Aggregation for Federated Learning

byzantine

Byzantine Detection for Federated Learning

error

Error types for ruqu-qflg

prelude

Prelude module for convenient imports Commonly used types for quantum federated learning.

privacy

Privacy Mechanisms for Federated Learning

protocol

Federated Learning Protocol

quantum

Quantum Enhancement Module

Constants

DEFAULT_BYZANTINE_FRACTION

Default Byzantine tolerance fraction

DEFAULT_PRIVACY_DELTA

Default privacy delta

DEFAULT_PRIVACY_EPSILON

Default privacy epsilon

NAME

Crate name

VERSION

Crate version