superquantx 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

superquantx/backends/braket_backend.py

@@ -5,7 +5,7 @@ on AWS quantum hardware and simulators.
 """
 
 import logging
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any
 
 import numpy as np
 
@@ -23,7 +23,7 @@ try:
     try:
         from braket.aws import AwsDevice
         AWS_AVAILABLE = True
-    except:
+    except ImportError:
         AWS_AVAILABLE = False
     BRAKET_AVAILABLE = True
 except ImportError:
@@ -34,22 +34,22 @@ except ImportError:
 
 class BraketBackend(BaseBackend):
     """AWS Braket backend for quantum computing operations.
-    
+
     This backend provides access to AWS Braket's quantum devices including
     local simulators, managed simulators, and QPU hardware from IonQ, Rigetti,
     and other providers available on AWS.
-    
+
     Args:
         device: Device name or ARN (e.g., 'local:braket/braket_sv', 'arn:aws:braket::device/qpu/ionq/ionQdevice')
         shots: Number of measurement shots
         aws_session: Optional AWS session for authentication
         s3_folder: S3 bucket folder for results (required for hardware)
         **kwargs: Additional device configuration
-        
+
     Example:
         >>> # Local simulator
         >>> backend = BraketBackend(device='local:braket/braket_sv')
-        >>> 
+        >>>
         >>> # AWS hardware (requires authentication)
         >>> backend = BraketBackend(
         ...     device='arn:aws:braket::device/qpu/ionq/ionQdevice',
@@ -63,7 +63,7 @@ class BraketBackend(BaseBackend):
         device: str = 'local:braket/braket_sv',
         shots: int = 1024,
         aws_session = None,
-        s3_folder: Optional[Tuple[str, str]] = None,
+        s3_folder: tuple[str, str] | None = None,
         **kwargs
     ) -> None:
         if not BRAKET_AVAILABLE:
@@ -122,7 +122,7 @@ class BraketBackend(BaseBackend):
         if hasattr(self._device, 'properties'):
             try:
                 return self._device.properties.paradigm.qubit_count
-            except:
+            except (AttributeError, Exception):
                 pass
         # Default estimates
         if 'sv' in self.device_name:
@@ -134,7 +134,7 @@ class BraketBackend(BaseBackend):
         else:
             return 30  # Conservative estimate for hardware
 
-    def _get_native_gates(self) -> List[str]:
+    def _get_native_gates(self) -> list[str]:
         """Get native gates supported by the device."""
         # Common Braket gates
         return [
@@ -155,8 +155,8 @@ class BraketBackend(BaseBackend):
 
         return BraketCircuit()
 
-    def add_gate(self, circuit: BraketCircuit, gate: str, qubits: Union[int, List[int]],
-                 params: Optional[List[float]] = None) -> BraketCircuit:
+    def add_gate(self, circuit: BraketCircuit, gate: str, qubits: int | list[int],
+                 params: list[float] | None = None) -> BraketCircuit:
         """Add a quantum gate to the circuit."""
         if isinstance(qubits, int):
             qubits = [qubits]
@@ -209,7 +209,7 @@ class BraketBackend(BaseBackend):
 
         return circuit
 
-    def add_measurement(self, circuit: BraketCircuit, qubits: Union[int, List[int]]) -> BraketCircuit:
+    def add_measurement(self, circuit: BraketCircuit, qubits: int | list[int]) -> BraketCircuit:
         """Add measurement instructions to specified qubits."""
         if isinstance(qubits, int):
             qubits = [qubits]
@@ -223,7 +223,7 @@ class BraketBackend(BaseBackend):
 
         return circuit
 
-    def execute_circuit(self, circuit: BraketCircuit, shots: Optional[int] = None) -> Dict[str, Any]:
+    def execute_circuit(self, circuit: BraketCircuit, shots: int | None = None) -> dict[str, Any]:
         """Execute quantum circuit and return results."""
         shots = shots or self.shots
 
@@ -281,7 +281,7 @@ class BraketBackend(BaseBackend):
     # Algorithm-Specific Operations
     # ========================================================================
 
-    def create_parameterized_circuit(self, n_qubits: int, n_params: int) -> Tuple[BraketCircuit, List[str]]:
+    def create_parameterized_circuit(self, n_qubits: int, n_params: int) -> tuple[BraketCircuit, list[str]]:
         """Create a parameterized quantum circuit for variational algorithms."""
         circuit = self.create_circuit(n_qubits)
 
@@ -294,7 +294,7 @@ class BraketBackend(BaseBackend):
 
         return circuit, param_names
 
-    def bind_parameters(self, circuit: BraketCircuit, param_values: Dict[str, float]) -> BraketCircuit:
+    def bind_parameters(self, circuit: BraketCircuit, param_values: dict[str, float]) -> BraketCircuit:
         """Bind parameter values to parameterized circuit."""
         # Braket handles parameterization differently - would need custom implementation
         # For now, create a new circuit with bound parameters
@@ -306,8 +306,8 @@ class BraketBackend(BaseBackend):
 
         return bound_circuit
 
-    def expectation_value(self, circuit: BraketCircuit, observable: Union[str, np.ndarray],
-                         shots: Optional[int] = None) -> float:
+    def expectation_value(self, circuit: BraketCircuit, observable: str | np.ndarray,
+                         shots: int | None = None) -> float:
         """Calculate expectation value of observable."""
         shots = shots or self.shots
 
@@ -347,7 +347,7 @@ class BraketBackend(BaseBackend):
     # Backend Information
     # ========================================================================
 
-    def get_backend_info(self) -> Dict[str, Any]:
+    def get_backend_info(self) -> dict[str, Any]:
         """Get information about the Braket backend."""
         info = {
             'backend_name': 'braket',
@@ -366,12 +366,12 @@ class BraketBackend(BaseBackend):
                     'provider_name': getattr(props, 'providerName', 'AWS'),
                     'max_qubits': getattr(props.paradigm, 'qubit_count', 'unknown') if hasattr(props, 'paradigm') else 'unknown',
                 })
