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

superquantx/utils/classical_utils.py

@@ -7,7 +7,7 @@ including cross-validation, hyperparameter search, and model selection.
 import itertools
 import time
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any
 
 import numpy as np
 from sklearn.metrics import accuracy_score, mean_squared_error
@@ -18,12 +18,12 @@ from sklearn.model_selection import KFold, StratifiedKFold, train_test_split
 class CrossValidationResult:
     """Results from cross-validation."""
 
-    scores: List[float]
+    scores: list[float]
     mean_score: float
     std_score: float
-    fold_times: List[float]
+    fold_times: list[float]
     mean_time: float
-    best_params: Optional[Dict[str, Any]] = None
+    best_params: dict[str, Any] | None = None
 
 
 def cross_validation(
@@ -33,11 +33,11 @@ def cross_validation(
     cv_folds: int = 5,
     scoring: str = 'accuracy',
     stratify: bool = True,
-    random_state: Optional[int] = 42,
+    random_state: int | None = 42,
     verbose: bool = False
 ) -> CrossValidationResult:
     """Perform k-fold cross-validation on quantum algorithm.
-    
+
     Args:
         algorithm: Quantum algorithm instance
         X: Feature matrix
@@ -47,12 +47,12 @@ def cross_validation(
         stratify: Whether to use stratified CV for classification
         random_state: Random seed
         verbose: Whether to print progress
-        
+
     Returns:
         CrossValidationResult with scores and timing info
 
     """
-    n_samples = len(X)
+    len(X)
 
     # Choose cross-validation strategy
     if stratify and _is_classification_task(y):
@@ -107,17 +107,17 @@ def cross_validation(
 
 def hyperparameter_search(
     algorithm_class: type,
-    param_grid: Dict[str, List[Any]],
+    param_grid: dict[str, list[Any]],
     X: np.ndarray,
     y: np.ndarray,
     cv_folds: int = 3,
     scoring: str = 'accuracy',
     n_jobs: int = 1,
-    random_state: Optional[int] = 42,
+    random_state: int | None = 42,
     verbose: bool = False
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """Perform grid search for hyperparameter optimization.
-    
+
     Args:
         algorithm_class: Quantum algorithm class
         param_grid: Dictionary of parameter names and values to try
@@ -128,7 +128,7 @@ def hyperparameter_search(
         n_jobs: Number of parallel jobs (not implemented)
         random_state: Random seed
         verbose: Whether to print progress
-        
+
     Returns:
         Dictionary with best parameters and results
 
@@ -147,7 +147,7 @@ def hyperparameter_search(
 
     for i, param_values in enumerate(param_combinations):
         # Create parameter dictionary
-        params = dict(zip(param_names, param_values))
+        params = dict(zip(param_names, param_values, strict=False))
 
         if verbose:
             print(f"Combination {i+1}/{len(param_combinations)}: {params}")
@@ -204,17 +204,17 @@ def hyperparameter_search(
 
 
 def model_selection(
-    algorithms: List[Tuple[str, type, Dict[str, Any]]],
+    algorithms: list[tuple[str, type, dict[str, Any]]],
     X: np.ndarray,
     y: np.ndarray,
     cv_folds: int = 5,
     scoring: str = 'accuracy',
     test_size: float = 0.2,
-    random_state: Optional[int] = 42,
+    random_state: int | None = 42,
     verbose: bool = False
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """Compare multiple algorithms and select the best one.
-    
+
     Args:
         algorithms: List of (name, class, params) tuples
         X: Feature matrix
@@ -224,7 +224,7 @@ def model_selection(
         test_size: Proportion for test set
         random_state: Random seed
         verbose: Whether to print progress
-        
+
     Returns:
         Dictionary with model selection results
 
@@ -311,10 +311,10 @@ def data_splitting(
     val_size: float = 0.15,
     test_size: float = 0.15,
     stratify: bool = True,
-    random_state: Optional[int] = 42
-) -> Tuple[np.ndarray, ...]:
+    random_state: int | None = 42
+) -> tuple[np.ndarray, ...]:
     """Split data into train, validation, and test sets.
-    
+
     Args:
         X: Feature matrix
         y: Target vector
@@ -323,7 +323,7 @@ def data_splitting(
         test_size: Proportion for testing
         stratify: Whether to stratify splits for classification
         random_state: Random seed
-        
+
     Returns:
         Tuple of (X_train, X_val, X_test, y_train, y_val, y_test)
 
@@ -355,14 +355,14 @@ def learning_curve_analysis(
     algorithm: Any,
     X: np.ndarray,
     y: np.ndarray,
-    train_sizes: Optional[List[float]] = None,
+    train_sizes: list[float] | None = None,
     cv_folds: int = 5,
     scoring: str = 'accuracy',
-    random_state: Optional[int] = 42,
+    random_state: int | None = 42,
     verbose: bool = False
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """Analyze learning curve by varying training set size.
-    
+
     Args:
         algorithm: Quantum algorithm instance
         X: Feature matrix
@@ -372,7 +372,7 @@ def learning_curve_analysis(
         scoring: Scoring metric
         random_state: Random seed
         verbose: Whether to print progress
-        
+
     Returns:
         Learning curve analysis results
 
@@ -438,10 +438,10 @@ def feature_importance_analysis(
     method: str = 'permutation',
     n_repeats: int = 10,
     scoring: str = 'accuracy',
-    random_state: Optional[int] = 42
+    random_state: int | None = 42
 ) -> np.ndarray:
     """Analyze feature importance using permutation or other methods.
-    
+
     Args:
         algorithm: Fitted quantum algorithm
         X: Feature matrix
@@ -450,7 +450,7 @@ def feature_importance_analysis(
         n_repeats: Number of permutation repeats
         scoring: Scoring metric
         random_state: Random seed
-        
+
     Returns:
         Feature importance scores
 
@@ -471,7 +471,7 @@ def _permutation_importance(
     y: np.ndarray,
     n_repeats: int,
     scoring: str,
-    random_state: Optional[int]
+    random_state: int | None
 ) -> np.ndarray:
     """Calculate permutation feature importance."""
     # Baseline score

superquantx/utils/feature_mapping.py

@@ -5,8 +5,9 @@ which encode classical data into quantum states for machine learning algorithms.
 """
 
 from abc import ABC, abstractmethod
+from collections.abc import Callable
 from dataclasses import dataclass
-from typing import Any, Callable, Dict, List, Optional, Tuple
+from typing import Any
 
 import numpy as np
 
@@ -21,12 +22,12 @@ class FeatureMapConfig:
     entanglement: str = 'full'
     parameter_prefix: str = 'x'
     insert_barriers: bool = False
-    data_map_func: Optional[Callable] = None
+    data_map_func: Callable | None = None
 
 
 class QuantumFeatureMap(ABC):
     """Abstract base class for quantum feature maps.
-    
+
     Feature maps encode classical data into quantum states by applying
     parameterized quantum gates based on the input features.
     """
@@ -46,16 +47,16 @@ class QuantumFeatureMap(ABC):
         self._parameters = []
 
     @abstractmethod
-    def _build_circuit(self, parameters: np.ndarray) -> Dict[str, Any]:
+    def _build_circuit(self, parameters: np.ndarray) -> dict[str, Any]:
         """Build the quantum circuit for the feature map."""
         pass
 
-    def map_data_point(self, x: np.ndarray) -> Dict[str, Any]:
+    def map_data_point(self, x: np.ndarray) -> dict[str, Any]:
         """Map a single data point to quantum circuit parameters.
-        
+
         Args:
             x: Input data point of length n_features
-            
+
         Returns:
             Circuit representation with parameters
 
@@ -68,12 +69,12 @@ class QuantumFeatureMap(ABC):
 
         return self._build_circuit(parameters)
 
-    def map_data(self, X: np.ndarray) -> List[Dict[str, Any]]:
+    def map_data(self, X: np.ndarray) -> list[dict[str, Any]]:
         """Map multiple data points to quantum circuits.
-        
+
         Args:
             X: Input data of shape (n_samples, n_features)
-            
+
         Returns:
             List of circuit representations
 
@@ -88,7 +89,7 @@ class QuantumFeatureMap(ABC):
 
 class ZFeatureMap(QuantumFeatureMap):
     """Z-axis rotation feature map.
-    
+
     This feature map applies RZ rotations to encode features:
     RZ(2 * x_i) for each feature x_i
     """
@@ -101,7 +102,7 @@ class ZFeatureMap(QuantumFeatureMap):
     ):
         super().__init__(n_features, reps, 'none', parameter_prefix)
 
-    def _build_circuit(self, parameters: np.ndarray) -> Dict[str, Any]:
+    def _build_circuit(self, parameters: np.ndarray) -> dict[str, Any]:
         """Build Z feature map circuit."""
         gates = []
 
@@ -125,9 +126,9 @@ class ZFeatureMap(QuantumFeatureMap):
 
 class ZZFeatureMap(QuantumFeatureMap):
     """ZZ entangling feature map.
-    
+
     This feature map uses both single-qubit Z rotations and two-qubit ZZ interactions:
-    - Single qubit: RZ(2 * x_i) 
+    - Single qubit: RZ(2 * x_i)
     - Two qubit: RZZ(2 * x_i * x_j) for entangled qubits
     """
 
@@ -142,7 +143,7 @@ class ZZFeatureMap(QuantumFeatureMap):
         super().__init__(n_features, reps, entanglement, parameter_prefix)
         self.alpha = alpha
 
-    def _build_circuit(self, parameters: np.ndarray) -> Dict[str, Any]:
+    def _build_circuit(self, parameters: np.ndarray) -> dict[str, Any]:
         """Build ZZ feature map circuit."""
         gates = []
 
@@ -180,7 +181,7 @@ class ZZFeatureMap(QuantumFeatureMap):
             'entanglement': self.entanglement
         }
 
-    def _get_entangling_pairs(self) -> List[Tuple[int, int]]:
+    def _get_entangling_pairs(self) -> list[tuple[int, int]]:
         """Get pairs of qubits for entangling gates."""
         pairs = []
 
@@ -211,7 +212,7 @@ class ZZFeatureMap(QuantumFeatureMap):
 
 class PauliFeatureMap(QuantumFeatureMap):
     """Pauli feature map with arbitrary Pauli strings.
-    
+
     This feature map applies rotations based on Pauli operators:
     exp(i * alpha * phi * P) where P is a Pauli string and phi is the feature value.
     """
@@ -220,16 +221,18 @@ class PauliFeatureMap(QuantumFeatureMap):
         self,
         n_features: int,
         reps: int = 1,
-        paulis: List[str] = ['Z', 'ZZ'],
+        paulis: list[str] = None,
         entanglement: str = 'full',
         alpha: float = 2.0,
         parameter_prefix: str = 'x'
     ):
+        if paulis is None:
+            paulis = ['Z', 'ZZ']
         super().__init__(n_features, reps, entanglement, parameter_prefix)
         self.paulis = paulis
         self.alpha = alpha
 
-    def _build_circuit(self, parameters: np.ndarray) -> Dict[str, Any]:
+    def _build_circuit(self, parameters: np.ndarray) -> dict[str, Any]:
         """Build Pauli feature map circuit."""
         gates = []
 
@@ -256,7 +259,7 @@ class PauliFeatureMap(QuantumFeatureMap):
 
     def _add_single_pauli_gates(
         self,
-        gates: List[Dict],
+        gates: list[dict],
         pauli: str,
         parameters: np.ndarray,
         rep: int
@@ -283,7 +286,7 @@ class PauliFeatureMap(QuantumFeatureMap):
 
     def _add_multi_pauli_gates(
         self,
-        gates: List[Dict],
+        gates: list[dict],
         pauli_string: str,
         parameters: np.ndarray,
         rep: int
@@ -312,12 +315,12 @@ def create_feature_map(
     **kwargs
 ) -> QuantumFeatureMap:
     """Factory function to create quantum feature maps.
-    
+
     Args:
         feature_map_type: Type of feature map ('Z', 'ZZ', 'Pauli')
         n_features: Number of input features
         **kwargs: Additional arguments for specific feature maps
-        
+
     Returns:
         QuantumFeatureMap instance
 
@@ -336,24 +339,26 @@ def create_feature_map(
 
 def pauli_feature_map(
     n_features: int,
-    paulis: List[str] = ['Z', 'ZZ'],
+    paulis: list[str] = None,
     reps: int = 1,
     alpha: float = 2.0,
     entanglement: str = 'full'
 ) -> PauliFeatureMap:
     """Create a Pauli feature map with specified Pauli strings.
-    
+
     Args:
         n_features: Number of input features
         paulis: List of Pauli strings to use
         reps: Number of repetitions
         alpha: Scaling factor
         entanglement: Entanglement pattern
-        
+
     Returns:
         PauliFeatureMap instance
 
     """
+    if paulis is None:
+        paulis = ['Z', 'ZZ']
     return PauliFeatureMap(
         n_features=n_features,
         paulis=paulis,
@@ -370,13 +375,13 @@ def zz_feature_map(
     alpha: float = 2.0
 ) -> ZZFeatureMap:
     """Create a ZZ feature map with specified parameters.
-    
+
     Args:
         n_features: Number of input features
         reps: Number of repetitions
         entanglement: Entanglement pattern ('linear', 'circular', 'full')
         alpha: Scaling factor
-        
+
     Returns:
         ZZFeatureMap instance
 
@@ -391,10 +396,10 @@ def zz_feature_map(
 
 def feature_map_from_config(config: FeatureMapConfig) -> QuantumFeatureMap:
     """Create feature map from configuration.
-    
+
     Args:
         config: FeatureMapConfig instance
-        
+
     Returns:
         QuantumFeatureMap instance
 
@@ -419,18 +424,18 @@ def feature_map_from_config(config: FeatureMapConfig) -> QuantumFeatureMap:
 def evaluate_feature_map_expressibility(
     feature_map: QuantumFeatureMap,
     n_samples: int = 1000,
-    random_state: Optional[int] = None
-) -> Dict[str, float]:
+    random_state: int | None = None
+) -> dict[str, float]:
     """Evaluate the expressibility of a quantum feature map.
-    
+
     Expressibility measures how well a feature map can generate
     diverse quantum states across the Hilbert space.
-    
+
     Args:
         feature_map: QuantumFeatureMap to evaluate
         n_samples: Number of random data points to sample
         random_state: Random seed
-        
+
     Returns:
         Dictionary with expressibility metrics
 

superquantx/utils/optimization.py

@@ -6,7 +6,8 @@ including classical optimizers commonly used in quantum machine learning.
 
 import time
 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
 
@@ -94,15 +95,15 @@ class AdamOptimizer(Optimizer):
 def optimize_circuit(
     cost_function: Callable[[np.ndarray], float],
     initial_params: np.ndarray,
-    gradient_function: Optional[Callable[[np.ndarray], np.ndarray]] = None,
+    gradient_function: Callable[[np.ndarray], np.ndarray] | None = None,
     optimizer: str = 'adam',
     max_iterations: int = 100,
     tolerance: float = 1e-6,
     learning_rate: float = 0.01,
     verbose: bool = False
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """Optimize quantum circuit parameters.
-    
+
     Args:
         cost_function: Function to minimize f(params) -> cost
         initial_params: Initial parameter values
@@ -112,7 +113,7 @@ def optimize_circuit(
         tolerance: Convergence tolerance
         learning_rate: Learning rate for gradient-based optimizers
         verbose: Whether to print progress
-        
+
     Returns:
         Dictionary with optimization results
 
@@ -132,7 +133,8 @@ def optimize_circuit(
 
     # If no gradient function provided, use finite differences
     if gradient_function is None:
-        gradient_function = lambda p: finite_difference_gradient(cost_function, p)
+        def gradient_function(p):
+            return finite_difference_gradient(cost_function, p)
 
     for iteration in range(max_iterations):
         # Compute cost and gradient
@@ -168,20 +170,20 @@ def optimize_circuit(
 
 def optimize_parameters(
     objective_function: Callable,
-    bounds: List[Tuple[float, float]],
+    bounds: list[tuple[float, float]],
     method: str = 'scipy',
     max_evaluations: int = 1000,
-    random_state: Optional[int] = None
-) -> Dict[str, Any]:
+    random_state: int | None = None
+) -> dict[str, Any]:
     """Optimize parameters using various methods.
-    
+
     Args:
         objective_function: Function to minimize
         bounds: Parameter bounds as list of (min, max) tuples
         method: Optimization method ('scipy', 'random_search', 'grid_search')
         max_evaluations: Maximum function evaluations
         random_state: Random seed
-        
+
     Returns:
         Optimization results dictionary
 
@@ -203,9 +205,9 @@ def gradient_descent(
     learning_rate: float = 0.01,
     max_iterations: int = 1000,
     tolerance: float = 1e-6
-) -> Tuple[np.ndarray, List[float]]:
+) -> tuple[np.ndarray, list[float]]:
     """Perform gradient descent optimization.
-    
+
     Args:
         cost_function: Cost function to minimize
         gradient_function: Function returning gradients
@@ -213,7 +215,7 @@ def gradient_descent(
         learning_rate: Learning rate
         max_iterations: Maximum iterations
         tolerance: Convergence tolerance
-        
+
     Returns:
         Tuple of (optimal_params, cost_history)
 
@@ -244,9 +246,9 @@ def adam_optimizer(
     epsilon: float = 1e-8,
     max_iterations: int = 1000,
     tolerance: float = 1e-6
-) -> Tuple[np.ndarray, List[float]]:
+) -> tuple[np.ndarray, list[float]]:
     """Perform Adam optimization.
-    
+
     Args:
         cost_function: Cost function to minimize
         gradient_function: Function returning gradients
@@ -257,7 +259,7 @@ def adam_optimizer(
         epsilon: Small constant for numerical stability
         max_iterations: Maximum iterations
         tolerance: Convergence tolerance
-        
+
     Returns:
         Tuple of (optimal_params, cost_history)
 
@@ -285,12 +287,12 @@ def finite_difference_gradient(
     epsilon: float = 1e-6
 ) -> np.ndarray:
     """Compute gradient using finite differences.
-    
+
     Args:
         function: Function to differentiate
         params: Parameters at which to compute gradient
         epsilon: Finite difference step size
-        
+
     Returns:
         Gradient vector
 
@@ -312,9 +314,9 @@ def finite_difference_gradient(
 
 def _scipy_optimize(
     objective_function: Callable,
-    bounds: List[Tuple[float, float]],
+    bounds: list[tuple[float, float]],
     max_evaluations: int
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """Optimize using scipy methods."""
     try:
         from scipy.optimize import minimize
@@ -342,10 +344,10 @@ def _scipy_optimize(
 
 def _random_search_optimize(
     objective_function: Callable,
-    bounds: List[Tuple[float, float]],
+    bounds: list[tuple[float, float]],
     max_evaluations: int,
-    random_state: Optional[int]
-) -> Dict[str, Any]:
+    random_state: int | None
+) -> dict[str, Any]:
     """Random search optimization."""
     np.random.seed(random_state)
 
@@ -372,9 +374,9 @@ def _random_search_optimize(
 
 def _grid_search_optimize(
     objective_function: Callable,
-    bounds: List[Tuple[float, float]],
+    bounds: list[tuple[float, float]],
     max_evaluations: int
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """Grid search optimization."""
     n_params = len(bounds)
     n_points_per_dim = int(max_evaluations ** (1 / n_params))