quantumflow-sdk 0.1.0__py3-none-any.whl

quantumflow/algorithms/optimization/qaoa.py

@@ -0,0 +1,251 @@
+"""
+Quantum Approximate Optimization Algorithm (QAOA).
+
+Solves combinatorial optimization problems like MaxCut, TSP, etc.
+Hybrid quantum-classical algorithm using parameterized circuits.
+"""
+
+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 QAOAResult:
+    """Result from QAOA optimization."""
+
+    circuit: QuantumCircuit
+    optimal_params: np.ndarray
+    best_solution: str
+    best_cost: float
+    cost_history: list[float]
+    n_iterations: int
+
+
+class QAOA:
+    """
+    Quantum Approximate Optimization Algorithm.
+
+    Solves combinatorial optimization by:
+    1. Encoding problem as cost Hamiltonian
+    2. Alternating cost and mixer layers
+    3. Classical optimization of parameters
+
+    Supported problems:
+    - MaxCut
+    - Weighted MaxCut
+    - Custom QUBO/Ising problems
+
+    Example:
+        >>> qaoa = QAOA(p=2)
+        >>> edges = [(0, 1), (1, 2), (2, 0)]
+        >>> result = qaoa.maxcut(edges, n_nodes=3)
+        >>> print(f"Best cut: {result.best_solution}, Cost: {result.best_cost}")
+    """
+
+    def __init__(
+        self,
+        backend: BackendType | str = BackendType.AUTO,
+        p: int = 1,
+        shots: int = 1024,
+    ):
+        """
+        Initialize QAOA.
+
+        Args:
+            backend: Quantum backend
+            p: Number of QAOA layers (depth)
+            shots: Measurement shots per evaluation
+        """
+        self.backend = get_backend(backend)
+        self.p = p
+        self.shots = shots
+        self._connected = False
+
+    def _ensure_connected(self):
+        if not self._connected:
+            self.backend.connect()
+            self._connected = True
+
+    def maxcut(
+        self,
+        edges: list[tuple[int, int]],
+        n_nodes: int,
+        weights: Optional[list[float]] = None,
+        max_iterations: int = 100,
+    ) -> QAOAResult:
+        """
+        Solve MaxCut problem.
+
+        Args:
+            edges: List of (i, j) edges
+            n_nodes: Number of nodes
+            weights: Optional edge weights
+            max_iterations: Max optimization iterations
+
+        Returns:
+            QAOAResult with optimal solution
+        """
+        if weights is None:
+            weights = [1.0] * len(edges)
+
+        # Build cost function
+        def cost_fn(bitstring: str) -> float:
+            cost = 0
+            for (i, j), w in zip(edges, weights):
+                if bitstring[i] != bitstring[j]:
+                    cost += w
+            return cost
+
+        return self._optimize(
+            n_qubits=n_nodes,
+            cost_hamiltonian=self._maxcut_hamiltonian(edges, weights, n_nodes),
+            cost_fn=cost_fn,
+            max_iterations=max_iterations,
+        )
+
+    def optimize_qubo(
+        self,
+        Q: np.ndarray,
+        max_iterations: int = 100,
+    ) -> QAOAResult:
+        """
+        Solve QUBO (Quadratic Unconstrained Binary Optimization).
+
+        Args:
+            Q: QUBO matrix (n x n)
+            max_iterations: Max optimization iterations
+
+        Returns:
+            QAOAResult with optimal solution
+        """
+        n_qubits = Q.shape[0]
+
+        def cost_fn(bitstring: str) -> float:
+            x = np.array([int(b) for b in bitstring])
+            return float(x @ Q @ x)
+
+        return self._optimize(
+            n_qubits=n_qubits,
+            cost_hamiltonian=self._qubo_hamiltonian(Q),
+            cost_fn=cost_fn,
+            max_iterations=max_iterations,
+        )
+
+    def _optimize(
+        self,
+        n_qubits: int,
+        cost_hamiltonian: Callable[[QuantumCircuit, float], None],
+        cost_fn: Callable[[str], float],
+        max_iterations: int,
+    ) -> QAOAResult:
+        """Run QAOA optimization loop."""
+        self._ensure_connected()
+
+        # Initialize parameters: gamma (cost), beta (mixer)
+        params = np.random.uniform(0, np.pi, 2 * self.p)
+        cost_history = []
+
+        # Simple gradient-free optimization (COBYLA-style)
+        best_params = params.copy()
+        best_cost = float('inf')
+
+        for iteration in range(max_iterations):
+            # Evaluate current parameters
+            circuit = self._build_circuit(n_qubits, params, cost_hamiltonian)
+            result = self.backend.execute(circuit, shots=self.shots)
+
+            # Calculate expected cost
+            total_cost = 0
+            for bitstring, count in result.counts.items():
+                total_cost += cost_fn(bitstring) * count
+            avg_cost = total_cost / self.shots
+
+            cost_history.append(avg_cost)
+
+            if avg_cost < best_cost:
+                best_cost = avg_cost
+                best_params = params.copy()
+
+            # Simple parameter update (gradient approximation)
+            for i in range(len(params)):
+                delta = 0.1 * (np.random.random() - 0.5)
+                params[i] += delta
+
+        # Get best solution
+        final_circuit = self._build_circuit(n_qubits, best_params, cost_hamiltonian)
+        final_result = self.backend.execute(final_circuit, shots=self.shots)
+        best_solution = max(final_result.counts, key=final_result.counts.get)
+
+        return QAOAResult(
+            circuit=final_circuit,
+            optimal_params=best_params,
+            best_solution=best_solution,
+            best_cost=best_cost,
+            cost_history=cost_history,
+            n_iterations=max_iterations,
+        )
+
+    def _build_circuit(
+        self,
+        n_qubits: int,
+        params: np.ndarray,
+        cost_hamiltonian: Callable,
+    ) -> QuantumCircuit:
+        """Build QAOA circuit with given parameters."""
+        qc = QuantumCircuit(n_qubits, n_qubits, name="qaoa")
+
+        # Initial superposition
+        qc.h(range(n_qubits))
+
+        # QAOA layers
+        for layer in range(self.p):
+            gamma = params[2 * layer]
+            beta = params[2 * layer + 1]
+
+            # Cost layer
+            cost_hamiltonian(qc, gamma)
+
+            # Mixer layer (X rotations)
+            for i in range(n_qubits):
+                qc.rx(2 * beta, i)
+
+        # Measure
+        qc.measure(range(n_qubits), range(n_qubits))
+
+        return qc
+
+    def _maxcut_hamiltonian(
+        self,
+        edges: list[tuple[int, int]],
+        weights: list[float],
+        n_qubits: int,
+    ) -> Callable:
+        """Create MaxCut cost Hamiltonian."""
+        def apply_cost(qc: QuantumCircuit, gamma: float):
+            for (i, j), w in zip(edges, weights):
+                qc.rzz(w * gamma, i, j)
+        return apply_cost
+
+    def _qubo_hamiltonian(self, Q: np.ndarray) -> Callable:
+        """Create QUBO cost Hamiltonian."""
+        n = Q.shape[0]
+
+        def apply_cost(qc: QuantumCircuit, gamma: float):
+            # Diagonal terms
+            for i in range(n):
+                if Q[i, i] != 0:
+                    qc.rz(Q[i, i] * gamma, i)
+
+            # Off-diagonal terms
+            for i in range(n):
+                for j in range(i + 1, n):
+                    if Q[i, j] != 0 or Q[j, i] != 0:
+                        coeff = Q[i, j] + Q[j, i]
+                        qc.rzz(coeff * gamma / 2, i, j)
+
+        return apply_cost

