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

superquantx/algorithms/quantum_pca.py

@@ -5,7 +5,7 @@ including quantum matrix diagonalization and dimensionality reduction.
 """
 
 import logging
-from typing import Any, Dict, Optional, Tuple, Union
+from typing import Any
 
 import numpy as np
 from sklearn.decomposition import PCA
@@ -18,16 +18,16 @@ logger = logging.getLogger(__name__)
 
 class QuantumPCA(UnsupervisedQuantumAlgorithm):
     """Quantum Principal Component Analysis for dimensionality reduction.
-    
+
     This implementation uses quantum algorithms to perform PCA, potentially
     offering exponential speedup for certain types of data matrices.
-    
+
     The algorithm can use different quantum approaches:
     - Quantum Matrix Inversion: For density matrix diagonalization
     - Variational Quantum Eigensolver: For finding principal eigenvectors
     - Quantum Phase Estimation: For eigenvalue extraction
     - Quantum Singular Value Decomposition: Direct SVD approach
-    
+
     Args:
         backend: Quantum backend for circuit execution
         n_components: Number of principal components to extract
@@ -38,7 +38,7 @@ class QuantumPCA(UnsupervisedQuantumAlgorithm):
         shots: Number of measurement shots
         classical_fallback: Use classical PCA if quantum fails
         **kwargs: Additional parameters
-        
+
     Example:
         >>> qpca = QuantumPCA(backend='pennylane', n_components=3, method='vqe')
         >>> qpca.fit(X_train)
