quantumflow-sdk 0.1.0__py3-none-any.whl

quantumflow/algorithms/machine_learning/qsvm.py

@@ -0,0 +1,249 @@
+"""
+Quantum Support Vector Machine (QSVM).
+
+Uses quantum feature maps for kernel-based classification.
+"""
+
+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 QSVMResult:
+    """Result from QSVM classification."""
+
+    predictions: np.ndarray
+    kernel_matrix: Optional[np.ndarray]
+    support_vectors: Optional[np.ndarray]
+    accuracy: float
+
+
+class QSVM:
+    """
+    Quantum Support Vector Machine.
+
+    Uses quantum circuits as feature maps to compute kernel values,
+    enabling classification in high-dimensional Hilbert space.
+
+    Feature maps:
+    - ZZ Feature Map: Entangling features with ZZ gates
+    - Pauli Feature Map: General Pauli rotations
+    - Amplitude Encoding: Direct amplitude encoding
+
+    Example:
+        >>> qsvm = QSVM(n_features=2)
+        >>> qsvm.fit(X_train, y_train)
+        >>> predictions = qsvm.predict(X_test)
+    """
+
+    def __init__(
+        self,
+        n_features: int,
+        backend: BackendType | str = BackendType.AUTO,
+        feature_map: str = "zz",
+        reps: int = 2,
+        shots: int = 1024,
+    ):
+        """
+        Initialize QSVM.
+
+        Args:
+            n_features: Number of input features
+            backend: Quantum backend
+            feature_map: Type of feature map ('zz', 'pauli', 'amplitude')
+            reps: Number of feature map repetitions
+            shots: Measurement shots for kernel estimation
+        """
+        self.n_features = n_features
+        self.n_qubits = n_features
+        self.backend = get_backend(backend)
+        self.feature_map_type = feature_map
+        self.reps = reps
+        self.shots = shots
+        self._connected = False
+
+        # Training data
+        self.X_train: Optional[np.ndarray] = None
+        self.y_train: Optional[np.ndarray] = None
+        self.alphas: Optional[np.ndarray] = None
+        self.kernel_matrix: Optional[np.ndarray] = None
+
+    def _ensure_connected(self):
+        if not self._connected:
+            self.backend.connect()
+            self._connected = True
+
+    def fit(self, X: np.ndarray, y: np.ndarray) -> 'QSVM':
+        """
+        Fit the QSVM classifier.
+
+        Args:
+            X: Training features (n_samples, n_features)
+            y: Training labels (n_samples,) with values in {-1, 1}
+
+        Returns:
+            self
+        """
+        self._ensure_connected()
+
+        self.X_train = X
+        self.y_train = y
+
+        # Compute kernel matrix
+        n_samples = len(X)
+        self.kernel_matrix = np.zeros((n_samples, n_samples))
+
+        for i in range(n_samples):
+            for j in range(i, n_samples):
+                k = self._compute_kernel(X[i], X[j])
+                self.kernel_matrix[i, j] = k
+                self.kernel_matrix[j, i] = k
+
+        # Solve dual SVM problem (simplified)
+        self.alphas = self._solve_dual(self.kernel_matrix, y)
+
+        return self
+
+    def predict(self, X: np.ndarray) -> np.ndarray:
+        """
+        Predict class labels.
+
+        Args:
+            X: Test features (n_samples, n_features)
+
+        Returns:
+            Predicted labels
+        """
+        if self.X_train is None:
+            raise ValueError("Model not fitted. Call fit() first.")
+
+        self._ensure_connected()
+
+        predictions = []
+
+        for x in X:
+            # Compute kernel with all training points
+            decision = 0.0
+            for i, (x_train, y_train, alpha) in enumerate(
+                zip(self.X_train, self.y_train, self.alphas)
+            ):
+                if alpha > 1e-6:  # Support vector
+                    k = self._compute_kernel(x, x_train)
+                    decision += alpha * y_train * k
+
+            predictions.append(1 if decision >= 0 else -1)
+
+        return np.array(predictions)
+
+    def score(self, X: np.ndarray, y: np.ndarray) -> float:
+        """Compute classification accuracy."""
+        predictions = self.predict(X)
+        return np.mean(predictions == y)
+
+    def _compute_kernel(self, x1: np.ndarray, x2: np.ndarray) -> float:
+        """Compute quantum kernel between two data points."""
+        # Build circuit: U(x1)† U(x2)
+        circuit = QuantumCircuit(self.n_qubits, self.n_qubits)
+
+        # Apply feature map for x2
+        self._apply_feature_map(circuit, x2)
+
+        # Apply inverse feature map for x1
+        self._apply_feature_map_inverse(circuit, x1)
+
+        # Measure
+        circuit.measure(range(self.n_qubits), range(self.n_qubits))
+
+        # Execute
+        result = self.backend.execute(circuit, shots=self.shots)
+
+        # Kernel = probability of measuring |0...0⟩
+        zero_state = '0' * self.n_qubits
+        zero_count = result.counts.get(zero_state, 0)
+
+        return zero_count / self.shots
+
+    def _apply_feature_map(self, circuit: QuantumCircuit, x: np.ndarray):
+        """Apply feature map encoding data point x."""
+        for rep in range(self.reps):
+            # Hadamard layer
+            circuit.h(range(self.n_qubits))
+
+            # Feature encoding
+            if self.feature_map_type == "zz":
+                self._zz_feature_map(circuit, x)
+            elif self.feature_map_type == "pauli":
+                self._pauli_feature_map(circuit, x)
+            else:
+                self._amplitude_feature_map(circuit, x)
+
+    def _apply_feature_map_inverse(self, circuit: QuantumCircuit, x: np.ndarray):
+        """Apply inverse feature map."""
+        for rep in range(self.reps - 1, -1, -1):
+            # Inverse feature encoding
+            if self.feature_map_type == "zz":
+                self._zz_feature_map(circuit, -x)
+            elif self.feature_map_type == "pauli":
+                self._pauli_feature_map(circuit, -x)
+            else:
+                self._amplitude_feature_map(circuit, -x)
+
+            # Hadamard layer
+            circuit.h(range(self.n_qubits))
+
+    def _zz_feature_map(self, circuit: QuantumCircuit, x: np.ndarray):
+        """ZZ feature map."""
+        # Single qubit rotations
+        for i in range(min(len(x), self.n_qubits)):
+            circuit.rz(2 * x[i], i)
+
+        # Two-qubit ZZ interactions
+        for i in range(self.n_qubits - 1):
+            j = i + 1
+            if i < len(x) and j < len(x):
+                circuit.cx(i, j)
+                circuit.rz(2 * (np.pi - x[i]) * (np.pi - x[j]), j)
+                circuit.cx(i, j)
+
+    def _pauli_feature_map(self, circuit: QuantumCircuit, x: np.ndarray):
+        """Pauli feature map with X, Y, Z rotations."""
+        for i in range(min(len(x), self.n_qubits)):
+            circuit.rx(x[i], i)
+            circuit.ry(x[i], i)
+            circuit.rz(x[i], i)
+
+    def _amplitude_feature_map(self, circuit: QuantumCircuit, x: np.ndarray):
+        """Simple amplitude-based encoding."""
+        for i in range(min(len(x), self.n_qubits)):
+            circuit.ry(x[i] * np.pi, i)
+
+    def _solve_dual(self, K: np.ndarray, y: np.ndarray) -> np.ndarray:
+        """
+        Solve SVM dual problem (simplified version).
+
+        In practice, use proper QP solver like CVXOPT.
+        """
+        n = len(y)
+        # Simple heuristic: set alphas based on kernel values
+        alphas = np.zeros(n)
+
+        for i in range(n):
+            # Points with low kernel similarity to same-class points
+            same_class = y == y[i]
+            diff_class = ~same_class
+
+            same_kernel = np.mean(K[i, same_class]) if any(same_class) else 0
+            diff_kernel = np.mean(K[i, diff_class]) if any(diff_class) else 0
+
+            # Higher alpha for boundary points
+            alphas[i] = max(0, 1 - same_kernel + diff_kernel)
+
+        # Normalize
+        if np.sum(alphas) > 0:
+            alphas = alphas / np.sum(alphas)
+
+        return alphas