quantumflow/algorithms/optimization/quantum_annealing.py

@@ -0,0 +1,237 @@
+"""
+Quantum Annealing Simulation.
+
+Simulates quantum annealing for optimization problems.
+Note: True quantum annealing requires specialized hardware (D-Wave).
+"""
+
+import math
+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 AnnealingResult:
+    """Result from quantum annealing."""
+
+    circuit: QuantumCircuit
+    best_solution: str
+    best_energy: float
+    energy_history: list[float]
+    n_steps: int
+
+
+class QuantumAnnealing:
+    """
+    Quantum Annealing Simulation using gate-based circuits.
+
+    Simulates the annealing process by:
+    1. Starting in ground state of transverse field
+    2. Slowly evolving to problem Hamiltonian
+    3. Measuring final state
+
+    Best for: Optimization problems expressible as Ising models.
+
+    Example:
+        >>> qa = QuantumAnnealing()
+        >>> J = {(0,1): -1, (1,2): -1}  # Ferromagnetic coupling
+        >>> result = qa.anneal(J, h={}, n_qubits=3)
+        >>> print(f"Ground state: {result.best_solution}")
+    """
+
+    def __init__(
+        self,
+        backend: BackendType | str = BackendType.AUTO,
+        n_steps: int = 20,
+    ):
+        """
+        Initialize quantum annealing.
+
+        Args:
+            backend: Quantum backend
+            n_steps: Number of annealing steps (Trotter steps)
+        """
+        self.backend = get_backend(backend)
+        self.n_steps = n_steps
+        self._connected = False
+
+    def _ensure_connected(self):
+        if not self._connected:
+            self.backend.connect()
+            self._connected = True
+
+    def anneal(
+        self,
+        J: dict[tuple[int, int], float],
+        h: dict[int, float],
+        n_qubits: int,
+        shots: int = 1024,
+    ) -> AnnealingResult:
+        """
+        Run quantum annealing for Ising problem.
+
+        Hamiltonian: H = -sum_ij J_ij * Z_i * Z_j - sum_i h_i * Z_i
+
+        Args:
+            J: Coupling strengths {(i,j): strength}
+            h: Local fields {i: field}
+            n_qubits: Number of qubits
+            shots: Measurement shots
+
+        Returns:
+            AnnealingResult with ground state
+        """
+        self._ensure_connected()
+
+        # Build annealing circuit
+        circuit = self._build_annealing_circuit(J, h, n_qubits)
+
+        # Execute
+        result = self.backend.execute(circuit, shots=shots)
+
+        # Find ground state (lowest energy)
+        best_solution = None
+        best_energy = float('inf')
+
+        for bitstring, count in result.counts.items():
+            energy = self._calculate_energy(bitstring, J, h)
+            if energy < best_energy:
+                best_energy = energy
+                best_solution = bitstring
+
+        # Simulate energy history (for visualization)
+        energy_history = self._simulate_energy_history(best_energy)
+
+        return AnnealingResult(
+            circuit=circuit,
+            best_solution=best_solution or "0" * n_qubits,
+            best_energy=best_energy,
+            energy_history=energy_history,
+            n_steps=self.n_steps,
+        )
+
+    def anneal_qubo(
+        self,
+        Q: np.ndarray,
+        shots: int = 1024,
+    ) -> AnnealingResult:
+        """
+        Run quantum annealing for QUBO problem.
+
+        Args:
+            Q: QUBO matrix
+            shots: Measurement shots
+
+        Returns:
+            AnnealingResult
+        """
+        n_qubits = Q.shape[0]
+
+        # Convert QUBO to Ising
+        J, h, offset = self._qubo_to_ising(Q)
+
+        result = self.anneal(J, h, n_qubits, shots)
+        result.best_energy += offset
+
+        return result
+
+    def _build_annealing_circuit(
+        self,
+        J: dict[tuple[int, int], float],
+        h: dict[int, float],
+        n_qubits: int,
+    ) -> QuantumCircuit:
+        """Build circuit simulating quantum annealing."""
+        circuit = QuantumCircuit(n_qubits, n_qubits, name="annealing")
+
+        # Start in |+⟩^n (ground state of transverse field)
+        circuit.h(range(n_qubits))
+
+        # Annealing schedule: s goes from 0 to 1
+        dt = 1.0 / self.n_steps
+
+        for step in range(self.n_steps):
+            s = (step + 1) / self.n_steps  # Annealing parameter
+
+            # Transverse field (decreasing)
+            gamma = (1 - s) * math.pi / 4
+            for i in range(n_qubits):
+                circuit.rx(2 * gamma * dt, i)
+
+            # Problem Hamiltonian (increasing)
+            beta = s * math.pi / 4
+
+            # ZZ interactions
+            for (i, j), strength in J.items():
+                circuit.rzz(2 * strength * beta * dt, i, j)
+
+            # Z terms
+            for i, field in h.items():
+                circuit.rz(2 * field * beta * dt, i)
+
+        # Measure
+        circuit.measure(range(n_qubits), range(n_qubits))
+
+        return circuit
+
+    def _calculate_energy(
+        self,
+        bitstring: str,
+        J: dict[tuple[int, int], float],
+        h: dict[int, float],
+    ) -> float:
+        """Calculate Ising energy for a bitstring."""
+        # Convert to spins (+1/-1)
+        spins = [1 if b == '0' else -1 for b in bitstring]
+
+        energy = 0.0
+
+        # Coupling terms
+        for (i, j), strength in J.items():
+            energy -= strength * spins[i] * spins[j]
+
+        # Field terms
+        for i, field in h.items():
+            energy -= field * spins[i]
+
+        return energy
+
+    def _qubo_to_ising(
+        self,
+        Q: np.ndarray,
+    ) -> tuple[dict, dict, float]:
+        """Convert QUBO to Ising formulation."""
+        n = Q.shape[0]
+        J = {}
+        h = {}
+        offset = 0.0
+
+        for i in range(n):
+            for j in range(i, n):
+                if i == j:
+                    h[i] = Q[i, i] / 2
+                    offset += Q[i, i] / 2
+                else:
+                    coupling = (Q[i, j] + Q[j, i]) / 4
+                    if coupling != 0:
+                        J[(i, j)] = coupling
+                    h[i] = h.get(i, 0) + (Q[i, j] + Q[j, i]) / 4
+                    h[j] = h.get(j, 0) + (Q[i, j] + Q[j, i]) / 4
+                    offset += (Q[i, j] + Q[j, i]) / 4
+
+        return J, h, offset
+
+    def _simulate_energy_history(self, final_energy: float) -> list[float]:
+        """Simulate energy evolution during annealing."""
+        history = []
+        for step in range(self.n_steps):
+            s = step / self.n_steps
+            # Energy decreases as we anneal
+            energy = final_energy + (1 - s) * abs(final_energy) * 2
+            history.append(energy)
+        history.append(final_energy)
+        return history