@@ -49,7 +49,7 @@ class QuantumPCA(UnsupervisedQuantumAlgorithm):
 
     def __init__(
         self,
-        backend: Union[str, Any],
+        backend: str | Any,
         n_components: int = 2,
         method: str = 'vqe',
         encoding: str = 'amplitude',
@@ -148,7 +148,7 @@ class QuantumPCA(UnsupervisedQuantumAlgorithm):
         logger.warning("Using fallback density matrix encoding")
         return None
 
-    def _quantum_eigensolver_vqe(self, density_matrix: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+    def _quantum_eigensolver_vqe(self, density_matrix: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
         """Use VQE to find principal eigenvectors and eigenvalues."""
         logger.info("Running VQE for quantum PCA")
 
@@ -174,7 +174,7 @@ class QuantumPCA(UnsupervisedQuantumAlgorithm):
             logger.error(f"VQE eigensolver failed: {e}")
             return self._fallback_vqe_eigensolver(density_matrix)
 
-    def _fallback_vqe_eigensolver(self, density_matrix: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+    def _fallback_vqe_eigensolver(self, density_matrix: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
         """Fallback VQE implementation using classical eigensolver."""
         logger.warning("Using classical fallback for VQE eigensolver")
         eigenvals, eigenvecs = np.linalg.eigh(density_matrix)
@@ -182,7 +182,7 @@ class QuantumPCA(UnsupervisedQuantumAlgorithm):
         idx = np.argsort(eigenvals)[::-1]
         return eigenvals[idx][:self.n_components], eigenvecs[:, idx][:, :self.n_components]
 
-    def _quantum_phase_estimation(self, density_matrix: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+    def _quantum_phase_estimation(self, density_matrix: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
         """Use quantum phase estimation for eigenvalue extraction."""
         logger.info("Running quantum phase estimation for PCA")
 
@@ -206,12 +206,12 @@ class QuantumPCA(UnsupervisedQuantumAlgorithm):
             logger.error(f"Quantum phase estimation failed: {e}")
             return self._fallback_phase_estimation(density_matrix)
 
-    def _fallback_phase_estimation(self, density_matrix: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+    def _fallback_phase_estimation(self, density_matrix: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
         """Fallback phase estimation using classical methods."""
         logger.warning("Using classical fallback for phase estimation")
         return self._fallback_vqe_eigensolver(density_matrix)
 
-    def _quantum_svd(self, X: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+    def _quantum_svd(self, X: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
         """Quantum singular value decomposition approach."""
         logger.info("Running quantum SVD for PCA")
 
@@ -237,14 +237,14 @@ class QuantumPCA(UnsupervisedQuantumAlgorithm):
             logger.error(f"Quantum SVD failed: {e}")
             return self._fallback_svd(X)
 
-    def _fallback_svd(self, X: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+    def _fallback_svd(self, X: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
         """Fallback SVD using classical methods."""
         logger.warning("Using classical fallback for SVD")
         U, s, Vt = np.linalg.svd(X, full_matrices=False)
         eigenvalues = (s ** 2) / (X.shape[0] - 1)
         return eigenvalues[:self.n_components], Vt[:self.n_components].T
 
-    def _quantum_matrix_inversion(self, density_matrix: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+    def _quantum_matrix_inversion(self, density_matrix: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
         """Quantum matrix inversion approach."""
         logger.info("Running quantum matrix inversion for PCA")
 
@@ -268,19 +268,19 @@ class QuantumPCA(UnsupervisedQuantumAlgorithm):
             logger.error(f"Quantum matrix inversion failed: {e}")
             return self._fallback_matrix_inversion(density_matrix)
 
-    def _fallback_matrix_inversion(self, density_matrix: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+    def _fallback_matrix_inversion(self, density_matrix: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
         """Fallback matrix inversion using classical methods."""
         logger.warning("Using classical fallback for matrix inversion")
         return self._fallback_vqe_eigensolver(density_matrix)
 
-    def fit(self, X: np.ndarray, y: Optional[np.ndarray] = None, **kwargs) -> 'QuantumPCA':
+    def fit(self, X: np.ndarray, y: np.ndarray | None = None, **kwargs) -> 'QuantumPCA':
         """Fit quantum PCA to the data.
-        
+
         Args:
             X: Training data
             y: Ignored (unsupervised learning)
             **kwargs: Additional fitting parameters
-            
+
         Returns:
             Self for method chaining
 
@@ -335,10 +335,10 @@ class QuantumPCA(UnsupervisedQuantumAlgorithm):
 
     def transform(self, X: np.ndarray) -> np.ndarray:
         """Transform data to lower dimensional space.
-        
+
         Args:
             X: Data to transform
-            
+
         Returns:
             Transformed data
 
@@ -360,10 +360,10 @@ class QuantumPCA(UnsupervisedQuantumAlgorithm):
 
     def inverse_transform(self, X_transformed: np.ndarray) -> np.ndarray:
         """Reconstruct data from lower dimensional representation.
-        
+
         Args:
             X_transformed: Transformed data
-            
+
         Returns:
             Reconstructed data
 
@@ -383,7 +383,7 @@ class QuantumPCA(UnsupervisedQuantumAlgorithm):
 
         return X_reconstructed
 
-    def fit_transform(self, X: np.ndarray, y: Optional[np.ndarray] = None) -> np.ndarray:
+    def fit_transform(self, X: np.ndarray, y: np.ndarray | None = None) -> np.ndarray:
         """Fit PCA and transform data in one step."""
         return self.fit(X, y).transform(X)
 
@@ -391,7 +391,7 @@ class QuantumPCA(UnsupervisedQuantumAlgorithm):
         """Transform data (alias for transform method)."""
         return self.transform(X)
 
-    def get_quantum_advantage_metrics(self) -> Dict[str, Any]:
+    def get_quantum_advantage_metrics(self) -> dict[str, Any]:
         """Analyze potential quantum advantage."""
         if not self.is_fitted:
             raise ValueError("Must fit model first")
@@ -418,7 +418,7 @@ class QuantumPCA(UnsupervisedQuantumAlgorithm):
 
         return metrics
 
-    def compare_with_classical(self, X: np.ndarray) -> Dict[str, Any]:
+    def compare_with_classical(self, X: np.ndarray) -> dict[str, Any]:
         """Compare quantum PCA results with classical PCA."""
         if not self.is_fitted or not hasattr(self.classical_pca, 'components_'):
             raise ValueError("Both quantum and classical PCA must be fitted")
@@ -459,7 +459,7 @@ class QuantumPCA(UnsupervisedQuantumAlgorithm):
             'mean_component_similarity': np.mean(component_similarities) if component_similarities else 0,
         }
 
-    def analyze_convergence(self) -> Dict[str, Any]:
+    def analyze_convergence(self) -> dict[str, Any]:
         """Analyze convergence properties of the quantum algorithm."""
         if not self.convergence_history:
             return {'message': 'No convergence history available'}
@@ -475,7 +475,7 @@ class QuantumPCA(UnsupervisedQuantumAlgorithm):
             'convergence_rate': np.mean(np.diff(convergence_data)) if len(convergence_data) > 1 else 0,
         }
 
-    def get_params(self, deep: bool = True) -> Dict[str, Any]:
+    def get_params(self, deep: bool = True) -> dict[str, Any]:
         """Get quantum PCA parameters."""
         params = super().get_params(deep)
         params.update({

superquantx/algorithms/quantum_svm.py

@@ -5,7 +5,8 @@ for binary and multiclass classification tasks using quantum kernels.
 """
 
 import logging
-from typing import Any, Callable, Dict, Optional, Union
+from collections.abc import Callable
+from typing import Any
 
 import numpy as np
 from sklearn.metrics import accuracy_score
@@ -19,16 +20,16 @@ logger = logging.getLogger(__name__)
 
 class QuantumSVM(SupervisedQuantumAlgorithm):
     """Quantum Support Vector Machine for classification.
-    
+
     This implementation uses quantum feature maps to transform data into
     a high-dimensional Hilbert space where linear separation is possible.
     The quantum kernel is computed using quantum circuits.
-    
+
     The algorithm works by:
     1. Encoding classical data into quantum states using feature maps
     2. Computing quantum kernels between data points
     3. Training a classical SVM using the quantum kernel matrix
-    
+
     Args:
         backend: Quantum backend for circuit execution
         feature_map: Type of quantum feature map ('ZZFeatureMap', 'PauliFeatureMap', etc.)
@@ -38,7 +39,7 @@ class QuantumSVM(SupervisedQuantumAlgorithm):
         quantum_kernel: Custom quantum kernel function
         shots: Number of measurement shots
         **kwargs: Additional parameters
-    
+
     Example:
         >>> qsvm = QuantumSVM(backend='pennylane', feature_map='ZZFeatureMap')
         >>> qsvm.fit(X_train, y_train)
@@ -49,12 +50,12 @@ class QuantumSVM(SupervisedQuantumAlgorithm):
 
     def __init__(
         self,
-        backend: Union[str, Any],
+        backend: str | Any,
         feature_map: str = 'ZZFeatureMap',
         feature_map_reps: int = 2,
         C: float = 1.0,
-        gamma: Optional[float] = None,
-        quantum_kernel: Optional[Callable] = None,
+        gamma: float | None = None,
+        quantum_kernel: Callable | None = None,
         shots: int = 1024,
         normalize_data: bool = True,
         **kwargs
@@ -103,13 +104,13 @@ class QuantumSVM(SupervisedQuantumAlgorithm):
         logger.warning("Using default feature map - results may vary")
         return None
 
-    def _compute_quantum_kernel(self, X1: np.ndarray, X2: Optional[np.ndarray] = None) -> np.ndarray:
+    def _compute_quantum_kernel(self, X1: np.ndarray, X2: np.ndarray | None = None) -> np.ndarray:
         """Compute quantum kernel matrix between data points.
-        
+
         Args:
             X1: First set of data points
             X2: Second set of data points (if None, use X1)
-            
+
         Returns:
             Quantum kernel matrix
 
@@ -145,12 +146,12 @@ class QuantumSVM(SupervisedQuantumAlgorithm):
 
     def fit(self, X: np.ndarray, y: np.ndarray, **kwargs) -> 'QuantumSVM':
         """Train the quantum SVM.
-        
+
         Args:
             X: Training data features
             y: Training data labels
             **kwargs: Additional training parameters
-            
+
         Returns:
             Self for method chaining
 
@@ -198,11 +199,11 @@ class QuantumSVM(SupervisedQuantumAlgorithm):
 
     def predict(self, X: np.ndarray, **kwargs) -> np.ndarray:
         """Make predictions using the trained quantum SVM.
-        
+
         Args:
             X: Input data for prediction
             **kwargs: Additional prediction parameters
-            
+
         Returns:
             Predicted labels
 
@@ -223,11 +224,11 @@ class QuantumSVM(SupervisedQuantumAlgorithm):
 
     def predict_proba(self, X: np.ndarray, **kwargs) -> np.ndarray:
         """Predict class probabilities.
-        
+
         Args:
             X: Input data for prediction
             **kwargs: Additional parameters
-            
+
         Returns:
             Predicted class probabilities
 
@@ -249,10 +250,10 @@ class QuantumSVM(SupervisedQuantumAlgorithm):
 
     def decision_function(self, X: np.ndarray) -> np.ndarray:
         """Compute decision function values.
-        
+
         Args:
             X: Input data
-            
+
         Returns:
             Decision function values
 
@@ -273,12 +274,12 @@ class QuantumSVM(SupervisedQuantumAlgorithm):
 
         return self.X_train_[self.svm.support_]
 
-    def get_quantum_kernel_matrix(self, X: Optional[np.ndarray] = None) -> np.ndarray:
+    def get_quantum_kernel_matrix(self, X: np.ndarray | None = None) -> np.ndarray:
         """Get the quantum kernel matrix.
-        
+
         Args:
             X: Data to compute kernel matrix for (default: training data)
-            
+
         Returns:
             Quantum kernel matrix
 
@@ -292,9 +293,9 @@ class QuantumSVM(SupervisedQuantumAlgorithm):
                 X = self.scaler.transform(X)
             return self._compute_quantum_kernel(X)
 
-    def analyze_kernel(self) -> Dict[str, Any]:
+    def analyze_kernel(self) -> dict[str, Any]:
         """Analyze properties of the quantum kernel.
-        
+
         Returns:
             Dictionary with kernel analysis results
 
@@ -324,7 +325,7 @@ class QuantumSVM(SupervisedQuantumAlgorithm):
 
         return analysis
 
-    def get_params(self, deep: bool = True) -> Dict[str, Any]:
+    def get_params(self, deep: bool = True) -> dict[str, Any]:
         """Get algorithm parameters."""
         params = super().get_params(deep)
         params.update({

superquantx/algorithms/vqe.py

@@ -5,7 +5,8 @@ and eigenvalues of quantum systems using parameterized quantum circuits.
 """
 
 import logging
-from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+from collections.abc import Callable
+from typing import Any
 
 import numpy as np
 from scipy.optimize import minimize
@@ -17,27 +18,27 @@ logger = logging.getLogger(__name__)
 
 class VQE(OptimizationQuantumAlgorithm):
     """Variational Quantum Eigensolver for finding ground states.
-    
+
     VQE is a hybrid quantum-classical algorithm that uses a parameterized
     quantum circuit (ansatz) to find the ground state energy of a given
     Hamiltonian by minimizing the expectation value.
-    
+
     The algorithm works by:
     1. Preparing a parameterized quantum state |ψ(θ)⟩
     2. Measuring the expectation value ⟨ψ(θ)|H|ψ(θ)⟩
     3. Classically optimizing parameters θ to minimize energy
     4. Iterating until convergence
-    
+
     Args:
         backend: Quantum backend for circuit execution
         hamiltonian: Target Hamiltonian (matrix or operator)
         ansatz: Parameterized circuit ansatz ('UCCSD', 'RealAmplitudes', etc.)
         optimizer: Classical optimizer ('COBYLA', 'L-BFGS-B', etc.)
         shots: Number of measurement shots
-        maxiter: Maximum optimization iterations  
+        maxiter: Maximum optimization iterations
         initial_params: Initial parameter values
         **kwargs: Additional parameters
-        
+
     Example:
         >>> # Define H2 molecule Hamiltonian
         >>> H2_hamiltonian = create_h2_hamiltonian(bond_distance=0.74)
@@ -49,13 +50,13 @@ class VQE(OptimizationQuantumAlgorithm):
 
     def __init__(
         self,
-        hamiltonian: Union[np.ndarray, Any],
-        ansatz: Union[str, Callable] = 'RealAmplitudes',
-        backend: Union[str, Any] = 'simulator',
+        hamiltonian: np.ndarray | Any,
+        ansatz: str | Callable = 'RealAmplitudes',
+        backend: str | Any = 'simulator',
         optimizer: str = 'COBYLA',
         shots: int = 1024,
         maxiter: int = 1000,
-        initial_params: Optional[np.ndarray] = None,
+        initial_params: np.ndarray | None = None,
         include_custom_gates: bool = False,
         client = None,
         **kwargs
@@ -101,14 +102,14 @@ class VQE(OptimizationQuantumAlgorithm):
             self.hamiltonian_terms = self.hamiltonian
             self.n_qubits = self._infer_qubits_from_hamiltonian()
 
-    def _decompose_hamiltonian(self) -> List[Tuple[float, str]]:
+    def _decompose_hamiltonian(self) -> list[tuple[float, str]]:
         """Decompose Hamiltonian into Pauli string representation."""
         if hasattr(self.backend, 'decompose_hamiltonian'):
             return self.backend.decompose_hamiltonian(self.hamiltonian)
         else:
             return self._fallback_decomposition()
 
-    def _fallback_decomposition(self) -> List[Tuple[float, str]]:
+    def _fallback_decomposition(self) -> list[tuple[float, str]]:
         """Fallback Hamiltonian decomposition."""
         logger.warning("Using fallback Hamiltonian decomposition")
         # Simple placeholder - would need proper Pauli decomposition
@@ -122,10 +123,10 @@ class VQE(OptimizationQuantumAlgorithm):
 
     def _create_ansatz_circuit(self, params: np.ndarray) -> Any:
         """Create ansatz circuit with given parameters.
-        
+
         Args:
             params: Circuit parameters
-            
+
         Returns:
             Parameterized quantum circuit
 
@@ -151,10 +152,10 @@ class VQE(OptimizationQuantumAlgorithm):
 
     def _compute_expectation_value(self, params: np.ndarray) -> float:
         """Compute expectation value ⟨ψ(θ)|H|ψ(θ)⟩.
-        
+
         Args:
             params: Circuit parameters
-            
+
         Returns:
             Hamiltonian expectation value
 
@@ -190,10 +191,10 @@ class VQE(OptimizationQuantumAlgorithm):
 
     def _compute_gradient(self, params: np.ndarray) -> np.ndarray:
         """Compute parameter gradients using parameter-shift rule.
-        
+
         Args:
             params: Current parameters
-            
+
         Returns:
             Gradient vector
 
@@ -218,14 +219,14 @@ class VQE(OptimizationQuantumAlgorithm):
         self.gradient_history.append(np.linalg.norm(gradients))
         return gradients
 
-    def fit(self, X: Optional[np.ndarray] = None, y: Optional[np.ndarray] = None, **kwargs) -> 'VQE':
+    def fit(self, X: np.ndarray | None = None, y: np.ndarray | None = None, **kwargs) -> 'VQE':
         """Fit VQE (setup for optimization).
-        
+
         Args:
             X: Not used in VQE
             y: Not used in VQE
             **kwargs: Additional parameters
-            
+
         Returns:
             Self for method chaining
 
@@ -265,13 +266,13 @@ class VQE(OptimizationQuantumAlgorithm):
         """Generate random initial parameters."""
         return np.random.uniform(-np.pi, np.pi, self.n_params)
 
-    def predict(self, X: Optional[np.ndarray] = None, **kwargs) -> np.ndarray:
+    def predict(self, X: np.ndarray | None = None, **kwargs) -> np.ndarray:
         """Get ground state wavefunction coefficients.
-        
+
         Args:
             X: Not used
             **kwargs: Additional parameters
-            
+
         Returns:
             Ground state wavefunction
 
@@ -292,14 +293,14 @@ class VQE(OptimizationQuantumAlgorithm):
 
         return np.array(statevector)
 
-    def _run_optimization(self, objective_function=None, initial_params: Optional[np.ndarray] = None, **kwargs):
+    def _run_optimization(self, objective_function=None, initial_params: np.ndarray | None = None, **kwargs):
         """Run VQE optimization.
-        
+
         Args:
             objective_function: Not used (VQE has its own objective)
             initial_params: Initial parameter guess
             **kwargs: Additional optimization parameters
-            
+
         Returns:
             Optimization result
 
@@ -356,15 +357,15 @@ class VQE(OptimizationQuantumAlgorithm):
             logger.error(f"VQE optimization failed: {e}")
             raise
 
-    def get_energy_landscape(self, param_indices: List[int], param_ranges: List[Tuple[float, float]],
-                           resolution: int = 20) -> Dict[str, Any]:
+    def get_energy_landscape(self, param_indices: list[int], param_ranges: list[tuple[float, float]],
+                           resolution: int = 20) -> dict[str, Any]:
         """Compute energy landscape for visualization.
-        
+
         Args:
             param_indices: Indices of parameters to vary
             param_ranges: Ranges for each parameter
             resolution: Number of points per dimension
-            
+
         Returns:
             Dictionary with landscape data
 
@@ -396,9 +397,9 @@ class VQE(OptimizationQuantumAlgorithm):
             'param_indices': param_indices
         }
 
-    def analyze_convergence(self) -> Dict[str, Any]:
+    def analyze_convergence(self) -> dict[str, Any]:
         """Analyze VQE convergence properties.
-        
+
         Returns:
             Convergence analysis results
 
@@ -447,12 +448,12 @@ class VQE(OptimizationQuantumAlgorithm):
 
         return analysis
 
-    def compare_with_exact(self, exact_ground_energy: float) -> Dict[str, Any]:
+    def compare_with_exact(self, exact_ground_energy: float) -> dict[str, Any]:
         """Compare VQE result with exact ground state energy.
-        
+
         Args:
             exact_ground_energy: Known exact ground state energy
-            
+
         Returns:
             Comparison analysis
 
@@ -472,7 +473,7 @@ class VQE(OptimizationQuantumAlgorithm):
             'energy_above_ground': max(0, self.optimal_value_ - exact_ground_energy)
         }
 
-    def get_params(self, deep: bool = True) -> Dict[str, Any]:
+    def get_params(self, deep: bool = True) -> dict[str, Any]:
         """Get VQE parameters."""
         params = super().get_params(deep)
         params.update({
@@ -502,7 +503,7 @@ def create_vqe_for_molecule(
     client = None
 ) -> VQE:
     """Create a VQE instance pre-configured for molecular simulation.
-    
+
     Args:
         molecule_name: Name of the molecule (e.g., 'H2', 'LiH')
         bond_distance: Bond distance for the molecule (uses default if None)
@@ -510,7 +511,7 @@ def create_vqe_for_molecule(
         ansatz: Ansatz circuit type
         optimizer: Classical optimizer
         client: Optional client for quantum execution
-        
+
     Returns:
         Configured VQE instance