-            except:
+            except (AttributeError, Exception):
                 pass
 
         return info
 
-    def get_version_info(self) -> Dict[str, str]:
+    def get_version_info(self) -> dict[str, str]:
         """Get version information for Braket dependencies."""
         import braket
         return {
@@ -383,7 +383,7 @@ class BraketBackend(BaseBackend):
         """Check if the backend is available and properly configured."""
         return BRAKET_AVAILABLE and self._device is not None
 
-    def get_circuit_info(self) -> Dict[str, Any]:
+    def get_circuit_info(self) -> dict[str, Any]:
         """Get information about circuit execution capabilities."""
         return {
             'max_qubits': self._get_max_qubits(),

superquantx/backends/cirq_backend.py

@@ -5,7 +5,7 @@ operations and access to Google Quantum AI hardware.
 """
 
 import logging
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Any
 
 import numpy as np
 
@@ -27,10 +27,10 @@ except ImportError:
 
 class CirqBackend(BaseBackend):
     """Cirq backend for quantum computing operations.
-    
+
     This backend provides access to Cirq simulators and Google Quantum AI
     hardware for quantum algorithm execution.
-    
+
     Args:
         device: Cirq device name ('simulator', 'sycamore', etc.)
         processor_id: Google Quantum AI processor ID
@@ -39,7 +39,7 @@ class CirqBackend(BaseBackend):
 
     """
 
-    def __init__(self, device: str = 'simulator', processor_id: Optional[str] = None,
+    def __init__(self, device: str = 'simulator', processor_id: str | None = None,
                  shots: int = 1024, **kwargs):
         if not CIRQ_AVAILABLE:
             raise ImportError("Cirq is required for CirqBackend. Install with: pip install cirq")
@@ -90,8 +90,8 @@ class CirqBackend(BaseBackend):
         circuit = cirq.Circuit()
         return circuit, qubits  # Return both circuit and qubits for convenience
 
-    def add_gate(self, circuit_info: Tuple[Any, List], gate: str,
-                 qubits: Union[int, List[int]], params: Optional[List[float]] = None) -> Tuple[Any, List]:
+    def add_gate(self, circuit_info: tuple[Any, list], gate: str,
+                 qubits: int | list[int], params: list[float] | None = None) -> tuple[Any, list]:
         """Add a quantum gate to the circuit."""
         circuit, qubit_list = circuit_info
 
@@ -131,8 +131,8 @@ class CirqBackend(BaseBackend):
 
         return circuit, qubit_list
 
-    def add_measurement(self, circuit_info: Tuple[Any, List],
-                       qubits: Optional[List[int]] = None) -> Tuple[Any, List]:
+    def add_measurement(self, circuit_info: tuple[Any, list],
+                       qubits: list[int] | None = None) -> tuple[Any, list]:
         """Add measurement operations to the circuit."""
         circuit, qubit_list = circuit_info
 
@@ -144,7 +144,7 @@ class CirqBackend(BaseBackend):
 
         return circuit, qubit_list
 
-    def execute_circuit(self, circuit_info: Union[Any, Tuple], shots: Optional[int] = None) -> Dict[str, Any]:
+    def execute_circuit(self, circuit_info: Any | tuple, shots: int | None = None) -> dict[str, Any]:
         """Execute quantum circuit and return results."""
         if isinstance(circuit_info, tuple):
             circuit, qubit_list = circuit_info
@@ -202,7 +202,7 @@ class CirqBackend(BaseBackend):
             logger.error(f"Circuit execution failed: {e}")
             raise
 
-    def get_statevector(self, circuit_info: Union[Any, Tuple]) -> np.ndarray:
+    def get_statevector(self, circuit_info: Any | tuple) -> np.ndarray:
         """Get the statevector from a quantum circuit."""
         if isinstance(circuit_info, tuple):
             circuit, qubit_list = circuit_info
@@ -227,7 +227,7 @@ class CirqBackend(BaseBackend):
             n_qubits = len(qubit_list)
             return np.array([1.0] + [0.0] * (2**n_qubits - 1))
 
-    def _get_n_qubits(self, circuit_info: Union[Any, Tuple]) -> int:
+    def _get_n_qubits(self, circuit_info: Any | tuple) -> int:
         """Get number of qubits in circuit."""
         if isinstance(circuit_info, tuple):
             circuit, qubit_list = circuit_info
@@ -239,10 +239,10 @@ class CirqBackend(BaseBackend):
     # Enhanced Cirq-specific implementations
     # ========================================================================
 
-    def create_feature_map(self, n_features: int, feature_map: str, reps: int = 1) -> Tuple[Any, List]:
+    def create_feature_map(self, n_features: int, feature_map: str, reps: int = 1) -> tuple[Any, list]:
         """Create quantum feature map for data encoding."""
-        qubits = [cirq.LineQubit(i) for i in range(n_features)]
-        circuit = cirq.Circuit()
+        [cirq.LineQubit(i) for i in range(n_features)]
+        cirq.Circuit()
 
         if feature_map == 'ZZFeatureMap':
             circuit_info = self._create_zz_feature_map(n_features, reps)
@@ -256,7 +256,7 @@ class CirqBackend(BaseBackend):
 
         return circuit_info
 
-    def _create_zz_feature_map(self, n_features: int, reps: int) -> Tuple[Any, List]:
+    def _create_zz_feature_map(self, n_features: int, reps: int) -> tuple[Any, list]:
         """Create ZZ feature map circuit."""
         qubits = [cirq.LineQubit(i) for i in range(n_features)]
         circuit = cirq.Circuit()
@@ -277,7 +277,7 @@ class CirqBackend(BaseBackend):
 
         return circuit, qubits
 
-    def _create_pauli_feature_map(self, n_features: int, reps: int) -> Tuple[Any, List]:
+    def _create_pauli_feature_map(self, n_features: int, reps: int) -> tuple[Any, list]:
         """Create Pauli feature map circuit."""
         qubits = [cirq.LineQubit(i) for i in range(n_features)]
         circuit = cirq.Circuit()
@@ -295,7 +295,7 @@ class CirqBackend(BaseBackend):
 
         return circuit, qubits
 
-    def _create_amplitude_map(self, n_features: int) -> Tuple[Any, List]:
+    def _create_amplitude_map(self, n_features: int) -> tuple[Any, list]:
         """Create amplitude encoding map."""
         n_qubits = int(np.ceil(np.log2(n_features)))
         qubits = [cirq.LineQubit(i) for i in range(n_qubits)]
@@ -307,7 +307,7 @@ class CirqBackend(BaseBackend):
 
         return circuit, qubits
 
-    def _create_angle_encoding_map(self, n_features: int) -> Tuple[Any, List]:
+    def _create_angle_encoding_map(self, n_features: int) -> tuple[Any, list]:
         """Create angle encoding map."""
         qubits = [cirq.LineQubit(i) for i in range(n_features)]
         circuit = cirq.Circuit()
@@ -318,7 +318,7 @@ class CirqBackend(BaseBackend):
         return circuit, qubits
 
     def create_ansatz(self, ansatz_type: str, n_qubits: int, params: np.ndarray,
-                     include_custom_gates: bool = False) -> Tuple[Any, List]:
+                     include_custom_gates: bool = False) -> tuple[Any, list]:
         """Create parameterized ansatz circuit."""
         if ansatz_type == 'RealAmplitudes':
             return self._create_real_amplitudes_ansatz(n_qubits, params)
@@ -332,7 +332,7 @@ class CirqBackend(BaseBackend):
             logger.warning(f"Unknown ansatz '{ansatz_type}', using RealAmplitudes")
             return self._create_real_amplitudes_ansatz(n_qubits, params)
 
-    def _create_real_amplitudes_ansatz(self, n_qubits: int, params: np.ndarray) -> Tuple[Any, List]:
+    def _create_real_amplitudes_ansatz(self, n_qubits: int, params: np.ndarray) -> tuple[Any, list]:
         """Create RealAmplitudes ansatz."""
         qubits = [cirq.LineQubit(i) for i in range(n_qubits)]
         circuit = cirq.Circuit()
@@ -359,7 +359,7 @@ class CirqBackend(BaseBackend):
 
         return circuit, qubits
 
-    def _create_efficient_su2_ansatz(self, n_qubits: int, params: np.ndarray) -> Tuple[Any, List]:
+    def _create_efficient_su2_ansatz(self, n_qubits: int, params: np.ndarray) -> tuple[Any, list]:
         """Create EfficientSU2 ansatz."""
         qubits = [cirq.LineQubit(i) for i in range(n_qubits)]
         circuit = cirq.Circuit()
@@ -382,7 +382,7 @@ class CirqBackend(BaseBackend):
 
         return circuit, qubits
 
-    def _create_two_local_ansatz(self, n_qubits: int, params: np.ndarray) -> Tuple[Any, List]:
+    def _create_two_local_ansatz(self, n_qubits: int, params: np.ndarray) -> tuple[Any, list]:
         """Create TwoLocal ansatz."""
         qubits = [cirq.LineQubit(i) for i in range(n_qubits)]
         circuit = cirq.Circuit()
@@ -406,7 +406,7 @@ class CirqBackend(BaseBackend):
 
         return circuit, qubits
 
-    def _create_uccsd_ansatz(self, n_qubits: int, params: np.ndarray) -> Tuple[Any, List]:
+    def _create_uccsd_ansatz(self, n_qubits: int, params: np.ndarray) -> tuple[Any, list]:
         """Create UCCSD ansatz (simplified)."""
         qubits = [cirq.LineQubit(i) for i in range(n_qubits)]
         circuit = cirq.Circuit()
@@ -434,8 +434,8 @@ class CirqBackend(BaseBackend):
 
         return circuit, qubits
 
-    def compute_expectation(self, circuit_info: Union[Any, Tuple], hamiltonian: Any,
-                          shots: Optional[int] = None) -> float:
+    def compute_expectation(self, circuit_info: Any | tuple, hamiltonian: Any,
+                          shots: int | None = None) -> float:
         """Compute expectation value of Hamiltonian."""
         try:
             if isinstance(hamiltonian, np.ndarray):
@@ -451,7 +451,7 @@ class CirqBackend(BaseBackend):
             logger.error(f"Expectation computation failed: {e}")
             return 0.0
 
-    def get_version_info(self) -> Dict[str, Any]:
+    def get_version_info(self) -> dict[str, Any]:
         """Get Cirq version information."""
         info = super().get_version_info()
 

superquantx/backends/ocean_backend.py

@@ -3,12 +3,12 @@
 This module provides integration with D-Wave Ocean SDK for quantum annealing
 and optimization problems using D-Wave quantum annealing processors.
 
-Note: This backend focuses on QUBO/Ising model problems rather than 
+Note: This backend focuses on QUBO/Ising model problems rather than
 gate-model quantum circuits.
 """
 
 import logging
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any
 
 import numpy as np
 
@@ -35,13 +35,13 @@ except ImportError:
 
 class OceanBackend(BaseBackend):
     """D-Wave Ocean backend for quantum annealing operations.
-    
+
     This backend provides access to D-Wave's quantum annealing systems
     for solving optimization problems formulated as QUBO or Ising models.
-    
+
     Note: Unlike gate-model quantum computers, D-Wave systems solve optimization
     problems rather than running quantum circuits.
-    
+
     Args:
         device: Sampler type ('DWave', 'hybrid', 'simulator', 'advantage')
         solver: Specific solver name (optional)
@@ -49,11 +49,11 @@ class OceanBackend(BaseBackend):
         endpoint: D-Wave API endpoint
         shots: Number of samples (reads)
         **kwargs: Additional sampler configuration
-        
+
     Example:
         >>> # Simulated annealing (no hardware required)
         >>> backend = OceanBackend(device='simulator')
-        >>> 
+        >>>
         >>> # D-Wave hardware (requires API token)
         >>> backend = OceanBackend(
         ...     device='advantage',
@@ -65,9 +65,9 @@ class OceanBackend(BaseBackend):
     def __init__(
         self,
         device: str = 'simulator',
-        solver: Optional[str] = None,
-        token: Optional[str] = None,
-        endpoint: Optional[str] = None,
+        solver: str | None = None,
+        token: str | None = None,
+        endpoint: str | None = None,
         shots: int = 1000,  # Called "num_reads" in D-Wave
         **kwargs
     ) -> None:
@@ -141,7 +141,7 @@ class OceanBackend(BaseBackend):
         if hasattr(self._sampler, 'properties'):
             try:
                 return len(self._sampler.properties['qubits'])
-            except:
+            except (AttributeError, KeyError, Exception):
                 pass
 
         # Default estimates
@@ -156,13 +156,13 @@ class OceanBackend(BaseBackend):
     # Optimization Problem Interface (replaces circuit operations)
     # ========================================================================
 
-    def solve_qubo(self, Q: Dict[Tuple[int, int], float], **kwargs) -> Dict[str, Any]:
+    def solve_qubo(self, Q: dict[tuple[int, int], float], **kwargs) -> dict[str, Any]:
         """Solve a Quadratic Unconstrained Binary Optimization (QUBO) problem.
-        
+
         Args:
             Q: QUBO dictionary where keys are (i, j) variable pairs and values are coefficients
             **kwargs: Additional solving parameters
-            
+
         Returns:
             Solution results with energies and samples
 
@@ -204,14 +204,14 @@ class OceanBackend(BaseBackend):
                 'problem_type': 'QUBO'
             }
 
-    def solve_ising(self, h: Dict[int, float], J: Dict[Tuple[int, int], float], **kwargs) -> Dict[str, Any]:
+    def solve_ising(self, h: dict[int, float], J: dict[tuple[int, int], float], **kwargs) -> dict[str, Any]:
         """Solve an Ising model problem.
-        
+
         Args:
             h: Linear coefficients (bias terms) for each variable
             J: Quadratic coefficients (coupling terms) between variables
             **kwargs: Additional solving parameters
-            
+
         Returns:
             Solution results with energies and samples
 
@@ -253,13 +253,13 @@ class OceanBackend(BaseBackend):
                 'problem_type': 'Ising'
             }
 
-    def solve_optimization_problem(self, problem: Union[Dict, Any], problem_type: str = 'auto') -> Dict[str, Any]:
+    def solve_optimization_problem(self, problem: dict | Any, problem_type: str = 'auto') -> dict[str, Any]:
         """Generic optimization problem solver.
-        
+
         Args:
             problem: Problem specification (QUBO dict, Ising model, or BQM)
             problem_type: Type of problem ('qubo', 'ising', 'bqm', 'auto')
-            
+
         Returns:
             Solution results
 
@@ -296,7 +296,7 @@ class OceanBackend(BaseBackend):
                 'problem_type': problem_type
             }
 
