quantumflow-sdk 0.1.0__py3-none-any.whl

quantumflow/algorithms/cryptography/qkd.py

@@ -0,0 +1,205 @@
+"""
+Quantum Key Distribution (QKD).
+
+Implements BB84 protocol for secure key exchange.
+"""
+
+import secrets
+from dataclasses import dataclass
+from typing import Optional
+import numpy as np
+from qiskit import QuantumCircuit
+
+from quantumflow.backends.base_backend import QuantumBackend, get_backend, BackendType
+
+
+@dataclass
+class QKDResult:
+    """Result from QKD key generation."""
+
+    shared_key: str
+    key_length: int
+    raw_key_length: int
+    error_rate: float
+    is_secure: bool
+    alice_bases: str
+    bob_bases: str
+
+
+class QKD:
+    """
+    Quantum Key Distribution using BB84 Protocol.
+
+    Enables two parties (Alice and Bob) to generate a shared secret key
+    with information-theoretic security guaranteed by quantum mechanics.
+
+    Protocol:
+    1. Alice prepares qubits in random states (Z or X basis)
+    2. Bob measures in random bases
+    3. They compare bases publicly
+    4. Keep only matching-basis measurements
+    5. Check for eavesdropping via error rate
+
+    Example:
+        >>> qkd = QKD()
+        >>> result = qkd.generate_key(key_length=128)
+        >>> print(f"Shared key: {result.shared_key[:32]}...")
+        >>> print(f"Secure: {result.is_secure}")
+    """
+
+    def __init__(
+        self,
+        backend: BackendType | str = BackendType.AUTO,
+        error_threshold: float = 0.11,
+    ):
+        """
+        Initialize QKD.
+
+        Args:
+            backend: Quantum backend
+            error_threshold: Max tolerable error rate (11% for BB84)
+        """
+        self.backend = get_backend(backend)
+        self.error_threshold = error_threshold
+        self._connected = False
+
+    def _ensure_connected(self):
+        if not self._connected:
+            self.backend.connect()
+            self._connected = True
+
+    def generate_key(
+        self,
+        key_length: int = 256,
+        with_eavesdropper: bool = False,
+    ) -> QKDResult:
+        """
+        Generate a shared cryptographic key.
+
+        Args:
+            key_length: Desired final key length in bits
+            with_eavesdropper: Simulate eavesdropping (for testing)
+
+        Returns:
+            QKDResult with shared key
+        """
+        self._ensure_connected()
+
+        # Need ~4x raw bits due to basis mismatch and error correction
+        raw_length = key_length * 4
+
+        # Step 1: Alice generates random bits and bases
+        alice_bits = self._random_bits(raw_length)
+        alice_bases = self._random_bits(raw_length)  # 0=Z, 1=X
+
+        # Step 2: Alice prepares qubits
+        alice_states = self._prepare_states(alice_bits, alice_bases)
+
+        # Step 3: (Optional) Eve intercepts
+        if with_eavesdropper:
+            eve_bases = self._random_bits(raw_length)
+            alice_states = self._eavesdrop(alice_states, eve_bases)
+
+        # Step 4: Bob chooses random bases and measures
+        bob_bases = self._random_bits(raw_length)
+        bob_bits = self._measure_states(alice_states, bob_bases)
+
+        # Step 5: Sifting - keep only matching bases
+        sifted_alice = []
+        sifted_bob = []
+
+        for i in range(raw_length):
+            if alice_bases[i] == bob_bases[i]:
+                sifted_alice.append(alice_bits[i])
+                sifted_bob.append(bob_bits[i])
+
+        # Step 6: Error estimation (use subset)
+        check_length = min(len(sifted_alice) // 4, 50)
+        errors = sum(
+            sifted_alice[i] != sifted_bob[i]
+            for i in range(check_length)
+        )
+        error_rate = errors / check_length if check_length > 0 else 0
+
+        # Remove check bits
+        final_alice = sifted_alice[check_length:]
+        final_bob = sifted_bob[check_length:]
+
+        # Step 7: Check security
+        is_secure = error_rate < self.error_threshold
+
+        # Create key (truncate to desired length)
+        shared_key = ''.join(str(b) for b in final_alice[:key_length])
+
+        return QKDResult(
+            shared_key=shared_key,
+            key_length=len(shared_key),
+            raw_key_length=raw_length,
+            error_rate=error_rate,
+            is_secure=is_secure,
+            alice_bases=''.join(str(b) for b in alice_bases[:20]) + "...",
+            bob_bases=''.join(str(b) for b in bob_bases[:20]) + "...",
+        )
+
+    def _random_bits(self, n: int) -> list[int]:
+        """Generate n random bits."""
+        return [secrets.randbelow(2) for _ in range(n)]
+
+    def _prepare_states(
+        self,
+        bits: list[int],
+        bases: list[int],
+    ) -> list[tuple[int, int]]:
+        """Prepare quantum states based on bits and bases."""
+        return list(zip(bits, bases))
+
+    def _measure_states(
+        self,
+        states: list[tuple[int, int]],
+        bases: list[int],
+    ) -> list[int]:
+        """Measure states in given bases using quantum circuit."""
+        results = []
+
+        for (bit, prep_basis), meas_basis in zip(states, bases):
+            circuit = QuantumCircuit(1, 1)
+
+            # Prepare state
+            if bit == 1:
+                circuit.x(0)
+            if prep_basis == 1:  # X basis
+                circuit.h(0)
+
+            # Measure in basis
+            if meas_basis == 1:  # X basis
+                circuit.h(0)
+            circuit.measure(0, 0)
+
+            # Execute
+            result = self.backend.execute(circuit, shots=1)
+            measured = int(list(result.counts.keys())[0])
+            results.append(measured)
+
+        return results
+
+    def _eavesdrop(
+        self,
+        states: list[tuple[int, int]],
+        eve_bases: list[int],
+    ) -> list[tuple[int, int]]:
+        """Simulate eavesdropper (introduces errors)."""
+        disturbed = []
+
+        for (bit, basis), eve_basis in zip(states, eve_bases):
+            if eve_basis != basis:
+                # Eve's measurement disturbs state (50% chance of error)
+                if secrets.randbelow(2) == 0:
+                    bit = 1 - bit  # Flip bit
+            disturbed.append((bit, basis))
+
+        return disturbed
+
+
+class BB84(QKD):
+    """Alias for QKD (BB84 protocol)."""
+    pass

quantumflow/algorithms/cryptography/qrng.py

@@ -0,0 +1,231 @@
+"""
+Quantum Random Number Generator (QRNG).
+
+Generates true random numbers using quantum mechanics.
+"""
+
+from dataclasses import dataclass
+from typing import Optional
+import numpy as np
+from qiskit import QuantumCircuit
+
+from quantumflow.backends.base_backend import QuantumBackend, get_backend, BackendType
+
+
+@dataclass
+class QRNGResult:
+    """Result from quantum random number generation."""
+
+    bits: str
+    integer: int
+    float_value: float
+    n_qubits_used: int
+    entropy_bits: int
+
+
+class QRNG:
+    """
+    Quantum Random Number Generator.
+
+    Generates cryptographically secure random numbers using
+    quantum superposition and measurement.
+
+    Unlike classical PRNGs:
+    - Randomness is fundamental, not pseudo
+    - Information-theoretically unpredictable
+    - Certified by quantum mechanics
+
+    Example:
+        >>> qrng = QRNG()
+        >>> bits = qrng.random_bits(128)
+        >>> number = qrng.random_int(0, 1000)
+        >>> value = qrng.random_float()
+    """
+
+    def __init__(
+        self,
+        backend: BackendType | str = BackendType.AUTO,
+        max_qubits: int = 20,
+    ):
+        """
+        Initialize QRNG.
+
+        Args:
+            backend: Quantum backend
+            max_qubits: Maximum qubits per generation
+        """
+        self.backend = get_backend(backend)
+        self.max_qubits = max_qubits
+        self._connected = False
+        self._buffer: list[int] = []
+
+    def _ensure_connected(self):
+        if not self._connected:
+            self.backend.connect()
+            self._connected = True
+
+    def random_bits(self, n: int) -> str:
+        """
+        Generate n random bits.
+
+        Args:
+            n: Number of bits to generate
+
+        Returns:
+            String of '0' and '1' characters
+        """
+        self._ensure_connected()
+
+        bits = []
+
+        while len(bits) < n:
+            # Generate batch of bits
+            batch_size = min(self.max_qubits, n - len(bits))
+            batch = self._generate_batch(batch_size)
+            bits.extend(batch)
+
+        return ''.join(str(b) for b in bits[:n])
+
+    def random_int(self, min_val: int = 0, max_val: int = 2**32 - 1) -> int:
+        """
+        Generate random integer in range [min_val, max_val].
+
+        Args:
+            min_val: Minimum value (inclusive)
+            max_val: Maximum value (inclusive)
+
+        Returns:
+            Random integer
+        """
+        range_size = max_val - min_val + 1
+        bits_needed = int(np.ceil(np.log2(range_size))) + 1
+
+        # Rejection sampling to avoid bias
+        while True:
+            bits = self.random_bits(bits_needed)
+            value = int(bits, 2)
+            if value < range_size:
+                return min_val + value
+
+    def random_float(self) -> float:
+        """
+        Generate random float in [0, 1).
+
+        Returns:
+            Random float with 53 bits of precision
+        """
+        # IEEE 754 double has 53 bits of mantissa
+        bits = self.random_bits(53)
+        value = int(bits, 2)
+        return value / (2**53)
+
+    def random_bytes(self, n: int) -> bytes:
+        """
+        Generate n random bytes.
+
+        Args:
+            n: Number of bytes
+
+        Returns:
+            Random bytes
+        """
+        bits = self.random_bits(n * 8)
+        return int(bits, 2).to_bytes(n, byteorder='big')
+
+    def random_gaussian(self, mean: float = 0.0, std: float = 1.0) -> float:
+        """
+        Generate Gaussian distributed random number.
+
+        Uses Box-Muller transform.
+
+        Args:
+            mean: Mean of distribution
+            std: Standard deviation
+
+        Returns:
+            Gaussian random number
+        """
+        u1 = self.random_float()
+        u2 = self.random_float()
+
+        # Avoid log(0)
+        while u1 < 1e-10:
+            u1 = self.random_float()
+
+        # Box-Muller transform
+        z = np.sqrt(-2 * np.log(u1)) * np.cos(2 * np.pi * u2)
+
+        return mean + std * z
+
+    def random_choice(self, items: list) -> any:
+        """
+        Randomly select an item from list.
+
+        Args:
+            items: List to choose from
+
+        Returns:
+            Randomly selected item
+        """
+        if not items:
+            raise ValueError("Cannot choose from empty list")
+
+        idx = self.random_int(0, len(items) - 1)
+        return items[idx]
+
+    def random_shuffle(self, items: list) -> list:
+        """
+        Randomly shuffle a list.
+
+        Args:
+            items: List to shuffle
+
+        Returns:
+            Shuffled copy of list
+        """
+        result = items.copy()
+        n = len(result)
+
+        # Fisher-Yates shuffle
+        for i in range(n - 1, 0, -1):
+            j = self.random_int(0, i)
+            result[i], result[j] = result[j], result[i]
+
+        return result
+
+    def _generate_batch(self, n_qubits: int) -> list[int]:
+        """Generate batch of random bits using quantum circuit."""
+        circuit = QuantumCircuit(n_qubits, n_qubits)
+
+        # Put all qubits in superposition
+        circuit.h(range(n_qubits))
+
+        # Measure
+        circuit.measure(range(n_qubits), range(n_qubits))
+
+        # Execute with single shot
+        result = self.backend.execute(circuit, shots=1)
+
+        # Extract bits
+        bitstring = list(result.counts.keys())[0]
+        return [int(b) for b in bitstring]
+
+    def get_result(self, n_bits: int) -> QRNGResult:
+        """
+        Generate random bits with full result details.
+
+        Args:
+            n_bits: Number of bits
+
+        Returns:
+            QRNGResult with all details
+        """
+        bits = self.random_bits(n_bits)
+
+        return QRNGResult(
+            bits=bits,
+            integer=int(bits, 2) if bits else 0,
+            float_value=int(bits, 2) / (2**n_bits) if bits else 0.0,
+            n_qubits_used=min(self.max_qubits, n_bits),
+            entropy_bits=n_bits,
+        )

quantumflow/algorithms/machine_learning/__init__.py

@@ -0,0 +1,7 @@
+"""Machine Learning Algorithms."""
+
+from quantumflow.algorithms.machine_learning.vqe import VQE
+from quantumflow.algorithms.machine_learning.qsvm import QSVM
+from quantumflow.algorithms.machine_learning.qnn import QNN
+
+__all__ = ["VQE", "QSVM", "QNN"]

quantumflow/algorithms/machine_learning/qnn.py

@@ -0,0 +1,276 @@
+"""
+Quantum Neural Network (QNN).
+
+Parameterized quantum circuits for machine learning tasks.
+Integrates with Paper 2's quantum backpropagation.
+"""
+
+from dataclasses import dataclass
+from typing import Optional, Callable
+import numpy as np
+from qiskit import QuantumCircuit
+
+from quantumflow.backends.base_backend import QuantumBackend, get_backend, BackendType
+
+
+@dataclass
+class QNNResult:
+    """Result from QNN training."""
+
+    final_weights: np.ndarray
+    loss_history: list[float]
+    accuracy: float
+    n_epochs: int
+
+
+class QNN:
+    """
+    Quantum Neural Network.
+
+    A parameterized quantum circuit that can be trained for:
+    - Binary classification
+    - Multi-class classification
+    - Regression
+
+    Architecture:
+    - Input encoding layer (amplitude or angle encoding)
+    - Variational layers (parameterized rotations + entanglement)
+    - Measurement layer
+
+    Example:
+        >>> qnn = QNN(n_qubits=4, n_layers=3)
+        >>> result = qnn.fit(X_train, y_train, epochs=100)
+        >>> predictions = qnn.predict(X_test)
+    """
+
+    def __init__(
+        self,
+        n_qubits: int,
+        n_layers: int = 2,
+        backend: BackendType | str = BackendType.AUTO,
+        learning_rate: float = 0.1,
+        shots: int = 1024,
+    ):
+        """
+        Initialize QNN.
+
+        Args:
+            n_qubits: Number of qubits
+            n_layers: Number of variational layers
+            backend: Quantum backend
+            learning_rate: Learning rate for optimization
+            shots: Measurement shots
+        """
+        self.n_qubits = n_qubits
+        self.n_layers = n_layers
+        self.backend = get_backend(backend)
+        self.learning_rate = learning_rate
+        self.shots = shots
+        self._connected = False
+
+        # Initialize weights: 3 parameters per qubit per layer (rx, ry, rz)
+        self.n_params = n_qubits * n_layers * 3
+        self.weights = np.random.uniform(-np.pi, np.pi, self.n_params)
+
+    def _ensure_connected(self):
+        if not self._connected:
+            self.backend.connect()
+            self._connected = True
+
+    def fit(
+        self,
+        X: np.ndarray,
+        y: np.ndarray,
+        epochs: int = 100,
+        batch_size: int = 8,
+    ) -> QNNResult:
+        """
+        Train the QNN.
+
+        Args:
+            X: Training features (n_samples, n_features)
+            y: Training labels (n_samples,)
+            epochs: Number of training epochs
+            batch_size: Mini-batch size
+
+        Returns:
+            QNNResult with training history
+        """
+        self._ensure_connected()
+
+        loss_history = []
+
+        for epoch in range(epochs):
+            epoch_loss = 0.0
+
+            # Mini-batch training
+            indices = np.random.permutation(len(X))
+
+            for i in range(0, len(X), batch_size):
+                batch_idx = indices[i:i + batch_size]
+                X_batch = X[batch_idx]
+                y_batch = y[batch_idx]
+
+                # Forward pass and gradient computation
+                batch_loss, gradients = self._compute_batch_gradient(X_batch, y_batch)
+                epoch_loss += batch_loss
+
+                # Update weights
+                self.weights -= self.learning_rate * gradients
+
+            epoch_loss /= (len(X) / batch_size)
+            loss_history.append(epoch_loss)
+
+        # Compute final accuracy
+        predictions = self.predict(X)
+        accuracy = np.mean(predictions == y)
+
+        return QNNResult(
+            final_weights=self.weights.copy(),
+            loss_history=loss_history,
+            accuracy=accuracy,
+            n_epochs=epochs,
+        )
+
+    def predict(self, X: np.ndarray) -> np.ndarray:
+        """
+        Make predictions.
+
+        Args:
+            X: Input features (n_samples, n_features)
+
+        Returns:
+            Predicted labels
+        """
+        self._ensure_connected()
+
+        predictions = []
+
+        for x in X:
+            prob = self._forward(x)
+            predictions.append(1 if prob > 0.5 else 0)
+
+        return np.array(predictions)
+
+    def predict_proba(self, X: np.ndarray) -> np.ndarray:
+        """
+        Predict class probabilities.
+
+        Args:
+            X: Input features
+
+        Returns:
+            Probabilities for class 1
+        """
+        self._ensure_connected()
+
+        probs = []
+        for x in X:
+            prob = self._forward(x)
+            probs.append(prob)
+
+        return np.array(probs)
+
+    def _forward(self, x: np.ndarray) -> float:
+        """Forward pass for a single input."""
+        circuit = self._build_circuit(x, self.weights)
+        result = self.backend.execute(circuit, shots=self.shots)
+
+        # Probability of measuring |1⟩ on first qubit
+        ones_count = sum(
+            count for state, count in result.counts.items()
+            if state[-1] == '1'
+        )
+
+        return ones_count / self.shots
+
+    def _build_circuit(
+        self,
+        x: np.ndarray,
+        weights: np.ndarray,
+    ) -> QuantumCircuit:
+        """Build QNN circuit."""
+        circuit = QuantumCircuit(self.n_qubits, 1, name="qnn")
+
+        # Input encoding
+        self._encode_input(circuit, x)
+
+        # Variational layers
+        param_idx = 0
+        for layer in range(self.n_layers):
+            # Single qubit rotations
+            for i in range(self.n_qubits):
+                circuit.rx(weights[param_idx], i)
+                param_idx += 1
+                circuit.ry(weights[param_idx], i)
+                param_idx += 1
+                circuit.rz(weights[param_idx], i)
+                param_idx += 1
+
+            # Entangling layer (ring topology)
+            for i in range(self.n_qubits):
+                circuit.cx(i, (i + 1) % self.n_qubits)
+
+        # Measure first qubit
+        circuit.measure(0, 0)
+
+        return circuit
+
+    def _encode_input(self, circuit: QuantumCircuit, x: np.ndarray):
+        """Encode input features into quantum state."""
+        # Angle encoding: each feature -> rotation angle
+        for i in range(min(len(x), self.n_qubits)):
+            circuit.ry(x[i] * np.pi, i)
+
+        # Initialize unmapped qubits
+        for i in range(len(x), self.n_qubits):
+            circuit.h(i)
+
+    def _compute_batch_gradient(
+        self,
+        X_batch: np.ndarray,
+        y_batch: np.ndarray,
+    ) -> tuple[float, np.ndarray]:
+        """Compute gradient using parameter shift rule."""
+        batch_loss = 0.0
+        gradients = np.zeros_like(self.weights)
+        shift = np.pi / 2
+
+        for x, y in zip(X_batch, y_batch):
+            # Forward pass
+            pred = self._forward(x)
+            loss = (pred - y) ** 2
+            batch_loss += loss
+
+            # Parameter shift gradient
+            for i in range(len(self.weights)):
+                # Shift +
+                weights_plus = self.weights.copy()
+                weights_plus[i] += shift
+                circuit_plus = self._build_circuit(x, weights_plus)
+                result_plus = self.backend.execute(circuit_plus, shots=self.shots)
+                ones_plus = sum(
+                    c for s, c in result_plus.counts.items() if s[-1] == '1'
+                )
+                pred_plus = ones_plus / self.shots
+
+                # Shift -
+                weights_minus = self.weights.copy()
+                weights_minus[i] -= shift
+                circuit_minus = self._build_circuit(x, weights_minus)
+                result_minus = self.backend.execute(circuit_minus, shots=self.shots)
+                ones_minus = sum(
+                    c for s, c in result_minus.counts.items() if s[-1] == '1'
+                )
+                pred_minus = ones_minus / self.shots
+
+                # Gradient
+                d_pred = (pred_plus - pred_minus) / 2
+                d_loss = 2 * (pred - y) * d_pred
+                gradients[i] += d_loss
+
+        # Average over batch
+        batch_loss /= len(X_batch)
+        gradients /= len(X_batch)
+
+        return batch_loss, gradients