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

superquantx/algorithms.py

@@ -2,7 +2,8 @@
 """
 
 from abc import ABC, abstractmethod
-from typing import Any, Callable, Dict, List, Optional, Tuple
+from collections.abc import Callable
+from typing import Any
 
 import numpy as np
 from scipy.optimize import minimize
@@ -17,18 +18,18 @@ class QuantumAlgorithm(ABC):
     """Base class for quantum algorithms
     """
 
-    def __init__(self, client: Optional[SuperQuantXClient] = None):
+    def __init__(self, client: SuperQuantXClient | None = None):
         """Initialize quantum algorithm
-        
+
         Args:
             client: SuperQuantX client for quantum execution
 
         """
         self.client = client
-        self.result_history: List[Dict[str, Any]] = []
+        self.result_history: list[dict[str, Any]] = []
 
     @abstractmethod
-    def run(self, *args, **kwargs) -> Dict[str, Any]:
+    def run(self, *args, **kwargs) -> dict[str, Any]:
         """Execute the quantum algorithm"""
         pass
 
@@ -45,13 +46,13 @@ class VQE(QuantumAlgorithm):
         self,
         hamiltonian: Hamiltonian,
         ansatz: Callable[[np.ndarray], QuantumCircuit],
-        client: Optional[SuperQuantXClient] = None,
+        client: SuperQuantXClient | None = None,
         optimizer: str = "SLSQP",
         max_iterations: int = 1000,
         tolerance: float = 1e-6
     ):
         """Initialize VQE algorithm
-        
+
         Args:
             hamiltonian: Target Hamiltonian
             ansatz: Parameterized quantum circuit ansatz
@@ -68,16 +69,16 @@ class VQE(QuantumAlgorithm):
         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] = []
+        self.optimal_parameters: np.ndarray | None = None
+        self.optimal_energy: float | None = 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
 
@@ -171,7 +172,7 @@ class VQE(QuantumAlgorithm):
 
         for i in range(dim):
             control_bit = (i >> control) & 1
-            target_bit = (i >> target) & 1
+            (i >> target) & 1
 
             if control_bit == 1:
                 # Flip target bit
@@ -232,7 +233,7 @@ class VQE(QuantumAlgorithm):
 
     def _calculate_pauli_expectation(
         self,
-        measurement_results: Dict[str, Any],
+        measurement_results: dict[str, Any],
         pauli_string: PauliString
     ) -> float:
         """Calculate expectation value from measurement results"""
