quantumflow-sdk 0.1.0__py3-none-any.whl

quantumflow/algorithms/compression/amplitude_amplification.py

@@ -0,0 +1,189 @@
+"""
+Amplitude Amplification Algorithm.
+
+Generalization of Grover's algorithm for amplifying the probability
+of marked states. Used in compression for selective retrieval.
+"""
+
+import math
+from dataclasses import dataclass
+from typing import Callable, Optional
+import numpy as np
+from qiskit import QuantumCircuit
+
+from quantumflow.backends.base_backend import QuantumBackend, get_backend, BackendType
+
+
+@dataclass
+class AmplificationResult:
+    """Result from amplitude amplification."""
+
+    circuit: QuantumCircuit
+    n_qubits: int
+    iterations: int
+    target_probability: float
+    amplified_probability: float
+
+
+class AmplitudeAmplification:
+    """
+    Quantum Amplitude Amplification.
+
+    Amplifies the amplitude of marked states, increasing their
+    measurement probability from ~1/N to near certainty.
+
+    Applications:
+    - Selective token retrieval from compressed state
+    - Search optimization
+    - Probability boosting
+
+    Example:
+        >>> aa = AmplitudeAmplification()
+        >>> result = aa.amplify(initial_circuit, oracle, n_qubits=4)
+        >>> print(f"Amplified probability: {result.amplified_probability:.2%}")
+    """
+
+    def __init__(self, backend: BackendType | str = BackendType.AUTO):
+        self.backend = get_backend(backend)
+
+    def amplify(
+        self,
+        initial_state: QuantumCircuit,
+        oracle: QuantumCircuit,
+        n_qubits: int,
+        iterations: Optional[int] = None,
+        target_count: int = 1,
+    ) -> AmplificationResult:
+        """
+        Apply amplitude amplification.
+
+        Args:
+            initial_state: Circuit preparing initial superposition
+            oracle: Oracle marking target states (applies phase flip)
+            n_qubits: Number of qubits
+            iterations: Grover iterations (optimal if None)
+            target_count: Number of marked states
+
+        Returns:
+            AmplificationResult with amplified circuit
+        """
+        N = 2 ** n_qubits
+
+        # Calculate optimal iterations
+        if iterations is None:
+            if target_count > 0:
+                theta = math.asin(math.sqrt(target_count / N))
+                iterations = max(1, int(round(math.pi / (4 * theta) - 0.5)))
+            else:
+                iterations = 1
+
+        # Initial probability
+        initial_prob = target_count / N
+
+        # Build amplification circuit
+        circuit = self._build_circuit(
+            initial_state, oracle, n_qubits, iterations
+        )
+
+        # Calculate amplified probability
+        theta = math.asin(math.sqrt(target_count / N))
+        amplified_prob = math.sin((2 * iterations + 1) * theta) ** 2
+
+        return AmplificationResult(
+            circuit=circuit,
+            n_qubits=n_qubits,
+            iterations=iterations,
+            target_probability=initial_prob,
+            amplified_probability=amplified_prob,
+        )
+
+    def create_oracle(
+        self,
+        n_qubits: int,
+        marked_states: list[int],
+    ) -> QuantumCircuit:
+        """
+        Create an oracle that marks specified states.
+
+        Args:
+            n_qubits: Number of qubits
+            marked_states: List of state indices to mark
+
+        Returns:
+            Oracle circuit applying phase flip to marked states
+        """
+        oracle = QuantumCircuit(n_qubits, name="oracle")
+
+        for state in marked_states:
+            # Convert state to binary and apply X gates for 0s
+            binary = format(state, f'0{n_qubits}b')
+
+            # Apply X to qubits that should be |0⟩
+            for i, bit in enumerate(reversed(binary)):
+                if bit == '0':
+                    oracle.x(i)
+
+            # Multi-controlled Z
+            if n_qubits == 1:
+                oracle.z(0)
+            elif n_qubits == 2:
+                oracle.cz(0, 1)
+            else:
+                oracle.h(n_qubits - 1)
+                oracle.mcx(list(range(n_qubits - 1)), n_qubits - 1)
+                oracle.h(n_qubits - 1)
+
+            # Undo X gates
+            for i, bit in enumerate(reversed(binary)):
+                if bit == '0':
+                    oracle.x(i)
+
+        return oracle
+
+    def _build_circuit(
+        self,
+        initial_state: QuantumCircuit,
+        oracle: QuantumCircuit,
+        n_qubits: int,
+        iterations: int,
+    ) -> QuantumCircuit:
+        """Build the full amplitude amplification circuit."""
+        circuit = QuantumCircuit(n_qubits, name="amplitude_amp")
+
+        # Apply initial state preparation
+        circuit.compose(initial_state, inplace=True)
+
+        # Grover iterations
+        diffuser = self._create_diffuser(n_qubits)
+
+        for _ in range(iterations):
+            # Oracle
+            circuit.compose(oracle, inplace=True)
+            # Diffuser
+            circuit.compose(diffuser, inplace=True)
+
+        return circuit
+
+    def _create_diffuser(self, n_qubits: int) -> QuantumCircuit:
+        """Create the Grover diffusion operator."""
+        diffuser = QuantumCircuit(n_qubits, name="diffuser")
+
+        # H gates
+        diffuser.h(range(n_qubits))
+
+        # X gates
+        diffuser.x(range(n_qubits))
+
+        # Multi-controlled Z
+        diffuser.h(n_qubits - 1)
+        if n_qubits > 1:
+            diffuser.mcx(list(range(n_qubits - 1)), n_qubits - 1)
+        diffuser.h(n_qubits - 1)
+
+        # X gates
+        diffuser.x(range(n_qubits))
+
+        # H gates
+        diffuser.h(range(n_qubits))
+
+        return diffuser

