superquantx 0.1.0__py3-none-any.whl

superquantx/algorithms.py

@@ -0,0 +1,863 @@
+"""Quantum algorithms implementation for SuperQuantX
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+import numpy as np
+from scipy.optimize import minimize
+from sklearn.base import BaseEstimator
+
+from .circuits import QuantumCircuit
+from .client import SuperQuantXClient
+from .gates import Hamiltonian, PauliString
+
+
+class QuantumAlgorithm(ABC):
+    """Base class for quantum algorithms
+    """
+
+    def __init__(self, client: Optional[SuperQuantXClient] = None):
+        """Initialize quantum algorithm
+        
+        Args:
+            client: SuperQuantX client for quantum execution
+
+        """
+        self.client = client
+        self.result_history: List[Dict[str, Any]] = []
+
+    @abstractmethod
+    def run(self, *args, **kwargs) -> Dict[str, Any]:
+        """Execute the quantum algorithm"""
+        pass
+
+    def set_client(self, client: SuperQuantXClient) -> None:
+        """Set the quantum client"""
+        self.client = client
+
+
+class VQE(QuantumAlgorithm):
+    """Variational Quantum Eigensolver (VQE) for finding ground state energies
+    """
+
+    def __init__(
+        self,
+        hamiltonian: Hamiltonian,
+        ansatz: Callable[[np.ndarray], QuantumCircuit],
+        client: Optional[SuperQuantXClient] = None,
+        optimizer: str = "SLSQP",
+        max_iterations: int = 1000,
+        tolerance: float = 1e-6
+    ):
+        """Initialize VQE algorithm
+        
+        Args:
+            hamiltonian: Target Hamiltonian
+            ansatz: Parameterized quantum circuit ansatz
+            client: SuperQuantX client for execution
+            optimizer: Classical optimizer method
+            max_iterations: Maximum optimization iterations
+            tolerance: Convergence tolerance
+
+        """
+        super().__init__(client)
+        self.hamiltonian = hamiltonian
+        self.ansatz = ansatz
+        self.optimizer = optimizer
+        self.max_iterations = max_iterations
+        self.tolerance = tolerance
+
+        self.optimal_parameters: Optional[np.ndarray] = None
+        self.optimal_energy: Optional[float] = None
+        self.optimization_history: List[float] = []
+
+    def cost_function(self, parameters: np.ndarray) -> float:
+        """VQE cost function: expectation value of Hamiltonian
+        
+        Args:
+            parameters: Ansatz parameters
+            
+        Returns:
+            Energy expectation value
+
+        """
+        circuit = self.ansatz(parameters)
+
+        if self.client is None:
+            # Simulate locally
+            energy = self._simulate_expectation_value(circuit, self.hamiltonian)
+        else:
+            # Execute on quantum backend
+            energy = self._execute_expectation_value(circuit, self.hamiltonian)
+
+        self.optimization_history.append(energy)
+        return energy
+
+    def _simulate_expectation_value(
+        self,
+        circuit: QuantumCircuit,
+        hamiltonian: Hamiltonian
+    ) -> float:
+        """Simulate expectation value locally"""
+        # This is a simplified simulation
+        # In practice, would use a quantum simulator
+        state = self._simulate_circuit(circuit)
+        return float(np.real(hamiltonian.expectation_value(state)))
+
+    def _simulate_circuit(self, circuit: QuantumCircuit) -> np.ndarray:
+        """Simulate quantum circuit to get final state"""
+        # Initialize state |0⟩^n
+        state = np.zeros(2 ** circuit.num_qubits, dtype=complex)
+        state[0] = 1.0
+
+        # Apply gates (simplified simulation)
+        for gate in circuit.gates:
+            if gate.name == "RY" and len(gate.qubits) == 1:
+                # Apply single-qubit rotation
+                qubit = gate.qubits[0]
+                theta = gate.parameters[0]
+
+                # Create rotation matrix for full system
+                from .gates import GateMatrix
+                gate_matrix = GateMatrix.ry(theta)
+
+                # Apply to specific qubit (simplified)
+                state = self._apply_single_qubit_gate(state, gate_matrix, qubit, circuit.num_qubits)
+            elif gate.name == "CNOT" and len(gate.qubits) == 2:
+                # Apply CNOT gate
+                control, target = gate.qubits
+                state = self._apply_cnot(state, control, target, circuit.num_qubits)
+
+        return state
+
+    def _apply_single_qubit_gate(
+        self,
+        state: np.ndarray,
+        gate_matrix: np.ndarray,
+        qubit: int,
+        num_qubits: int
+    ) -> np.ndarray:
+        """Apply single-qubit gate to state vector"""
+        # This is a simplified implementation
+        # Would use more efficient tensor operations in practice
+
+        dim = 2 ** num_qubits
+        new_state = np.zeros_like(state)
+
+        for i in range(dim):
+            # Extract qubit state
+            qubit_state = (i >> qubit) & 1
+
+            for new_qubit_state in range(2):
+                # Apply gate matrix element
+                amplitude = gate_matrix[new_qubit_state, qubit_state]
+                if abs(amplitude) > 1e-12:
+                    new_i = i ^ ((qubit_state ^ new_qubit_state) << qubit)
+                    new_state[new_i] += amplitude * state[i]
+
+        return new_state
+
+    def _apply_cnot(
+        self,
+        state: np.ndarray,
+        control: int,
+        target: int,
+        num_qubits: int
+    ) -> np.ndarray:
+        """Apply CNOT gate to state vector"""
+        dim = 2 ** num_qubits
+        new_state = np.copy(state)
+
+        for i in range(dim):
+            control_bit = (i >> control) & 1
+            target_bit = (i >> target) & 1
+
+            if control_bit == 1:
+                # Flip target bit
+                flipped_i = i ^ (1 << target)
+                new_state[i], new_state[flipped_i] = state[flipped_i], state[i]
+
+        return new_state
+
+    def _execute_expectation_value(
+        self,
+        circuit: QuantumCircuit,
+        hamiltonian: Hamiltonian
+    ) -> float:
+        """Execute expectation value measurement on quantum backend"""
+        if self.client is None:
+            raise ValueError("Client required for quantum execution")
+
+        # Decompose Hamiltonian into measurable terms
+        total_expectation = 0.0
+
+        for pauli_string in hamiltonian.pauli_strings:
+            # Create measurement circuit for this Pauli string
+            measurement_circuit = self._create_measurement_circuit(circuit, pauli_string)
+
+            # Execute circuit
+            job = self.client.submit_job_sync(
+                circuit_data=measurement_circuit.to_dict(),
+                shots=1024
+            )
+            result = self.client.wait_for_job_sync(job.job_id)
+
+            # Calculate expectation value from measurement results
+            expectation = self._calculate_pauli_expectation(result.results, pauli_string)
+            total_expectation += expectation
+
+        return total_expectation
+
+    def _create_measurement_circuit(
+        self,
+        circuit: QuantumCircuit,
+        pauli_string: PauliString
+    ) -> QuantumCircuit:
+        """Create circuit with appropriate measurements for Pauli string"""
+        measurement_circuit = circuit.copy()
+
+        # Add rotation gates to measure in correct basis
+        for i, pauli_op in enumerate(pauli_string.pauli_ops):
+            if pauli_op == 'X':
+                measurement_circuit.ry(-np.pi/2, i)  # Rotate Y→Z
+            elif pauli_op == 'Y':
+                measurement_circuit.rx(np.pi/2, i)   # Rotate X→Z
+            # Z measurements don't need rotation
+
+        # Measure all qubits
+        measurement_circuit.measure_all()
+
+        return measurement_circuit
+
+    def _calculate_pauli_expectation(
+        self,
+        measurement_results: Dict[str, Any],
+        pauli_string: PauliString
+    ) -> float:
+        """Calculate expectation value from measurement results"""
+        counts = measurement_results.get("counts", {})
+        shots = sum(counts.values())
+
+        if shots == 0:
+            return 0.0
+
+        expectation = 0.0
+
+        for bitstring, count in counts.items():
+            # Calculate parity for non-identity Pauli operators
+            parity = 1
+            for i, pauli_op in enumerate(pauli_string.pauli_ops):
+                if pauli_op != 'I' and i < len(bitstring):
+                    bit = int(bitstring[-(i+1)])  # Reverse order
+                    parity *= (-1) ** bit
+
+            expectation += parity * count / shots
+
+        return float(np.real(pauli_string.coefficient * expectation))
+
+    def run(
+        self,
+        initial_parameters: Optional[np.ndarray] = None,
+        **optimizer_kwargs
+    ) -> Dict[str, Any]:
+        """Run VQE optimization
+        
+        Args:
+            initial_parameters: Initial parameter values
+            **optimizer_kwargs: Additional optimizer parameters
+            
+        Returns:
+            VQE results dictionary
+
+        """
+        if initial_parameters is None:
+            # Random initialization
+            num_params = self._estimate_parameter_count()
+            initial_parameters = np.random.uniform(0, 2*np.pi, num_params)
+
+        self.optimization_history = []
+
+        # Run classical optimization
+        result = minimize(
+            fun=self.cost_function,
+            x0=initial_parameters,
+            method=self.optimizer,
+            options={'maxiter': self.max_iterations, 'ftol': self.tolerance},
+            **optimizer_kwargs
+        )
+
+        self.optimal_parameters = result.x
+        self.optimal_energy = result.fun
+
+        return {
+            "optimal_energy": self.optimal_energy,
+            "optimal_parameters": self.optimal_parameters,
+            "optimization_history": self.optimization_history,
+            "converged": result.success,
+            "num_iterations": result.nit,
+            "ground_state_energy_exact": self.hamiltonian.ground_state_energy()
+        }
+
+    def _estimate_parameter_count(self) -> int:
+        """Estimate number of parameters needed for ansatz"""
+        # This is a heuristic - would depend on specific ansatz
+        return self.hamiltonian.num_qubits * 2
+
+
+class QAOA(QuantumAlgorithm):
+    """Quantum Approximate Optimization Algorithm (QAOA)
+    """
+
+    def __init__(
+        self,
+        cost_hamiltonian: Hamiltonian,
+        mixer_hamiltonian: Optional[Hamiltonian] = None,
+        p: int = 1,
+        client: Optional[SuperQuantXClient] = None,
+        optimizer: str = "SLSQP"
+    ):
+        """Initialize QAOA
+        
+        Args:
+            cost_hamiltonian: Problem Hamiltonian
+            mixer_hamiltonian: Mixer Hamiltonian (default: X on all qubits)
+            p: Number of QAOA layers
+            client: SuperQuantX client
+            optimizer: Classical optimizer
+
+        """
+        super().__init__(client)
+        self.cost_hamiltonian = cost_hamiltonian
+        self.p = p
+        self.optimizer = optimizer
+
+        # Default mixer: transverse field
+        if mixer_hamiltonian is None:
+            pauli_strings = []
+            for i in range(cost_hamiltonian.num_qubits):
+                x_ops = ['I'] * cost_hamiltonian.num_qubits
+                x_ops[i] = 'X'
+                pauli_strings.append(PauliString(''.join(x_ops), 1.0))
+            self.mixer_hamiltonian = Hamiltonian(pauli_strings)
+        else:
+            self.mixer_hamiltonian = mixer_hamiltonian
+
+    def create_qaoa_circuit(self, parameters: np.ndarray) -> QuantumCircuit:
+        """Create QAOA circuit with given parameters
+        
+        Args:
+            parameters: [beta_1, gamma_1, beta_2, gamma_2, ...] for p layers
+            
+        Returns:
+            QAOA quantum circuit
+
+        """
+        if len(parameters) != 2 * self.p:
+            raise ValueError(f"Expected {2*self.p} parameters, got {len(parameters)}")
+
+        circuit = QuantumCircuit(self.cost_hamiltonian.num_qubits)
+
+        # Initialize in equal superposition
+        for i in range(circuit.num_qubits):
+            circuit.h(i)
+
+        # Apply QAOA layers
+        for layer in range(self.p):
+            gamma = parameters[2*layer]
+            beta = parameters[2*layer + 1]
+
+            # Apply cost Hamiltonian evolution: exp(-i γ H_C)
+            self._apply_hamiltonian_evolution(circuit, self.cost_hamiltonian, gamma)
+
+            # Apply mixer Hamiltonian evolution: exp(-i β H_M)
+            self._apply_hamiltonian_evolution(circuit, self.mixer_hamiltonian, beta)
+
+        return circuit
+
+    def _apply_hamiltonian_evolution(
+        self,
+        circuit: QuantumCircuit,
+        hamiltonian: Hamiltonian,
+        time: float
+    ) -> None:
+        """Apply Hamiltonian time evolution to circuit"""
+        for pauli_string in hamiltonian.pauli_strings:
+            angle = 2 * time * np.real(pauli_string.coefficient)
+            self._apply_pauli_rotation(circuit, pauli_string.pauli_ops, angle)
+
+    def _apply_pauli_rotation(
+        self,
+        circuit: QuantumCircuit,
+        pauli_ops: str,
+        angle: float
+    ) -> None:
+        """Apply Pauli string rotation to circuit"""
+        # Find qubits involved in non-identity operations
+        active_qubits = [i for i, op in enumerate(pauli_ops) if op != 'I']
+
+        if not active_qubits:
+            return  # All identity, no rotation needed
+
+        # Change basis for X and Y measurements
+        for i in active_qubits:
+            if pauli_ops[i] == 'X':
+                circuit.h(i)
+            elif pauli_ops[i] == 'Y':
+                circuit.rx(np.pi/2, i)
+
+        # Apply ZZ...Z rotation using CNOT ladder
+        if len(active_qubits) == 1:
+            circuit.rz(angle, active_qubits[0])
+        else:
+            # CNOT ladder
+            for i in range(len(active_qubits) - 1):
+                circuit.cnot(active_qubits[i], active_qubits[-1])
+
+            # Rotation on last qubit
+            circuit.rz(angle, active_qubits[-1])
+
+            # Reverse CNOT ladder
+            for i in reversed(range(len(active_qubits) - 1)):
+                circuit.cnot(active_qubits[i], active_qubits[-1])
+
+        # Reverse basis change
+        for i in active_qubits:
+            if pauli_ops[i] == 'X':
+                circuit.h(i)
+            elif pauli_ops[i] == 'Y':
+                circuit.rx(-np.pi/2, i)
+
+    def cost_function(self, parameters: np.ndarray) -> float:
+        """QAOA cost function"""
+        circuit = self.create_qaoa_circuit(parameters)
+
+        if self.client is None:
+            # Simulate locally
+            state = self._simulate_circuit(circuit)
+            energy = float(np.real(self.cost_hamiltonian.expectation_value(state)))
+        else:
+            # Execute on quantum backend
+            energy = self._execute_expectation_value(circuit, self.cost_hamiltonian)
+
+        return energy
+
+    def _simulate_circuit(self, circuit: QuantumCircuit) -> np.ndarray:
+        """Simulate QAOA circuit"""
+        # Simplified simulation - would use proper quantum simulator
+        return np.ones(2 ** circuit.num_qubits, dtype=complex) / np.sqrt(2 ** circuit.num_qubits)
+
+    def _execute_expectation_value(
+        self,
+        circuit: QuantumCircuit,
+        hamiltonian: Hamiltonian
+    ) -> float:
+        """Execute expectation value on quantum backend"""
+        # Similar to VQE implementation
+        return 0.0  # Placeholder
+
+    def run(
+        self,
+        initial_parameters: Optional[np.ndarray] = None,
+        **optimizer_kwargs
+    ) -> Dict[str, Any]:
+        """Run QAOA optimization
+        
+        Args:
+            initial_parameters: Initial [beta, gamma] parameters
+            **optimizer_kwargs: Additional optimizer options
+            
+        Returns:
+            QAOA results
+
+        """
+        if initial_parameters is None:
+            # Random initialization
+            initial_parameters = np.random.uniform(0, 2*np.pi, 2*self.p)
+
+        result = minimize(
+            fun=self.cost_function,
+            x0=initial_parameters,
+            method=self.optimizer,
+            **optimizer_kwargs
+        )
+
+        optimal_circuit = self.create_qaoa_circuit(result.x)
+
+        return {
+            "optimal_energy": result.fun,
+            "optimal_parameters": result.x,
+            "optimal_circuit": optimal_circuit,
+            "converged": result.success,
+            "num_iterations": result.nit
+        }
+
+
+class QuantumNeuralNetwork(BaseEstimator):
+    """Quantum Neural Network for machine learning tasks
+    """
+
+    def __init__(
+        self,
+        num_qubits: int,
+        num_layers: int = 2,
+        entangling_gates: str = "CNOT",
+        client: Optional[SuperQuantXClient] = None,
+        optimizer: str = "SLSQP",
+        learning_rate: float = 0.01
+    ):
+        """Initialize Quantum Neural Network
+        
+        Args:
+            num_qubits: Number of qubits
+            num_layers: Number of variational layers
+            entangling_gates: Type of entangling gates
+            client: SuperQuantX client
+            optimizer: Classical optimizer
+            learning_rate: Learning rate for optimization
+
+        """
+        self.num_qubits = num_qubits
+        self.num_layers = num_layers
+        self.entangling_gates = entangling_gates
+        self.client = client
+        self.optimizer = optimizer
+        self.learning_rate = learning_rate
+
+        # Calculate number of parameters
+        self.num_parameters = num_qubits * num_layers * 3  # 3 rotation angles per qubit per layer
+        self.parameters: Optional[np.ndarray] = None
+
+        self.is_fitted_ = False
+
+    def create_ansatz(self, parameters: np.ndarray, x: Optional[np.ndarray] = None) -> QuantumCircuit:
+        """Create parameterized quantum circuit ansatz
+        
+        Args:
+            parameters: Variational parameters
+            x: Input data for encoding (optional)
+            
+        Returns:
+            Quantum circuit
+
+        """
+        circuit = QuantumCircuit(self.num_qubits)
+
+        # Data encoding (amplitude encoding)
+        if x is not None:
+            self._encode_data(circuit, x)
+
+        param_idx = 0
+        for layer in range(self.num_layers):
+            # Parameterized single-qubit rotations
+            for qubit in range(self.num_qubits):
+                circuit.rx(parameters[param_idx], qubit)
+                circuit.ry(parameters[param_idx + 1], qubit)
+                circuit.rz(parameters[param_idx + 2], qubit)
+                param_idx += 3
+
+            # Entangling gates
+            if layer < self.num_layers - 1:  # No entangling on last layer
+                self._add_entangling_layer(circuit)
+
+        return circuit
+
+    def _encode_data(self, circuit: QuantumCircuit, x: np.ndarray) -> None:
+        """Encode classical data into quantum circuit"""
+        # Simple angle encoding
+        for i, value in enumerate(x[:self.num_qubits]):
+            circuit.ry(value, i)
+
+    def _add_entangling_layer(self, circuit: QuantumCircuit) -> None:
+        """Add entangling gates between qubits"""
+        if self.entangling_gates == "CNOT":
+            for i in range(self.num_qubits - 1):
+                circuit.cnot(i, i + 1)
+        elif self.entangling_gates == "CZ":
+            for i in range(self.num_qubits - 1):
+                circuit.cz(i, i + 1)
+        else:
+            raise ValueError(f"Unknown entangling gates: {self.entangling_gates}")
+
+    def forward(self, X: np.ndarray, parameters: np.ndarray) -> np.ndarray:
+        """Forward pass through quantum neural network
+        
+        Args:
+            X: Input data
+            parameters: Network parameters
+            
+        Returns:
+            Output predictions
+
+        """
+        predictions = []
+
+        for x in X:
+            circuit = self.create_ansatz(parameters, x)
+
+            # Add measurement
+            circuit.measure(0, 0)  # Measure first qubit
+
+            if self.client is None:
+                # Simulate locally
+                prob_0 = self._simulate_measurement_probability(circuit)
+            else:
+                # Execute on quantum backend
+                prob_0 = self._execute_measurement_probability(circuit)
+
+            # Convert probability to prediction
+            prediction = 2 * prob_0 - 1  # Map [0,1] to [-1,1]
+            predictions.append(prediction)
+
+        return np.array(predictions)
+
+    def _simulate_measurement_probability(self, circuit: QuantumCircuit) -> float:
+        """Simulate measurement probability"""
+        # Simplified simulation
+        return 0.5  # Placeholder
+
+    def _execute_measurement_probability(self, circuit: QuantumCircuit) -> float:
+        """Execute measurement on quantum backend"""
+        if self.client is None:
+            raise ValueError("Client required for quantum execution")
+
+        job = self.client.submit_job_sync(
+            circuit_data=circuit.to_dict(),
+            shots=1024
+        )
+        result = self.client.wait_for_job_sync(job.job_id)
+
+        counts = result.results.get("counts", {})
+        total_shots = sum(counts.values())
+
+        # Probability of measuring |0⟩
+        prob_0 = counts.get("0", 0) / total_shots if total_shots > 0 else 0.5
+        return prob_0
+
+    def loss_function(self, parameters: np.ndarray, X: np.ndarray, y: np.ndarray) -> float:
+        """Calculate loss function"""
+        predictions = self.forward(X, parameters)
+        # Mean squared error
+        return np.mean((predictions - y) ** 2)
+
+    def fit(self, X: np.ndarray, y: np.ndarray) -> "QuantumNeuralNetwork":
+        """Fit the quantum neural network
+        
+        Args:
+            X: Training data
+            y: Training labels
+            
+        Returns:
+            Fitted model
+
+        """
+        # Initialize parameters
+        initial_parameters = np.random.uniform(0, 2*np.pi, self.num_parameters)
+
+        # Optimize parameters
+        result = minimize(
+            fun=lambda params: self.loss_function(params, X, y),
+            x0=initial_parameters,
+            method=self.optimizer
+        )
+
+        self.parameters = result.x
+        self.is_fitted_ = True
+
+        return self
+
+    def predict(self, X: np.ndarray) -> np.ndarray:
+        """Make predictions
+        
+        Args:
+            X: Input data
+            
+        Returns:
+            Predictions
+
+        """
+        if not self.is_fitted_:
+            raise ValueError("Model must be fitted before making predictions")
+
+        return self.forward(X, self.parameters)
+
+    def score(self, X: np.ndarray, y: np.ndarray) -> float:
+        """Calculate R² score
+        
+        Args:
+            X: Test data
+            y: True labels
+            
+        Returns:
+            R² score
+
+        """
+        predictions = self.predict(X)
+        ss_res = np.sum((y - predictions) ** 2)
+        ss_tot = np.sum((y - np.mean(y)) ** 2)
+        return 1 - (ss_res / ss_tot) if ss_tot != 0 else 0.0
+
+
+class QuantumFourierTransform(QuantumAlgorithm):
+    """Quantum Fourier Transform implementation
+    """
+
+    def __init__(self, num_qubits: int, client: Optional[SuperQuantXClient] = None):
+        """Initialize QFT
+        
+        Args:
+            num_qubits: Number of qubits
+            client: SuperQuantX client
+
+        """
+        super().__init__(client)
+        self.num_qubits = num_qubits
+
+    def create_qft_circuit(self, inverse: bool = False) -> QuantumCircuit:
+        """Create QFT circuit
+        
+        Args:
+            inverse: Whether to create inverse QFT
+            
+        Returns:
+            QFT circuit
+
+        """
+        circuit = QuantumCircuit(self.num_qubits)
+
+        if inverse:
+            # Inverse QFT: reverse the forward QFT
+            qft_circuit = self.create_qft_circuit(inverse=False)
+            return qft_circuit.inverse()
+
+        # Forward QFT
+        for j in range(self.num_qubits):
+            # Apply Hadamard
+            circuit.h(j)
+
+            # Apply controlled phase rotations
+            for k in range(j + 1, self.num_qubits):
+                angle = np.pi / (2 ** (k - j))
+                circuit.crz(angle, k, j)
+
+        # Reverse qubit order
+        for i in range(self.num_qubits // 2):
+            circuit.swap(i, self.num_qubits - 1 - i)
+
+        return circuit
+
+    def run(self, initial_state: Optional[np.ndarray] = None) -> Dict[str, Any]:
+        """Execute QFT
+        
+        Args:
+            initial_state: Initial quantum state
+            
+        Returns:
+            QFT results
+
+        """
+        circuit = self.create_qft_circuit()
+
+        if self.client is None:
+            # Local simulation
+            if initial_state is None:
+                initial_state = np.zeros(2 ** self.num_qubits, dtype=complex)
+                initial_state[0] = 1.0
+
+            # Apply QFT (simplified)
+            fourier_state = np.fft.fft(initial_state) / np.sqrt(len(initial_state))
+
+            return {
+                "circuit": circuit,
+                "initial_state": initial_state,
+                "fourier_state": fourier_state
+            }
+        else:
+            # Execute on quantum backend
+            job = self.client.submit_job_sync(circuit_data=circuit.to_dict())
+            result = self.client.wait_for_job_sync(job.job_id)
+
+            return {
+                "circuit": circuit,
+                "job_result": result
+            }
+
+
+# Factory functions for common algorithms
+def create_vqe_for_molecule(
+    molecule_name: str,
+    basis_set: str = "sto-3g",
+    client: Optional[SuperQuantXClient] = None
+) -> VQE:
+    """Create VQE instance for molecular ground state calculation
+    
+    Args:
+        molecule_name: Molecule identifier (e.g., "H2", "LiH")
+        basis_set: Quantum chemistry basis set
+        client: SuperQuantX client
+        
+    Returns:
+        Configured VQE instance
+
+    """
+    # This would interface with quantum chemistry libraries
+    # For now, create a simple Hamiltonian
+
+    if molecule_name.upper() == "H2":
+        # Simple H2 Hamiltonian (placeholder)
+        hamiltonian = Hamiltonian.from_dict({
+            "ZZ": -1.0523732,
+            "ZI": -0.39793742,
+            "IZ": -0.39793742,
+            "XX": -0.01128010,
+            "YY": 0.01128010
+        })
+
+        def h2_ansatz(params):
+            circuit = QuantumCircuit(2)
+            circuit.h(0)
+            circuit.h(1)
+            circuit.ry(params[0], 0)
+            circuit.ry(params[1], 1)
+            circuit.cnot(0, 1)
+            return circuit
+
+        return VQE(hamiltonian, h2_ansatz, client)
+
+    else:
+        raise ValueError(f"Molecule {molecule_name} not implemented")
+
+
+def create_qaoa_for_max_cut(
+    graph_edges: List[Tuple[int, int]],
+    num_nodes: int,
+    p: int = 1,
+    client: Optional[SuperQuantXClient] = None
+) -> QAOA:
+    """Create QAOA instance for Max-Cut problem
+    
+    Args:
+        graph_edges: List of graph edges as (node1, node2) tuples
+        num_nodes: Number of nodes in graph
+        p: QAOA depth parameter
+        client: SuperQuantX client
+        
+    Returns:
+        Configured QAOA instance
+
+    """
+    # Build Max-Cut Hamiltonian
+    pauli_strings = []
+
+    for edge in graph_edges:
+        i, j = edge
+        if i < num_nodes and j < num_nodes:
+            # Add ZZ term for edge (i,j)
+            zz_ops = ['I'] * num_nodes
+            zz_ops[i] = 'Z'
+            zz_ops[j] = 'Z'
+            pauli_strings.append(PauliString(''.join(zz_ops), 0.5))
+
+    cost_hamiltonian = Hamiltonian(pauli_strings)
+
+    return QAOA(cost_hamiltonian, p=p, client=client)