import torch
import torch.nn as nn
import numpy as np

class UncertaintyAwareSelector:
    def __init__(self, model, num_mc_samples=50, tau=0.1):
        self.model = model
        self.num_mc_samples = num_mc_samples
        self.tau = tau  # temperature for MC dropout

    def compute_uncertainty(self, x):
        """Compute epistemic and aleatoric uncertainty via MC dropout."""
        self.model.train()  # Enable dropout for MC sampling
        predictions = []

        with torch.no_grad():
            for _ in range(self.num_mc_samples):
                # Add temperature-scaled noise
                noisy_input = x + torch.randn_like(x) * self.tau
                pred = self.model(noisy_input)
                predictions.append(pred)

        predictions = torch.stack(predictions)

        # Epistemic uncertainty: variance across MC samples
        epistemic = predictions.var(dim=0)

        # Aleatoric uncertainty: mean of predictive entropies
        probs = torch.softmax(predictions, dim=-1)
        aleatoric = -(probs * torch.log(probs + 1e-10)).sum(dim=-1).mean(dim=0)

        return epistemic, aleatoric

    def select_samples(self, pool_loader, budget):
        """Select most informative samples for expert labeling."""
        scores = []
        samples = []

        for batch in pool_loader:
            x, idx = batch
            epi, ale = self.compute_uncertainty(x)

            # Balanced scoring: combine both uncertainties
            # Weight epistemic more heavily for rare mutations
            combined_score = 0.7 * epi.mean(dim=1) + 0.3 * ale.mean(dim=1)
            scores.extend(combined_score.tolist())
            samples.extend(idx.tolist())

        # Select top-k by score
        selected = np.argsort(scores)[-budget:]
        return [samples[i] for i in selected]

from phe import paillier  # Python Paillier homomorphic encryption
import numpy as np
import hashlib
from typing import List, Dict

class ZeroTrustGradientAggregator:
    def __init__(self, public_key, private_key, min_participants=3):
        self.pub_key = public_key
        self.priv_key = private_key
        self.min_participants = min_participants
        self.encrypted_updates = {}

    def verify_participant(self, participant_id, signed_commitment):
        """Zero-trust verification: verify identity and integrity."""
        # Verify digital signature
        expected_hash = hashlib.sha256(
            f"{participant_id}:{signed_commitment['timestamp']}".encode()
        ).hexdigest()

        if not self.verify_signature(signed_commitment, expected_hash):
            raise SecurityException("Invalid participant signature")

        # Check commitment matches
        if signed_commitment['commitment'] != expected_hash:
            raise SecurityException("Commitment mismatch")

        return True

    def aggregate_encrypted_updates(self, updates: List[Dict]):
        """Aggregate encrypted gradients without decryption."""
        if len(updates) < self.min_participants:
            raise SecurityException("Insufficient participants")

        # Initialize encrypted accumulator with first update
        acc = {k: updates[0]['encrypted_grad'][k]
               for k in updates[0]['encrypted_grad']}

        # Homomorphic addition of all updates
        for update in updates[1:]:
            for param_name, enc_value in update['encrypted_grad'].items():
                acc[param_name] += enc_value  # Homomorphic add

        # Decrypt only the aggregated result
        decrypted = {
            k: self.priv_key.decrypt(v)
            for k, v in acc.items()
        }

        return decrypted

    def verify_gradient_norms(self, encrypted_grads, threshold=4.0):
        """Detect anomalous updates before aggregation."""
        # We can compute encrypted norms using homomorphic properties
        # This requires some clever encoding of the norm computation
        encrypted_norms = []
        for grad in encrypted_grads:
            # Square each component and sum (homomorphic)
            squared_sum = sum(g**2 for g in grad.values())
            encrypted_norms.append(squared_sum)

        # Decrypt norms for verification
        norms = [self.priv_key.decrypt(n) for n in encrypted_norms]
        mean_norm = np.mean(norms)
        std_norm = np.std(norms)

        # Flag outliers (potential poisoning attacks)
        flags = []
        for i, norm in enumerate(norms):
            z_score = (norm - mean_norm) / (std_norm + 1e-8)
            flags.append(abs(z_score) < threshold)

        return flags

import numpy as np
from scipy.special import softmax

class AdaptivePrivacyScheduler:
    def __init__(self, total_epsilon=10.0, delta=1e-5, decay_rate=0.95):
        self.total_epsilon = total_epsilon
        self.delta = delta
        self.remaining_epsilon = total_epsilon
        self.decay_rate = decay_rate
        self.used_epsilon = []

    def compute_privacy_budget(self, uncertainty, sensitivity, num_samples):
        """
        Allocate privacy budget based on sample informativeness.

        Args:
            uncertainty: epistemic uncertainty (0 to 1)
            sensitivity: gradient sensitivity (L2 norm bound)
            num_samples: number of samples in this round
        """
        # Normalize uncertainty to [0, 1]
        normalized_uncertainty = np.clip(uncertainty, 0, 1)

        # High uncertainty samples get more budget (they're more informative)
        base_budget = self.remaining_epsilon / num_samples
        budget_multiplier = 0.5 + normalized_uncertainty

        # Apply exponential decay to control total consumption
        decay_factor = self.decay_rate ** len(self.used_epsilon)

        # Calculate per-sample epsilon
        sample_epsilon = base_budget * budget_multiplier * decay_factor

        # Ensure we don't exceed remaining budget
        total_requested = sample_epsilon * num_samples
        if total_requested > self.remaining_epsilon:
            scale_factor = self.remaining_epsilon / total_requested
            sample_epsilon *= scale_factor

        return sample_epsilon

    def update_budget(self, used_epsilon):
        """Update remaining budget after training round."""
        self.remaining_epsilon -= used_epsilon
        self.used_epsilon.append(used_epsilon)

        if self.remaining_epsilon < 0:
            raise PrivacyBudgetExhausted(
                f"Privacy budget exhausted: {self.remaining_epsilon}"
            )

        return self.remaining_epsilon