quantumflow/algorithms/compression/qft_compression.py

@@ -0,0 +1,133 @@
+"""
+Quantum Fourier Transform Compression.
+
+Uses QFT for frequency-domain compression of token sequences,
+similar to classical DCT/FFT compression but with quantum speedup.
+"""
+
+import math
+from dataclasses import dataclass
+from typing import Optional
+import numpy as np
+from qiskit import QuantumCircuit
+from qiskit.circuit.library import QFT
+
+from quantumflow.backends.base_backend import QuantumBackend, get_backend, BackendType
+
+
+@dataclass
+class QFTResult:
+    """Result from QFT compression."""
+
+    circuit: QuantumCircuit
+    n_qubits: int
+    kept_coefficients: int
+    total_coefficients: int
+    compression_ratio: float
+
+
+class QFTCompression:
+    """
+    Quantum Fourier Transform based compression.
+
+    Compresses data by:
+    1. Encoding data as quantum amplitudes
+    2. Applying QFT to transform to frequency domain
+    3. Truncating high-frequency components
+    4. Storing only significant coefficients
+
+    Best for: Periodic or smoothly varying data.
+
+    Example:
+        >>> qft = QFTCompression()
+        >>> result = qft.compress([100, 110, 105, 115, 100, 108])
+        >>> print(f"Kept {result.kept_coefficients}/{result.total_coefficients}")
+    """
+
+    def __init__(
+        self,
+        backend: BackendType | str = BackendType.AUTO,
+        keep_ratio: float = 0.5,
+    ):
+        """
+        Initialize QFT compression.
+
+        Args:
+            backend: Quantum backend to use
+            keep_ratio: Fraction of frequency components to keep (0.0-1.0)
+        """
+        self.backend = get_backend(backend)
+        self.keep_ratio = keep_ratio
+
+    def compress(
+        self,
+        data: list[float],
+        n_qubits: Optional[int] = None,
+    ) -> QFTResult:
+        """
+        Compress data using QFT.
+
+        Args:
+            data: Input data to compress
+            n_qubits: Number of qubits (auto if None)
+
+        Returns:
+            QFTResult with circuit and metadata
+        """
+        if not data:
+            raise ValueError("Cannot compress empty data")
+
+        # Calculate qubits needed
+        if n_qubits is None:
+            n_qubits = max(2, math.ceil(math.log2(len(data))))
+
+        target_size = 2 ** n_qubits
+
+        # Normalize data to amplitudes
+        data_arr = np.array(data, dtype=float)
+        data_arr = np.pad(data_arr, (0, max(0, target_size - len(data_arr))))
+        data_arr = data_arr[:target_size]
+
+        norm = np.linalg.norm(data_arr)
+        if norm > 0:
+            amplitudes = data_arr / norm
+        else:
+            amplitudes = np.ones(target_size) / np.sqrt(target_size)
+
+        # Build circuit
+        circuit = self._build_qft_circuit(amplitudes, n_qubits)
+
+        kept = int(target_size * self.keep_ratio)
+        ratio = target_size / max(kept, 1)
+
+        return QFTResult(
+            circuit=circuit,
+            n_qubits=n_qubits,
+            kept_coefficients=kept,
+            total_coefficients=target_size,
+            compression_ratio=ratio,
+        )
+
+    def _build_qft_circuit(
+        self,
+        amplitudes: np.ndarray,
+        n_qubits: int,
+    ) -> QuantumCircuit:
+        """Build QFT compression circuit."""
+        qc = QuantumCircuit(n_qubits, name="qft_compress")
+
+        # Initialize with data
+        qc.initialize(amplitudes, range(n_qubits))
+
+        # Apply QFT
+        qft = QFT(n_qubits, do_swaps=True)
+        qc.append(qft, range(n_qubits))
+
+        return qc
+
+    def inverse_qft_circuit(self, n_qubits: int) -> QuantumCircuit:
+        """Get inverse QFT circuit for decompression."""
+        qc = QuantumCircuit(n_qubits, name="iqft")
+        qft_inv = QFT(n_qubits, do_swaps=True, inverse=True)
+        qc.append(qft_inv, range(n_qubits))
+        return qc