quantumflow/algorithms/machine_learning/vqe.py

@@ -0,0 +1,229 @@
+"""
+Variational Quantum Eigensolver (VQE).
+
+Finds ground state energy of molecular Hamiltonians.
+Hybrid quantum-classical algorithm for quantum chemistry.
+"""
+
+import math
+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 VQEResult:
+    """Result from VQE optimization."""
+
+    circuit: QuantumCircuit
+    optimal_params: np.ndarray
+    ground_energy: float
+    energy_history: list[float]
+    n_iterations: int
+
+
+class VQE:
+    """
+    Variational Quantum Eigensolver.
+
+    Finds the ground state energy of a Hamiltonian by:
+    1. Preparing parameterized ansatz state
+    2. Measuring expectation value
+    3. Classically optimizing parameters
+
+    Example:
+        >>> vqe = VQE(n_qubits=2)
+        >>> # Simple H2 molecule Hamiltonian
+        >>> H = [("ZZ", 0.5), ("XI", 0.3), ("IX", 0.3)]
+        >>> result = vqe.run(H)
+        >>> print(f"Ground energy: {result.ground_energy:.4f}")
+    """
+
+    def __init__(
+        self,
+        n_qubits: int,
+        backend: BackendType | str = BackendType.AUTO,
+        ansatz: str = "ry_linear",
+        depth: int = 2,
+        shots: int = 1024,
+    ):
+        """
+        Initialize VQE.
+
+        Args:
+            n_qubits: Number of qubits
+            backend: Quantum backend
+            ansatz: Ansatz type ('ry_linear', 'ry_full', 'hardware_efficient')
+            depth: Circuit depth (layers)
+            shots: Measurement shots
+        """
+        self.n_qubits = n_qubits
+        self.backend = get_backend(backend)
+        self.ansatz_type = ansatz
+        self.depth = depth
+        self.shots = shots
+        self._connected = False
+
+    def _ensure_connected(self):
+        if not self._connected:
+            self.backend.connect()
+            self._connected = True
+
+    def run(
+        self,
+        hamiltonian: list[tuple[str, float]],
+        max_iterations: int = 100,
+        initial_params: Optional[np.ndarray] = None,
+    ) -> VQEResult:
+        """
+        Run VQE to find ground state energy.
+
+        Args:
+            hamiltonian: List of (Pauli string, coefficient) tuples
+                         e.g., [("ZZ", 0.5), ("XI", 0.3)]
+            max_iterations: Maximum optimization iterations
+            initial_params: Initial parameter values
+
+        Returns:
+            VQEResult with ground state energy
+        """
+        self._ensure_connected()
+
+        # Initialize parameters
+        n_params = self._count_params()
+        if initial_params is None:
+            params = np.random.uniform(-np.pi, np.pi, n_params)
+        else:
+            params = initial_params.copy()
+
+        energy_history = []
+        best_energy = float('inf')
+        best_params = params.copy()
+
+        # Optimization loop
+        for iteration in range(max_iterations):
+            energy = self._evaluate_energy(params, hamiltonian)
+            energy_history.append(energy)
+
+            if energy < best_energy:
+                best_energy = energy
+                best_params = params.copy()
+
+            # Simple gradient descent with finite differences
+            grad = self._compute_gradient(params, hamiltonian)
+            params -= 0.1 * grad
+
+        # Build final circuit
+        final_circuit = self._build_ansatz(best_params)
+
+        return VQEResult(
+            circuit=final_circuit,
+            optimal_params=best_params,
+            ground_energy=best_energy,
+            energy_history=energy_history,
+            n_iterations=max_iterations,
+        )
+
+    def _count_params(self) -> int:
+        """Count parameters in ansatz."""
+        if self.ansatz_type == "ry_linear":
+            return self.n_qubits * self.depth
+        elif self.ansatz_type == "ry_full":
+            return self.n_qubits * self.depth * 2
+        elif self.ansatz_type == "hardware_efficient":
+            return self.n_qubits * self.depth * 3
+        return self.n_qubits * self.depth
+
+    def _build_ansatz(self, params: np.ndarray) -> QuantumCircuit:
+        """Build parameterized ansatz circuit."""
+        qc = QuantumCircuit(self.n_qubits, name="vqe_ansatz")
+        param_idx = 0
+
+        for layer in range(self.depth):
+            # Single qubit rotations
+            for i in range(self.n_qubits):
+                if self.ansatz_type == "hardware_efficient":
+                    qc.ry(params[param_idx], i)
+                    param_idx += 1
+                    qc.rz(params[param_idx], i)
+                    param_idx += 1
+                else:
+                    qc.ry(params[param_idx], i)
+                    param_idx += 1
+
+            # Entangling layer
+            for i in range(self.n_qubits - 1):
+                qc.cx(i, i + 1)
+
+        return qc
+
+    def _evaluate_energy(
+        self,
+        params: np.ndarray,
+        hamiltonian: list[tuple[str, float]],
+    ) -> float:
+        """Evaluate expectation value of Hamiltonian."""
+        total_energy = 0.0
+
+        for pauli_string, coeff in hamiltonian:
+            expectation = self._measure_pauli(params, pauli_string)
+            total_energy += coeff * expectation
+
+        return total_energy
+
+    def _measure_pauli(self, params: np.ndarray, pauli_string: str) -> float:
+        """Measure expectation value of a Pauli string."""
+        qc = self._build_ansatz(params)
+
+        # Add measurement basis rotations
+        for i, p in enumerate(pauli_string):
+            if p == 'X':
+                qc.h(i)
+            elif p == 'Y':
+                qc.sdg(i)
+                qc.h(i)
+            # Z needs no rotation
+
+        qc.measure_all()
+
+        # Execute
+        result = self.backend.execute(qc, shots=self.shots)
+
+        # Calculate expectation
+        expectation = 0.0
+        for bitstring, count in result.counts.items():
+            # Parity of measured bits
+            parity = 1
+            for i, p in enumerate(pauli_string):
+                if p != 'I':
+                    bit_idx = self.n_qubits - 1 - i
+                    if bit_idx < len(bitstring) and bitstring[bit_idx] == '1':
+                        parity *= -1
+            expectation += parity * count
+
+        return expectation / self.shots
+
+    def _compute_gradient(
+        self,
+        params: np.ndarray,
+        hamiltonian: list[tuple[str, float]],
+    ) -> np.ndarray:
+        """Compute parameter gradient using parameter shift rule."""
+        grad = np.zeros_like(params)
+        shift = np.pi / 2
+
+        for i in range(len(params)):
+            params_plus = params.copy()
+            params_plus[i] += shift
+            energy_plus = self._evaluate_energy(params_plus, hamiltonian)
+
+            params_minus = params.copy()
+            params_minus[i] -= shift
+            energy_minus = self._evaluate_energy(params_minus, hamiltonian)
+
+            grad[i] = (energy_plus - energy_minus) / 2
+
+        return grad