class ByzantineResilientAggregator:
    def __init__(self, reputation_scores, clip_threshold=1.0):
        self.reputation = reputation_scores
        self.clip_threshold = clip_threshold

    def clip_encrypted_gradients(self, encrypted_grad):
        """Clip gradients in encrypted domain to bound sensitivity."""
        # Compute L2 norm in encrypted domain
        # This uses the square-root property of homomorphic encryption
        encrypted_norm_sq = sum(g**2 for g in encrypted_grad.values())

        # We can't compute sqrt homomorphically, so we use a trick:
        # Clip by scaling factor = min(1, clip_threshold / norm)
        # This requires a secure comparison protocol
        scale_factor = self.secure_clip_factor(encrypted_norm_sq)

        # Apply scaling to all components
        clipped_grad = {
            k: v * scale_factor for k, v in encrypted_grad.items()
        }

        return clipped_grad

    def secure_clip_factor(self, encrypted_norm_sq):
        """Use SMPC to compute clipping factor without revealing norm."""
        # In practice, this uses a garbled circuit or secret sharing
        # Simplified version for illustration
        decrypted_norm = self.priv_key.decrypt(encrypted_norm_sq)
        norm = np.sqrt(decrypted_norm)

        if norm > self.clip_threshold:
            return self.clip_threshold / norm
        return 1.0

    def weighted_aggregation(self, updates, weights):
        """Weight updates by reputation to reduce Byzantine impact."""
        weighted_sum = {}
        total_weight = sum(weights.values())

        for participant_id, update in updates.items():
            weight = self.reputation[participant_id] / total_weight
            for param_name, value in update.items():
                if param_name not in weighted_sum:
                    weighted_sum[param_name] = value * weight
                else:
                    weighted_sum[param_name] += value * weight

        return weighted_sum

class PrivacyPreservingOncologySystem:
    def __init__(self, config):
        self.selector = UncertaintyAwareSelector(config['model'])
        self.aggregator = ZeroTrustGradientAggregator(
            config['public_key'],
            config['private_key']
        )
        self.privacy_scheduler = AdaptivePrivacyScheduler(
            total_epsilon=config['privacy_budget']
        )
        self.byzantine_resilient = ByzantineResilientAggregator(
            config['reputation_scores']
        )

    def active_learning_round(self, hospital_clients, unlabeled_pool):
        """
        Execute one round of privacy-preserving active learning.
        """
        # Phase 1: Uncertainty-based sample selection
        selected_samples = []
        for client in hospital_clients:
            # Each client computes uncertainty on their local data
            local_uncertainty = client.compute_local_uncertainty(
                unlabeled_pool[client.data_indices]
            )

            # Select top samples from each client
            client_selected = self.selector.select_samples(
                local_uncertainty,
                budget=config['per_client_budget']
            )
            selected_samples.extend(client_selected)

        # Phase 2: Privacy-aware training
        encrypted_updates = []
        for client in hospital_clients:
            # Compute privacy budget for this client's samples
            sample_epsilon = self.privacy_scheduler.compute_privacy_budget(
                uncertainty=client.get_uncertainty(selected_samples),
                sensitivity=client.compute_gradient_sensitivity(),
                num_samples=len(selected_samples)
            )

            # Train locally with differential privacy
            local_model = client.train_local_model(
                selected_samples,
                epsilon=sample_epsilon,
                delta=self.delta
            )

            # Encrypt gradients for zero-trust transmission
            encrypted_grad = self.encrypt_gradients(
                local_model.get_gradients()
            )

            # Verify and add to aggregation pool
            if self.aggregator.verify_participant(
                client.id,
                client.get_signed_commitment(encrypted_grad)
            ):
                encrypted_updates.append({
                    'participant': client.id,
                    'encrypted_grad': encrypted_grad
                })

        # Phase 3: Secure aggregation
        # First, clip gradients to bound sensitivity
        clipped_updates = [
            self.byzantine_resilient.clip_encrypted_gradients(
                update['encrypted_grad']
            ) for update in encrypted_updates
        ]

        # Check for anomalies
        flags = self.aggregator.verify_gradient_norms(clipped_updates)
        valid_updates = [
            u for u, f in zip(clipped_updates, flags) if f
        ]

        # Aggregate valid updates
        aggregated_grad = self.aggregator.aggregate_encrypted_updates(
            valid_updates
        )

        # Update global model
        self.global_model.update(aggregated_grad)

        # Update privacy budget
        self.privacy_scheduler.update_budget(
            sum(u['epsilon_used'] for u in encrypted_updates)
        )

        return {
            'selected_samples': selected_samples,
            'privacy_remaining': self.privacy_scheduler.remaining_epsilon,
            'model_accuracy': self.evaluate_model(),
            'anomaly_flags': flags
        }

python
# Conceptual example - quantum-enhanced secure aggregation
class QuantumEnhancedAggregator:
    def __init__(self, num_qubits=8):
        self.num_qubits = num_qubits
        self.entanglement_pairs = {}

    def establish_quantum_channel(self, institution_a, institution_b):
        """
        Establish EPR pairs for secure communication.
        In