quantumflow/algorithms/utility/__init__.py

@@ -0,0 +1,6 @@
+"""Utility Algorithms."""
+
+from quantumflow.algorithms.utility.error_correction import ErrorCorrection
+from quantumflow.algorithms.utility.circuit_optimizer import CircuitOptimizer
+
+__all__ = ["ErrorCorrection", "CircuitOptimizer"]

quantumflow/algorithms/utility/circuit_optimizer.py

@@ -0,0 +1,194 @@
+"""
+Quantum Circuit Optimizer.
+
+Optimizes quantum circuits for better performance on real hardware.
+"""
+
+from dataclasses import dataclass
+from typing import Optional
+import numpy as np
+from qiskit import QuantumCircuit, transpile
+
+from quantumflow.backends.base_backend import QuantumBackend, get_backend, BackendType
+
+
+@dataclass
+class OptimizationResult:
+    """Result from circuit optimization."""
+
+    original_circuit: QuantumCircuit
+    optimized_circuit: QuantumCircuit
+    original_depth: int
+    optimized_depth: int
+    original_gates: int
+    optimized_gates: int
+    depth_reduction: float
+    gate_reduction: float
+
+
+class CircuitOptimizer:
+    """
+    Quantum Circuit Optimizer.
+
+    Applies various optimization techniques:
+    - Gate cancellation
+    - Gate fusion
+    - Commutation optimization
+    - Hardware-specific transpilation
+
+    Example:
+        >>> opt = CircuitOptimizer()
+        >>> result = opt.optimize(circuit)
+        >>> print(f"Depth reduced by {result.depth_reduction:.1%}")
+    """
+
+    def __init__(
+        self,
+        backend: BackendType | str = BackendType.AUTO,
+        optimization_level: int = 2,
+    ):
+        """
+        Initialize optimizer.
+
+        Args:
+            backend: Target backend for optimization
+            optimization_level: 0-3 (higher = more optimization)
+        """
+        self.backend = get_backend(backend)
+        self.optimization_level = optimization_level
+
+    def optimize(
+        self,
+        circuit: QuantumCircuit,
+        target_basis: Optional[list[str]] = None,
+    ) -> OptimizationResult:
+        """
+        Optimize a quantum circuit.
+
+        Args:
+            circuit: Circuit to optimize
+            target_basis: Target gate set (e.g., ['cx', 'u3'])
+
+        Returns:
+            OptimizationResult with optimized circuit
+        """
+        original_depth = circuit.depth()
+        original_gates = sum(circuit.count_ops().values())
+
+        # Apply optimizations
+        optimized = self._apply_optimizations(circuit)
+
+        # Transpile for target
+        if target_basis:
+            optimized = transpile(
+                optimized,
+                basis_gates=target_basis,
+                optimization_level=self.optimization_level,
+            )
+        else:
+            optimized = transpile(
+                optimized,
+                optimization_level=self.optimization_level,
+            )
+
+        optimized_depth = optimized.depth()
+        optimized_gates = sum(optimized.count_ops().values())
+
+        depth_reduction = 1 - (optimized_depth / original_depth) if original_depth > 0 else 0
+        gate_reduction = 1 - (optimized_gates / original_gates) if original_gates > 0 else 0
+
+        return OptimizationResult(
+            original_circuit=circuit,
+            optimized_circuit=optimized,
+            original_depth=original_depth,
+            optimized_depth=optimized_depth,
+            original_gates=original_gates,
+            optimized_gates=optimized_gates,
+            depth_reduction=depth_reduction,
+            gate_reduction=gate_reduction,
+        )
+
+    def _apply_optimizations(self, circuit: QuantumCircuit) -> QuantumCircuit:
+        """Apply custom optimization passes using transpile."""
+        # Use transpile with high optimization level
+        return transpile(circuit, optimization_level=3)
+
+    def cancel_redundant_gates(self, circuit: QuantumCircuit) -> QuantumCircuit:
+        """Cancel adjacent inverse gates."""
+        return transpile(circuit, optimization_level=2)
+
+    def fuse_single_qubit_gates(self, circuit: QuantumCircuit) -> QuantumCircuit:
+        """Fuse consecutive single-qubit gates."""
+        return transpile(circuit, optimization_level=2)
+
+    def optimize_for_hardware(
+        self,
+        circuit: QuantumCircuit,
+        coupling_map: Optional[list[list[int]]] = None,
+    ) -> QuantumCircuit:
+        """
+        Optimize circuit for specific hardware topology.
+
+        Args:
+            circuit: Circuit to optimize
+            coupling_map: Hardware qubit connectivity
+
+        Returns:
+            Hardware-optimized circuit
+        """
+        return transpile(
+            circuit,
+            coupling_map=coupling_map,
+            optimization_level=self.optimization_level,
+        )
+
+    def estimate_cost(self, circuit: QuantumCircuit) -> dict:
+        """
+        Estimate circuit execution cost.
+
+        Returns:
+            Dict with depth, gate counts, estimated time
+        """
+        ops = circuit.count_ops()
+
+        # Rough gate time estimates (in microseconds)
+        gate_times = {
+            'x': 0.02, 'y': 0.02, 'z': 0.02,
+            'h': 0.02, 's': 0.02, 't': 0.02,
+            'rx': 0.03, 'ry': 0.03, 'rz': 0.03,
+            'cx': 0.3, 'cz': 0.3,
+            'ccx': 0.9, 'swap': 0.6,
+            'measure': 1.0,
+        }
+
+        total_time = sum(
+            ops.get(gate, 0) * gate_times.get(gate, 0.1)
+            for gate in ops
+        )
+
+        two_qubit_gates = ops.get('cx', 0) + ops.get('cz', 0) + ops.get('swap', 0)
+
+        return {
+            'depth': circuit.depth(),
+            'total_gates': sum(ops.values()),
+            'two_qubit_gates': two_qubit_gates,
+            'estimated_time_us': total_time,
+            'gate_counts': dict(ops),
+        }
+
+    def compare_circuits(
+        self,
+        circuit1: QuantumCircuit,
+        circuit2: QuantumCircuit,
+    ) -> dict:
+        """Compare two circuits."""
+        cost1 = self.estimate_cost(circuit1)
+        cost2 = self.estimate_cost(circuit2)
+
+        return {
+            'circuit1': cost1,
+            'circuit2': cost2,
+            'depth_diff': cost1['depth'] - cost2['depth'],
+            'gate_diff': cost1['total_gates'] - cost2['total_gates'],
+            'time_diff_us': cost1['estimated_time_us'] - cost2['estimated_time_us'],
+        }