quantumflow/algorithms/optimization/__init__.py

@@ -0,0 +1,7 @@
+"""Optimization Algorithms."""
+
+from quantumflow.algorithms.optimization.qaoa import QAOA
+from quantumflow.algorithms.optimization.grover import GroverSearch
+from quantumflow.algorithms.optimization.quantum_annealing import QuantumAnnealing
+
+__all__ = ["QAOA", "GroverSearch", "QuantumAnnealing"]

quantumflow/algorithms/optimization/grover.py

@@ -0,0 +1,223 @@
+"""
+Grover's Search Algorithm.
+
+Provides quadratic speedup for unstructured search: O(sqrt(N)) vs O(N).
+"""
+
+import math
+from dataclasses import dataclass
+from typing import Optional, Callable, Union
+import numpy as np
+from qiskit import QuantumCircuit
+
+from quantumflow.backends.base_backend import QuantumBackend, get_backend, BackendType
+
+
+@dataclass
+class GroverResult:
+    """Result from Grover search."""
+
+    circuit: QuantumCircuit
+    found_state: str
+    probability: float
+    iterations: int
+    n_qubits: int
+
+
+class GroverSearch:
+    """
+    Grover's Quantum Search Algorithm.
+
+    Finds marked items in an unstructured database with quadratic speedup.
+
+    Features:
+    - Automatic iteration count optimization
+    - Custom oracle support
+    - Multi-target search
+
+    Example:
+        >>> grover = GroverSearch()
+        >>> result = grover.search(n_qubits=4, marked_states=[5, 10])
+        >>> print(f"Found: {result.found_state} with P={result.probability:.2%}")
+    """
+
+    def __init__(self, backend: BackendType | str = BackendType.AUTO):
+        self.backend = get_backend(backend)
+        self._connected = False
+
+    def _ensure_connected(self):
+        if not self._connected:
+            self.backend.connect()
+            self._connected = True
+
+    def search(
+        self,
+        n_qubits: int,
+        marked_states: list[int],
+        iterations: Optional[int] = None,
+        shots: int = 1024,
+    ) -> GroverResult:
+        """
+        Search for marked states.
+
+        Args:
+            n_qubits: Number of qubits (search space = 2^n)
+            marked_states: States to find
+            iterations: Grover iterations (optimal if None)
+            shots: Measurement shots
+
+        Returns:
+            GroverResult with found state
+        """
+        self._ensure_connected()
+
+        N = 2 ** n_qubits
+        M = len(marked_states)
+
+        # Calculate optimal iterations
+        if iterations is None:
+            if M > 0 and M < N:
+                theta = math.asin(math.sqrt(M / N))
+                iterations = max(1, int(round(math.pi / (4 * theta) - 0.5)))
+            else:
+                iterations = 1
+
+        # Build circuit
+        oracle = self._build_oracle(n_qubits, marked_states)
+        circuit = self._build_circuit(n_qubits, oracle, iterations)
+
+        # Execute
+        result = self.backend.execute(circuit, shots=shots)
+
+        # Find most likely state
+        found_state = max(result.counts, key=result.counts.get)
+        probability = result.counts[found_state] / shots
+
+        return GroverResult(
+            circuit=circuit,
+            found_state=found_state,
+            probability=probability,
+            iterations=iterations,
+            n_qubits=n_qubits,
+        )
+
+    def search_with_oracle(
+        self,
+        n_qubits: int,
+        oracle: QuantumCircuit,
+        n_solutions: int = 1,
+        iterations: Optional[int] = None,
+        shots: int = 1024,
+    ) -> GroverResult:
+        """
+        Search using a custom oracle.
+
+        Args:
+            n_qubits: Number of qubits
+            oracle: Custom oracle circuit
+            n_solutions: Expected number of solutions
+            iterations: Grover iterations
+            shots: Measurement shots
+
+        Returns:
+            GroverResult
+        """
+        self._ensure_connected()
+
+        N = 2 ** n_qubits
+
+        if iterations is None:
+            if n_solutions > 0 and n_solutions < N:
+                theta = math.asin(math.sqrt(n_solutions / N))
+                iterations = max(1, int(round(math.pi / (4 * theta) - 0.5)))
+            else:
+                iterations = 1
+
+        circuit = self._build_circuit(n_qubits, oracle, iterations)
+        result = self.backend.execute(circuit, shots=shots)
+
+        found_state = max(result.counts, key=result.counts.get)
+        probability = result.counts[found_state] / shots
+
+        return GroverResult(
+            circuit=circuit,
+            found_state=found_state,
+            probability=probability,
+            iterations=iterations,
+            n_qubits=n_qubits,
+        )
+
+    def _build_oracle(
+        self,
+        n_qubits: int,
+        marked_states: list[int],
+    ) -> QuantumCircuit:
+        """Build oracle marking specified states."""
+        oracle = QuantumCircuit(n_qubits, name="oracle")
+
+        for state in marked_states:
+            binary = format(state, f'0{n_qubits}b')
+
+            # Flip qubits that should be |0⟩
+            for i, bit in enumerate(reversed(binary)):
+                if bit == '0':
+                    oracle.x(i)
+
+            # Multi-controlled Z gate
+            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)
+
+            # Unflip
+            for i, bit in enumerate(reversed(binary)):
+                if bit == '0':
+                    oracle.x(i)
+
+        return oracle
+
+    def _build_diffuser(self, n_qubits: int) -> QuantumCircuit:
+        """Build Grover diffusion operator."""
+        diffuser = QuantumCircuit(n_qubits, name="diffuser")
+
+        diffuser.h(range(n_qubits))
+        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)
+
+        diffuser.x(range(n_qubits))
+        diffuser.h(range(n_qubits))
+
+        return diffuser
+
+    def _build_circuit(
+        self,
+        n_qubits: int,
+        oracle: QuantumCircuit,
+        iterations: int,
+    ) -> QuantumCircuit:
+        """Build complete Grover circuit."""
+        circuit = QuantumCircuit(n_qubits, n_qubits, name="grover")
+
+        # Initial superposition
+        circuit.h(range(n_qubits))
+
+        # Grover iterations
+        diffuser = self._build_diffuser(n_qubits)
+
+        for _ in range(iterations):
+            circuit.compose(oracle, inplace=True)
+            circuit.compose(diffuser, inplace=True)
+
+        # Measure
+        circuit.measure(range(n_qubits), range(n_qubits))
+
+        return circuit