-    def _convert_sampleset(self, sampleset, problem_type: str) -> Dict[str, Any]:
+    def _convert_sampleset(self, sampleset, problem_type: str) -> dict[str, Any]:
         """Convert D-Wave sampleset to standard format."""
         results = {
             'samples': [],
@@ -319,9 +319,9 @@ class OceanBackend(BaseBackend):
     # Gate Model Compatibility (Limited Support)
     # ========================================================================
 
-    def create_circuit(self, n_qubits: int) -> Dict[str, Any]:
+    def create_circuit(self, n_qubits: int) -> dict[str, Any]:
         """Limited circuit support for compatibility.
-        
+
         Note: D-Wave is not a gate-model quantum computer.
         This returns a placeholder for optimization problems.
         """
@@ -333,18 +333,18 @@ class OceanBackend(BaseBackend):
             'problem': None
         }
 
-    def add_gate(self, circuit: Dict, gate: str, qubits: Union[int, List[int]],
-                 params: Optional[List[float]] = None) -> Dict:
+    def add_gate(self, circuit: dict, gate: str, qubits: int | list[int],
+                 params: list[float] | None = None) -> dict:
         """Limited gate support - not applicable for annealing."""
         logger.warning("Gate operations not supported on D-Wave annealing backend")
         return circuit
 