quantumflow/algorithms/compression/token_compression.py

@@ -0,0 +1,261 @@
+"""
+Token Compression Algorithm.
+
+Enhanced version of Paper 1 compression with additional features:
+- Adaptive qubit allocation
+- Batch compression
+- Streaming support
+"""
+
+import math
+from dataclasses import dataclass
+from typing import Optional, Iterator
+import numpy as np
+from qiskit import QuantumCircuit
+
+from quantumflow.backends.base_backend import QuantumBackend, get_backend, BackendType
+
+
+@dataclass
+class CompressionConfig:
+    """Configuration for token compression."""
+
+    min_compression_ratio: float = 1.5
+    max_qubits: int = 20
+    adaptive: bool = True
+    error_mitigation: bool = False
+
+
+@dataclass
+class CompressedBatch:
+    """A batch of compressed tokens."""
+
+    circuit: QuantumCircuit
+    original_size: int
+    compressed_size: int
+    batch_index: int
+    amplitudes: np.ndarray
+
+
+class TokenCompression:
+    """
+    Advanced token compression using quantum amplitude encoding.
+
+    Features:
+    - Adaptive qubit allocation based on token distribution
+    - Batch processing for large token sequences
+    - Streaming compression for real-time applications
+
+    Example:
+        >>> tc = TokenCompression()
+        >>> result = tc.compress([100, 200, 300, 400])
+        >>> print(f"Ratio: {result.compression_ratio}x")
+    """
+
+    def __init__(
+        self,
+        backend: BackendType | str = BackendType.AUTO,
+        config: Optional[CompressionConfig] = None,
+    ):
+        self.backend = get_backend(backend)
+        self.config = config or CompressionConfig()
+        self._connected = False
+
+    def _ensure_connected(self):
+        if not self._connected:
+            self.backend.connect()
+            self._connected = True
+
+    def compress(
+        self,
+        tokens: list[int],
+        n_qubits: Optional[int] = None,
+    ) -> CompressedBatch:
+        """
+        Compress a list of tokens.
+
+        Args:
+            tokens: Integer tokens to compress
+            n_qubits: Override automatic qubit calculation
+
+        Returns:
+            CompressedBatch with circuit and metadata
+        """
+        if not tokens:
+            raise ValueError("Cannot compress empty token list")
+
+        # Calculate optimal qubits
+        if n_qubits is None:
+            n_qubits = self._calculate_qubits(tokens)
+
+        n_qubits = min(n_qubits, self.config.max_qubits)
+
+        # Normalize to amplitudes
+        amplitudes = self._tokens_to_amplitudes(tokens, n_qubits)
+
+        # Build circuit
+        circuit = self._build_circuit(amplitudes, n_qubits)
+
+        return CompressedBatch(
+            circuit=circuit,
+            original_size=len(tokens),
+            compressed_size=n_qubits,
+            batch_index=0,
+            amplitudes=amplitudes,
+        )
+
+    def compress_batch(
+        self,
+        tokens: list[int],
+        batch_size: int = 256,
+    ) -> list[CompressedBatch]:
+        """
+        Compress tokens in batches.
+
+        Args:
+            tokens: All tokens to compress
+            batch_size: Max tokens per batch (must be power of 2)
+
+        Returns:
+            List of CompressedBatch objects
+        """
+        # Ensure batch_size is power of 2
+        batch_size = 2 ** int(math.log2(batch_size))
+
+        batches = []
+        for i in range(0, len(tokens), batch_size):
+            batch_tokens = tokens[i:i + batch_size]
+            batch = self.compress(batch_tokens)
+            batch.batch_index = i // batch_size
+            batches.append(batch)
+
+        return batches
+
+    def compress_stream(
+        self,
+        token_iterator: Iterator[int],
+        buffer_size: int = 64,
+    ) -> Iterator[CompressedBatch]:
+        """
+        Stream compress tokens as they arrive.
+
+        Args:
+            token_iterator: Iterator yielding tokens
+            buffer_size: Tokens to buffer before compression
+
+        Yields:
+            CompressedBatch objects
+        """
+        buffer = []
+        batch_idx = 0
+
+        for token in token_iterator:
+            buffer.append(token)
+
+            if len(buffer) >= buffer_size:
+                batch = self.compress(buffer)
+                batch.batch_index = batch_idx
+                yield batch
+                buffer = []
+                batch_idx += 1
+
+        # Final batch
+        if buffer:
+            batch = self.compress(buffer)
+            batch.batch_index = batch_idx
+            yield batch
+
+    def decompress(
+        self,
+        batch: CompressedBatch,
+        shots: int = 1024,
+    ) -> list[int]:
+        """
+        Decompress a batch back to tokens.
+
+        Args:
+            batch: CompressedBatch to decompress
+            shots: Measurement shots for reconstruction
+
+        Returns:
+            Reconstructed token list
+        """
+        self._ensure_connected()
+
+        result = self.backend.execute(batch.circuit, shots=shots)
+
+        # Reconstruct from statevector if available
+        if result.statevector is not None:
+            probs = np.abs(result.statevector) ** 2
+        else:
+            # Reconstruct from measurement counts
+            probs = np.zeros(2 ** batch.compressed_size)
+            for state, count in result.counts.items():
+                idx = int(state, 2)
+                probs[idx] = count / shots
+
+        # Scale back to token range
+        # This is approximate - exact reconstruction requires statevector
+        max_prob = np.max(probs)
+        if max_prob > 0:
+            tokens = (probs[:batch.original_size] / max_prob * 255).astype(int)
+        else:
+            tokens = np.zeros(batch.original_size, dtype=int)
+
+        return tokens.tolist()
+
+    def _calculate_qubits(self, tokens: list[int]) -> int:
+        """Calculate optimal qubit count based on token distribution."""
+        n = len(tokens)
+        base_qubits = max(1, math.ceil(math.log2(n)))
+
+        if self.config.adaptive:
+            # Analyze token distribution
+            tokens_arr = np.array(tokens)
+            variance = np.var(tokens_arr)
+
+            # High variance = need more precision = more qubits
+            if variance > 1000:
+                base_qubits += 1
+
+        return base_qubits
+
+    def _tokens_to_amplitudes(
+        self,
+        tokens: list[int],
+        n_qubits: int,
+    ) -> np.ndarray:
+        """Convert tokens to normalized quantum amplitudes."""
+        target_size = 2 ** n_qubits
+
+        tokens_arr = np.array(tokens, dtype=float)
+        tokens_arr = np.maximum(tokens_arr, 1e-10)
+
+        # Pad to target size
+        if len(tokens_arr) < target_size:
+            tokens_arr = np.pad(
+                tokens_arr,
+                (0, target_size - len(tokens_arr)),
+                constant_values=1e-10
+            )
+        else:
+            tokens_arr = tokens_arr[:target_size]
+
+        # Normalize
+        norm = np.linalg.norm(tokens_arr)
+        return tokens_arr / norm if norm > 0 else tokens_arr
+
+    def _build_circuit(
+        self,
+        amplitudes: np.ndarray,
+        n_qubits: int,
+    ) -> QuantumCircuit:
+        """Build quantum circuit for amplitude encoding."""
+        qc = QuantumCircuit(n_qubits, name="token_compress")
+        qc.initialize(amplitudes, range(n_qubits))
+        return qc
+
+    @property
+    def compression_ratio(self) -> float:
+        """Expected compression ratio based on config."""
+        return self.config.min_compression_ratio

quantumflow/algorithms/cryptography/__init__.py

@@ -0,0 +1,6 @@
+"""Cryptography Algorithms."""
+
+from quantumflow.algorithms.cryptography.qkd import QKD
+from quantumflow.algorithms.cryptography.qrng import QRNG
+
+__all__ = ["QKD", "QRNG"]