@@ -258,15 +259,15 @@ class VQE(QuantumAlgorithm):
 
     def run(
         self,
-        initial_parameters: Optional[np.ndarray] = None,
+        initial_parameters: np.ndarray | None = None,
         **optimizer_kwargs
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Run VQE optimization
-        
+
         Args:
             initial_parameters: Initial parameter values
             **optimizer_kwargs: Additional optimizer parameters
-            
+
         Returns:
             VQE results dictionary
 
@@ -312,13 +313,13 @@ class QAOA(QuantumAlgorithm):
     def __init__(
         self,
         cost_hamiltonian: Hamiltonian,
-        mixer_hamiltonian: Optional[Hamiltonian] = None,
+        mixer_hamiltonian: Hamiltonian | None = None,
         p: int = 1,
-        client: Optional[SuperQuantXClient] = None,
+        client: SuperQuantXClient | None = None,
         optimizer: str = "SLSQP"
     ):
         """Initialize QAOA
-        
+
         Args:
             cost_hamiltonian: Problem Hamiltonian
             mixer_hamiltonian: Mixer Hamiltonian (default: X on all qubits)
@@ -345,10 +346,10 @@ class QAOA(QuantumAlgorithm):
 
     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
 
@@ -458,15 +459,15 @@ class QAOA(QuantumAlgorithm):
 
     def run(
         self,
-        initial_parameters: Optional[np.ndarray] = None,
+        initial_parameters: np.ndarray | None = None,
         **optimizer_kwargs
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Run QAOA optimization
-        
+
         Args:
             initial_parameters: Initial [beta, gamma] parameters
             **optimizer_kwargs: Additional optimizer options
-            
+
         Returns:
             QAOA results
 
@@ -502,12 +503,12 @@ class QuantumNeuralNetwork(BaseEstimator):
         num_qubits: int,
         num_layers: int = 2,
         entangling_gates: str = "CNOT",
-        client: Optional[SuperQuantXClient] = None,
+        client: SuperQuantXClient | None = 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
@@ -526,17 +527,17 @@ class QuantumNeuralNetwork(BaseEstimator):
 
         # 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.parameters: np.ndarray | None = None
 
         self.is_fitted_ = False
 
-    def create_ansatz(self, parameters: np.ndarray, x: Optional[np.ndarray] = None) -> QuantumCircuit:
+    def create_ansatz(self, parameters: np.ndarray, x: np.ndarray | None = None) -> QuantumCircuit:
         """Create parameterized quantum circuit ansatz
-        
+
         Args:
             parameters: Variational parameters
             x: Input data for encoding (optional)
-            
+
         Returns:
             Quantum circuit
 
@@ -581,11 +582,11 @@ class QuantumNeuralNetwork(BaseEstimator):
 
     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
 
@@ -642,11 +643,11 @@ class QuantumNeuralNetwork(BaseEstimator):
 
     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
 
@@ -668,10 +669,10 @@ class QuantumNeuralNetwork(BaseEstimator):
 
     def predict(self, X: np.ndarray) -> np.ndarray:
         """Make predictions
-        
+
         Args:
             X: Input data
-            
+
         Returns:
             Predictions
 
@@ -683,11 +684,11 @@ class QuantumNeuralNetwork(BaseEstimator):
 
     def score(self, X: np.ndarray, y: np.ndarray) -> float:
         """Calculate R² score
-        
+
         Args:
             X: Test data
             y: True labels
-            
+
         Returns:
             R² score
 
@@ -702,9 +703,9 @@ class QuantumFourierTransform(QuantumAlgorithm):
     """Quantum Fourier Transform implementation
     """
 
-    def __init__(self, num_qubits: int, client: Optional[SuperQuantXClient] = None):
+    def __init__(self, num_qubits: int, client: SuperQuantXClient | None = None):
         """Initialize QFT
-        
+
         Args:
             num_qubits: Number of qubits
             client: SuperQuantX client
@@ -715,10 +716,10 @@ class QuantumFourierTransform(QuantumAlgorithm):
 
     def create_qft_circuit(self, inverse: bool = False) -> QuantumCircuit:
         """Create QFT circuit
-        
+
         Args:
             inverse: Whether to create inverse QFT
-            
+
         Returns:
             QFT circuit
 
@@ -746,12 +747,12 @@ class QuantumFourierTransform(QuantumAlgorithm):
 
         return circuit
 
-    def run(self, initial_state: Optional[np.ndarray] = None) -> Dict[str, Any]:
+    def run(self, initial_state: np.ndarray | None = None) -> dict[str, Any]:
         """Execute QFT
-        
+
         Args:
             initial_state: Initial quantum state
-            
+
         Returns:
             QFT results
 
@@ -787,15 +788,15 @@ class QuantumFourierTransform(QuantumAlgorithm):
 def create_vqe_for_molecule(
     molecule_name: str,
     basis_set: str = "sto-3g",
-    client: Optional[SuperQuantXClient] = None
+    client: SuperQuantXClient | None = 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
 
@@ -829,19 +830,19 @@ def create_vqe_for_molecule(
 
 
 def create_qaoa_for_max_cut(
-    graph_edges: List[Tuple[int, int]],
+    graph_edges: list[tuple[int, int]],
     num_nodes: int,
     p: int = 1,
-    client: Optional[SuperQuantXClient] = None
+    client: SuperQuantXClient | None = 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
 

superquantx/backends/__init__.py

@@ -85,20 +85,20 @@ BACKEND_ALIASES = {
     'local': 'simulator',
 }
 
-def get_backend(backend: Union[str, BaseBackend], **kwargs) -> BaseBackend:
+def get_backend(backend: str | BaseBackend, **kwargs) -> BaseBackend:
     """Get a quantum backend instance.
-    
+
     Args:
         backend: Backend name or instance
         **kwargs: Backend configuration parameters
-        
+
     Returns:
         Backend instance
-        
+
     Raises:
         ValueError: If backend is not supported
         ImportError: If backend dependencies are missing
-        
+
     Example:
         >>> backend = get_backend('pennylane', device='default.qubit')
         >>> backend = get_backend('qiskit', provider='IBMQ')
@@ -136,7 +136,7 @@ def get_backend(backend: Union[str, BaseBackend], **kwargs) -> BaseBackend:
 
 def _auto_select_backend() -> str:
     """Automatically select the best available backend.
-    
+
     Returns:
         Backend name
 
@@ -148,7 +148,7 @@ def _auto_select_backend() -> str:
         try:
             backend_class = BACKEND_REGISTRY[backend_name]
             # Try to instantiate with minimal config
-            test_backend = backend_class()
+            backend_class()
             logger.info(f"Auto-selected backend: {backend_name}")
             return backend_name
         except (ImportError, Exception) as e:
@@ -159,9 +159,9 @@ def _auto_select_backend() -> str:
     logger.warning("No preferred backends available, falling back to simulator")
     return 'simulator'
 
-def list_available_backends() -> Dict[str, Dict[str, Any]]:
+def list_available_backends() -> dict[str, dict[str, Any]]:
     """List all available backends and their status.
-    
+
     Returns:
         Dictionary with backend information
 
@@ -196,12 +196,12 @@ def list_available_backends() -> Dict[str, Dict[str, Any]]:
 
     return backend_info
 
-def check_backend_compatibility(backend_name: str) -> Dict[str, Any]:
+def check_backend_compatibility(backend_name: str) -> dict[str, Any]:
     """Check compatibility and requirements for a specific backend.
-    
+
     Args:
         backend_name: Name of the backend to check
-        
+
     Returns:
         Compatibility information
 

superquantx/backends/base_backend.py

@@ -6,7 +6,7 @@ must implement to work with SuperQuantX algorithms.
 
 import logging
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional, Union
+from typing import Any
 
 import numpy as np
 
@@ -15,11 +15,11 @@ logger = logging.getLogger(__name__)
 
 class BaseBackend(ABC):
     """Abstract base class for quantum computing backends.
-    
+
     This class defines the interface that all quantum backends must implement
     to provide quantum circuit execution, measurement, and algorithm-specific
     operations for SuperQuantX.
-    
+
     Args:
         device: Device or simulator to use
         shots: Default number of measurement shots
@@ -27,7 +27,7 @@ class BaseBackend(ABC):
 
     """
 
-    def __init__(self, device: Optional[str] = None, shots: int = 1024, **kwargs):
+    def __init__(self, device: str | None = None, shots: int = 1024, **kwargs):
         self.device = device
         self.shots = shots
         self.config = kwargs
@@ -50,18 +50,18 @@ class BaseBackend(ABC):
         pass
 
     @abstractmethod
-    def add_gate(self, circuit: Any, gate: str, qubits: Union[int, List[int]],
-                 params: Optional[List[float]] = None) -> Any:
+    def add_gate(self, circuit: Any, gate: str, qubits: int | list[int],
+                 params: list[float] | None = None) -> Any:
         """Add a quantum gate to the circuit."""
         pass
 
     @abstractmethod
-    def add_measurement(self, circuit: Any, qubits: Optional[List[int]] = None) -> Any:
+    def add_measurement(self, circuit: Any, qubits: list[int] | None = None) -> Any:
         """Add measurement operations to the circuit."""
         pass
 
     @abstractmethod
-    def execute_circuit(self, circuit: Any, shots: Optional[int] = None) -> Dict[str, Any]:
+    def execute_circuit(self, circuit: Any, shots: int | None = None) -> dict[str, Any]:
         """Execute quantum circuit and return results."""
         pass
 
@@ -80,7 +80,7 @@ class BaseBackend(ABC):
         return self.create_circuit(n_features)
 
     def compute_kernel_matrix(self, X1: np.ndarray, X2: np.ndarray,
-                            feature_map: Any, shots: Optional[int] = None) -> np.ndarray:
+                            feature_map: Any, shots: int | None = None) -> np.ndarray:
         """Compute quantum kernel matrix between data points."""
         logger.warning(f"Kernel matrix computation not implemented in {self.__class__.__name__}")
         # Fallback to RBF kernel
@@ -94,7 +94,7 @@ class BaseBackend(ABC):
         return self.create_circuit(n_qubits)
 
     def compute_expectation(self, circuit: Any, hamiltonian: Any,
-                          shots: Optional[int] = None) -> float:
+                          shots: int | None = None) -> float:
         """Compute expectation value of Hamiltonian."""
         logger.warning(f"Expectation computation not implemented in {self.__class__.__name__}")
         return 0.0
@@ -107,12 +107,12 @@ class BaseBackend(ABC):
         return self.create_circuit(n_qubits)
 
     def execute_qaoa(self, circuit: Any, problem_hamiltonian: Any, problem_instance: Any,
-                    shots: Optional[int] = None) -> float:
+                    shots: int | None = None) -> float:
         """Execute QAOA circuit and return expectation value."""
         logger.warning(f"QAOA execution not implemented in {self.__class__.__name__}")
         return 0.0
 
-    def sample_circuit(self, circuit: Any, shots: Optional[int] = None) -> np.ndarray:
+    def sample_circuit(self, circuit: Any, shots: int | None = None) -> np.ndarray:
         """Sample bit strings from quantum circuit."""
         result = self.execute_circuit(circuit, shots)
         # Convert result to bit string array
@@ -141,9 +141,9 @@ class BaseBackend(ABC):
         # Normalize data
         norm = np.linalg.norm(data)
         if norm > 0:
-            normalized_data = data / norm
+            data / norm
         else:
-            normalized_data = data
+            pass
 
         # Simple implementation - would need proper state preparation
         logger.warning("Amplitude encoding not fully implemented")
@@ -173,8 +173,8 @@ class BaseBackend(ABC):
                                 encoding: str, n_qubits: int, shots: int) -> float:
         """Compute quantum distance between two data points."""
         # Encode both data points
-        circuit1 = self.encode_data_point(x1, encoding, n_qubits)
-        circuit2 = self.encode_data_point(x2, encoding, n_qubits)
+        self.encode_data_point(x1, encoding, n_qubits)
+        self.encode_data_point(x2, encoding, n_qubits)
 
         # Simple distance approximation using overlap
         # This is a placeholder - actual implementation would use swap test or similar
@@ -186,10 +186,10 @@ class BaseBackend(ABC):
             return np.linalg.norm(x1 - x2)
 
     def execute_qnn(self, input_data: np.ndarray, weights: np.ndarray,
-                   quantum_layers: List[Dict], classical_layers: List[Dict],
+                   quantum_layers: list[dict], classical_layers: list[dict],
                    encoding: str, measurement: str, shots: int) -> np.ndarray:
         """Execute quantum neural network."""
-        batch_size = input_data.shape[0]
+        input_data.shape[0]
         n_qubits = len(weights) // len(quantum_layers) if quantum_layers else 1
 
         # Get expected output size from classical layers
@@ -226,7 +226,7 @@ class BaseBackend(ABC):
                 result = self._result_to_probabilities(result)
 
             # Apply classical layers if present
-            original_length = len(result)
+            len(result)
             if classical_layers and expected_output_size:
                 # Simple linear transformation to get desired output size
                 if len(result) != expected_output_size:
@@ -271,7 +271,7 @@ class BaseBackend(ABC):
         """Get number of qubits in circuit."""
         pass
 
-    def _result_to_bitstrings(self, result: Dict[str, Any]) -> np.ndarray:
+    def _result_to_bitstrings(self, result: dict[str, Any]) -> np.ndarray:
         """Convert execution result to bit string array."""
         # This is backend-specific and should be overridden
         if 'counts' in result:
@@ -284,7 +284,7 @@ class BaseBackend(ABC):
         else:
             return np.array([[0, 1]])  # Placeholder
 
-    def _result_to_probabilities(self, result: Dict[str, Any]) -> np.ndarray:
+    def _result_to_probabilities(self, result: dict[str, Any]) -> np.ndarray:
         """Convert execution result to probability array."""
         if 'counts' in result:
             counts = result['counts']
@@ -296,20 +296,21 @@ class BaseBackend(ABC):
         else:
             return np.array([0.5, 0.5])  # Placeholder
 
-    def _compute_pauli_expectation(self, circuit: Any, pauli_strings: List[str]) -> np.ndarray:
+    def _compute_pauli_expectation(self, circuit: Any, pauli_strings: list[str]) -> np.ndarray:
         """Compute expectation values of Pauli strings."""
         # Placeholder implementation
         return np.random.random(len(pauli_strings)) * 2 - 1
 
-    def get_version_info(self) -> Dict[str, Any]:
+    def get_version_info(self) -> dict[str, Any]:
         """Get backend version information."""
         return {
             'backend_name': self.__class__.__name__,
             'device': self.device,
             'capabilities': self.capabilities,
+            'backend_version': '1.0.0',  # Default backend version
         }
 
-    def get_device_info(self) -> Dict[str, Any]:
+    def get_device_info(self) -> dict[str, Any]:
         """Get information about the quantum device."""
         return {
             'device': self.device,