-    def add_measurement(self, circuit: Dict, qubits: Union[int, List[int]]) -> Dict:
+    def add_measurement(self, circuit: dict, qubits: int | list[int]) -> dict:
         """Limited measurement support - not applicable for annealing."""
         logger.warning("Measurements not applicable for D-Wave annealing backend")
         return circuit
 
-    def execute_circuit(self, circuit: Dict, shots: Optional[int] = None) -> Dict[str, Any]:
+    def execute_circuit(self, circuit: dict, shots: int | None = None) -> dict[str, Any]:
         """Limited circuit execution - redirects to optimization solving."""
         logger.warning("Circuit execution not supported - use solve_qubo() or solve_ising() instead")
         return {
@@ -359,7 +359,7 @@ class OceanBackend(BaseBackend):
     # Backend Information
     # ========================================================================
 
-    def get_backend_info(self) -> Dict[str, Any]:
+    def get_backend_info(self) -> dict[str, Any]:
         """Get information about the D-Wave Ocean backend."""
         info = {
             'backend_name': 'ocean',
@@ -379,30 +379,30 @@ class OceanBackend(BaseBackend):
                     'num_qubits': len(props.get('qubits', [])),
                     'connectivity': 'Chimera/Pegasus/Zephyr',  # D-Wave topologies
                 })
-            except:
+            except (AttributeError, Exception):
                 pass
 
         return info
 
-    def get_version_info(self) -> Dict[str, str]:
+    def get_version_info(self) -> dict[str, str]:
         """Get version information for Ocean dependencies."""
         version_info = {'backend_version': '1.0.0'}
 
         try:
             version_info['dimod'] = dimod.__version__
-        except:
+        except (AttributeError, ImportError):
             pass
 
         try:
             import dwave.system
             version_info['dwave_system'] = dwave.system.__version__
-        except:
+        except (ImportError, AttributeError):
             pass
 
         try:
             import dwave.samplers
             version_info['dwave_samplers'] = dwave.samplers.__version__
-        except:
+        except (ImportError, AttributeError):
             pass
 
         return version_info
@@ -411,7 +411,7 @@ class OceanBackend(BaseBackend):
         """Check if the backend is available and properly configured."""
         return OCEAN_AVAILABLE and self._sampler is not None
 
-    def get_circuit_info(self) -> Dict[str, Any]:
+    def get_circuit_info(self) -> dict[str, Any]:
         """Get circuit capabilities (limited for annealing backend)."""
         return {
             'max_qubits': 0,  # Not applicable
@@ -424,13 +424,13 @@ class OceanBackend(BaseBackend):
             'quantum_annealing': True,
         }
 
-    def _get_n_qubits(self, circuit: Dict) -> int:
+    def _get_n_qubits(self, circuit: dict) -> int:
         """Get number of qubits/variables (not applicable for annealing)."""
         if isinstance(circuit, dict):
             return circuit.get('n_variables', 0)
         return 0
 
-    def get_statevector(self, circuit: Dict) -> np.ndarray:
+    def get_statevector(self, circuit: dict) -> np.ndarray:
         """Get statevector (not applicable for annealing backend)."""
         logger.warning("Statevector not applicable for quantum annealing backend")
         return np.array([1.0 + 0j])  # Dummy statevector
@@ -439,7 +439,7 @@ class OceanBackend(BaseBackend):
     # Convenience Methods for Common Optimization Problems
     # ========================================================================
 
-    def solve_max_cut(self, graph: Union[Any, List[Tuple]], **kwargs) -> Dict[str, Any]:
+    def solve_max_cut(self, graph: Any | list[tuple], **kwargs) -> dict[str, Any]:
         """Solve Maximum Cut problem on a graph."""
         try:
             if not nx:
@@ -465,7 +465,7 @@ class OceanBackend(BaseBackend):
             logger.error(f"Max Cut solving failed: {e}")
             return {'success': False, 'error': str(e)}
 
-    def solve_tsp(self, distance_matrix: np.ndarray, **kwargs) -> Dict[str, Any]:
+    def solve_tsp(self, distance_matrix: np.ndarray, **kwargs) -> dict[str, Any]:
         """Solve Traveling Salesman Problem (simplified formulation)."""
         try:
             n_cities = len(distance_matrix)