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

superquantx/measurements.py

@@ -3,7 +3,7 @@
 
 import json
 from collections import Counter, defaultdict
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any
 
 import matplotlib.pyplot as plt
 import numpy as np
@@ -14,10 +14,10 @@ class MeasurementResult(BaseModel):
     """Represents the result of quantum measurements
     """
 
-    counts: Dict[str, int] = Field(..., description="Measurement outcome counts")
+    counts: dict[str, int] = Field(..., description="Measurement outcome counts")
     shots: int = Field(..., description="Total number of shots")
-    memory: Optional[List[str]] = Field(default=None, description="Individual shot outcomes")
-    metadata: Dict[str, Any] = Field(default_factory=dict, description="Additional metadata")
+    memory: list[str] | None = Field(default=None, description="Individual shot outcomes")
+    metadata: dict[str, Any] = Field(default_factory=dict, description="Additional metadata")
 
     def model_post_init(self, __context):
         """Validate measurement result"""
@@ -25,21 +25,21 @@ class MeasurementResult(BaseModel):
             raise ValueError("Sum of counts must equal total shots")
 
     @property
-    def probabilities(self) -> Dict[str, float]:
+    def probabilities(self) -> dict[str, float]:
         """Get measurement probabilities"""
         return {outcome: count / self.shots for outcome, count in self.counts.items()}
 
     @property
-    def most_frequent(self) -> Tuple[str, int]:
+    def most_frequent(self) -> tuple[str, int]:
         """Get most frequent measurement outcome"""
         return max(self.counts.items(), key=lambda x: x[1])
 
-    def marginal_counts(self, qubits: List[int]) -> Dict[str, int]:
+    def marginal_counts(self, qubits: list[int]) -> dict[str, int]:
         """Get marginal counts for specific qubits
-        
+
         Args:
             qubits: List of qubit indices to marginalize over
-            
+
         Returns:
             Marginal counts dictionary
 
@@ -55,10 +55,10 @@ class MeasurementResult(BaseModel):
 
     def expectation_value(self, observable: str) -> float:
         """Calculate expectation value for Pauli observable
-        
+
         Args:
             observable: Pauli string (e.g., "ZZI")
-            
+
         Returns:
             Expectation value
 
@@ -94,16 +94,16 @@ class MeasurementResult(BaseModel):
     def plot_histogram(
         self,
         title: str = "Measurement Results",
-        figsize: Tuple[int, int] = (10, 6),
+        figsize: tuple[int, int] = (10, 6),
         max_outcomes: int = 20
     ) -> plt.Figure:
         """Plot measurement histogram
-        
+
         Args:
             title: Plot title
             figsize: Figure size
             max_outcomes: Maximum number of outcomes to show
-            
+
         Returns:
             Matplotlib figure
 
@@ -117,7 +117,7 @@ class MeasurementResult(BaseModel):
         if len(sorted_outcomes) > max_outcomes:
             sorted_outcomes = sorted_outcomes[:max_outcomes]
 
-        outcomes, counts = zip(*sorted_outcomes) if sorted_outcomes else ([], [])
+        outcomes, counts = zip(*sorted_outcomes, strict=False) if sorted_outcomes else ([], [])
 
         ax.bar(range(len(outcomes)), counts)
         ax.set_xlabel('Measurement Outcome')
@@ -129,7 +129,7 @@ class MeasurementResult(BaseModel):
         plt.tight_layout()
         return fig
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         """Convert to dictionary"""
         return {
             "counts": self.counts,
@@ -143,7 +143,7 @@ class MeasurementResult(BaseModel):
         return json.dumps(self.to_dict(), indent=indent)
 
     @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "MeasurementResult":
+    def from_dict(cls, data: dict[str, Any]) -> "MeasurementResult":
         """Create from dictionary"""
         return cls(**data)
 
@@ -176,15 +176,15 @@ class QuantumMeasurement:
     """Quantum measurement operations and analysis
     """
 
-    def __init__(self, backend: Optional[str] = "simulator"):
+    def __init__(self, backend: str | None = "simulator"):
         """Initialize measurement system
-        
+
         Args:
             backend: Quantum backend for measurements
 
         """
         self.backend = backend
-        self.measurement_history: List[MeasurementResult] = []
+        self.measurement_history: list[MeasurementResult] = []
 
     def measure_circuit(
         self,
@@ -193,12 +193,12 @@ class QuantumMeasurement:
         memory: bool = False
     ) -> MeasurementResult:
         """Measure quantum circuit
-        
+
         Args:
             circuit: Quantum circuit to measure
             shots: Number of measurement shots
             memory: Whether to store individual shot outcomes
-            
+
         Returns:
             Measurement result
 
@@ -206,7 +206,6 @@ class QuantumMeasurement:
         # This would interface with actual quantum hardware/simulator
         # For now, create simulated results
 
-        num_classical_bits = circuit.num_classical_bits
 
         # Simulate measurement outcomes
         if self.backend == "simulator":
@@ -232,7 +231,7 @@ class QuantumMeasurement:
         self.measurement_history.append(result)
         return result
 
-    def _simulate_measurements(self, circuit: "QuantumCircuit", shots: int) -> Dict[str, int]:
+    def _simulate_measurements(self, circuit: "QuantumCircuit", shots: int) -> dict[str, int]:
         """Simulate measurement outcomes"""
         num_bits = circuit.num_classical_bits
 
@@ -245,7 +244,7 @@ class QuantumMeasurement:
 
         return dict(Counter(outcomes))
 
-    def _execute_measurements(self, circuit: "QuantumCircuit", shots: int) -> Dict[str, int]:
+    def _execute_measurements(self, circuit: "QuantumCircuit", shots: int) -> dict[str, int]:
         """Execute measurements on quantum hardware"""
         # This would interface with quantum hardware via client
         # Placeholder for now
@@ -258,12 +257,12 @@ class QuantumMeasurement:
         shots: int = 1024
     ) -> float:
         """Measure expectation value of Pauli observable
-        
+
         Args:
             circuit: Quantum circuit (without measurements)
             observable: Pauli string observable
             shots: Number of shots
-            
+
         Returns:
             Expectation value
 
@@ -306,16 +305,16 @@ class QuantumMeasurement:
     def tomography_measurements(
         self,
         circuit: "QuantumCircuit",
-        qubits: Optional[List[int]] = None,
+        qubits: list[int] | None = None,
         shots_per_measurement: int = 1024
-    ) -> Dict[str, MeasurementResult]:
+    ) -> dict[str, MeasurementResult]:
         """Perform quantum state tomography measurements
-        
+
         Args:
             circuit: Quantum circuit to tomographically reconstruct
             qubits: Qubits to perform tomography on (default: all)
             shots_per_measurement: Shots per Pauli measurement
-            
+
         Returns:
             Dictionary of measurement results for each Pauli basis
 
@@ -354,7 +353,7 @@ class QuantumMeasurement:
         self,
         circuit: "QuantumCircuit",
         pauli_string: str,
-        qubits: List[int]
+        qubits: list[int]
     ) -> "QuantumCircuit":
         """Prepare circuit for tomography measurement"""
         measurement_circuit = circuit.copy()
@@ -379,13 +378,13 @@ class QuantumMeasurement:
 
     def reconstruct_state(
         self,
-        tomography_results: Dict[str, MeasurementResult]
+        tomography_results: dict[str, MeasurementResult]
     ) -> np.ndarray:
         """Reconstruct quantum state from tomography measurements
-        
+
         Args:
             tomography_results: Results from tomography_measurements
-            
+
         Returns:
             Reconstructed density matrix
 
@@ -410,11 +409,11 @@ class QuantumMeasurement:
         state2: np.ndarray
     ) -> float:
         """Calculate quantum state fidelity
-        
+
         Args:
             state1: First quantum state (vector or density matrix)
             state2: Second quantum state (vector or density matrix)
-            
+
         Returns:
             Fidelity between states
 
@@ -447,11 +446,11 @@ class QuantumMeasurement:
         state2: np.ndarray
     ) -> float:
         """Calculate trace distance between quantum states
-        
+
         Args:
             state1: First quantum state
             state2: Second quantum state
-            
+
         Returns:
             Trace distance
 
@@ -478,15 +477,15 @@ class QuantumMeasurement:
         depth: int,
         trials: int = 100,
         shots_per_trial: int = 1024
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Perform quantum volume benchmark
-        
+
         Args:
             num_qubits: Number of qubits
             depth: Circuit depth
             trials: Number of random circuits to test
             shots_per_trial: Shots per circuit
-            
+
         Returns:
             Quantum volume benchmark results
 
@@ -557,13 +556,13 @@ class ResultAnalyzer:
     def compare_results(
         results1: MeasurementResult,
         results2: MeasurementResult
-    ) -> Dict[str, float]:
+    ) -> dict[str, float]:
         """Compare two measurement results
-        
+
         Args:
             results1: First measurement result
             results2: Second measurement result
-            
+
         Returns:
             Comparison metrics
 
@@ -603,17 +602,17 @@ class ResultAnalyzer:
 
     @staticmethod
     def error_mitigation_zero_noise_extrapolation(
-        noise_levels: List[float],
-        measurement_results: List[MeasurementResult],
+        noise_levels: list[float],
+        measurement_results: list[MeasurementResult],
         observable: str = "Z"
-    ) -> Tuple[float, Dict[str, Any]]:
+    ) -> tuple[float, dict[str, Any]]:
         """Perform zero-noise extrapolation error mitigation
-        
+
         Args:
             noise_levels: List of noise levels (e.g., [1, 2, 3])
             measurement_results: Results for each noise level
             observable: Observable to extrapolate
-            
+
         Returns:
             Zero-noise extrapolated value and fitting info
 
@@ -670,21 +669,21 @@ class ResultAnalyzer:
 
     @staticmethod
     def readout_error_mitigation(
-        calibration_results: Dict[str, MeasurementResult],
+        calibration_results: dict[str, MeasurementResult],
         measurement_result: MeasurementResult
     ) -> MeasurementResult:
         """Apply readout error mitigation
-        
+
         Args:
             calibration_results: Results from measuring |0⟩ and |1⟩ states
             measurement_result: Result to correct
-            
+
         Returns:
             Error-mitigated result
 
         """
         # Build calibration matrix
-        num_qubits = len(next(iter(calibration_results.keys())))
+        len(next(iter(calibration_results.keys())))
 
         # This is a simplified implementation
         # Full readout error mitigation would build complete confusion matrix

superquantx/ml.py

@@ -2,7 +2,6 @@
 """
 
 from abc import ABC, abstractmethod
-from typing import Dict, List, Optional
 
 import numpy as np
 from scipy.optimize import minimize
@@ -20,7 +19,7 @@ class QuantumFeatureMap(ABC):
 
     def __init__(self, num_qubits: int, num_features: int):
         """Initialize feature map
-        
+
         Args:
             num_qubits: Number of qubits
             num_features: Number of input features
@@ -32,10 +31,10 @@ class QuantumFeatureMap(ABC):
     @abstractmethod
     def map_features(self, x: np.ndarray) -> QuantumCircuit:
         """Map classical features to quantum state
-        
+
         Args:
             x: Feature vector
-            
+
         Returns:
             Quantum circuit encoding the features
 
@@ -51,10 +50,10 @@ class AngleEmbeddingFeatureMap(QuantumFeatureMap):
         self,
         num_qubits: int,
         num_features: int,
-        rotation_gates: List[str] = None
+        rotation_gates: list[str] = None
     ):
         """Initialize angle embedding
-        
+
         Args:
             num_qubits: Number of qubits
             num_features: Number of features
@@ -117,7 +116,7 @@ class IQPFeatureMap(QuantumFeatureMap):
 
     def __init__(self, num_qubits: int, num_features: int, degree: int = 2):
         """Initialize IQP feature map
-        
+
         Args:
             num_qubits: Number of qubits
             num_features: Number of features
@@ -158,10 +157,10 @@ class QuantumKernel:
     def __init__(
         self,
         feature_map: QuantumFeatureMap,
-        client: Optional[SuperQuantXClient] = None
+        client: SuperQuantXClient | None = None
     ):
         """Initialize quantum kernel
-        
+
         Args:
             feature_map: Quantum feature map
             client: SuperQuantX client for execution
@@ -172,11 +171,11 @@ class QuantumKernel:
 
     def kernel_matrix(self, X1: np.ndarray, X2: np.ndarray = None) -> np.ndarray:
         """Compute quantum kernel matrix
-        
+
         Args:
             X1: First set of data points
             X2: Second set of data points (default: same as X1)
-            
+
         Returns:
             Kernel matrix K[i,j] = ⟨φ(x_i)|φ(x_j)⟩
 
@@ -194,11 +193,11 @@ class QuantumKernel:
 
     def _kernel_value(self, x1: np.ndarray, x2: np.ndarray) -> float:
         """Compute kernel value between two data points
-        
+
         Args:
             x1: First data point
             x2: Second data point
-            
+
         Returns:
             Kernel value ⟨φ(x1)|φ(x2)⟩
 
@@ -260,7 +259,7 @@ class QuantumKernel:
 
         return kernel_circuit
 
-    def _inverse_gate(self, gate: QuantumGate, mapped_qubits: List[int]) -> QuantumGate:
+    def _inverse_gate(self, gate: QuantumGate, mapped_qubits: list[int]) -> QuantumGate:
         """Create inverse gate with mapped qubits"""
         # Simplified inverse gate creation
         inverse_params = [-p for p in gate.parameters] if gate.parameters else []
@@ -305,7 +304,7 @@ class QuantumSVM(BaseEstimator, ClassifierMixin):
         C: float = 1.0
     ):
         """Initialize Quantum SVM
-        
+
         Args:
             quantum_kernel: Quantum kernel for classification
             C: Regularization parameter
@@ -316,19 +315,19 @@ class QuantumSVM(BaseEstimator, ClassifierMixin):
         self.is_fitted_ = False
 
         # Will be set during training
-        self.support_vectors_: Optional[np.ndarray] = None
-        self.support_: Optional[np.ndarray] = None
-        self.alpha_: Optional[np.ndarray] = None
-        self.intercept_: Optional[float] = None
-        self.classes_: Optional[np.ndarray] = None
+        self.support_vectors_: np.ndarray | None = None
+        self.support_: np.ndarray | None = None
+        self.alpha_: np.ndarray | None = None
+        self.intercept_: float | None = None
+        self.classes_: np.ndarray | None = None
 
     def fit(self, X: np.ndarray, y: np.ndarray) -> "QuantumSVM":
         """Fit Quantum SVM
-        
+
         Args:
             X: Training data
             y: Training labels
-            
+
         Returns:
             Fitted model
 
@@ -411,10 +410,10 @@ class QuantumSVM(BaseEstimator, ClassifierMixin):
 
     def decision_function(self, X: np.ndarray) -> np.ndarray:
         """Compute decision function
-        
+
         Args:
             X: Input data
-            
+
         Returns:
             Decision function values
 
@@ -444,10 +443,10 @@ class QuantumSVM(BaseEstimator, ClassifierMixin):
 
     def predict(self, X: np.ndarray) -> np.ndarray:
         """Make predictions
-        
+
         Args:
             X: Input data
-            
+
         Returns:
             Predicted labels
 
@@ -467,12 +466,12 @@ class QuantumClassifier(BaseEstimator, ClassifierMixin):
         self,
         feature_map: QuantumFeatureMap,
         ansatz_layers: int = 2,
-        client: Optional[SuperQuantXClient] = None,
+        client: SuperQuantXClient | None = None,
         optimizer: str = "SLSQP",
         max_iter: int = 1000
     ):
         """Initialize quantum classifier
-        
+
         Args:
             feature_map: Quantum feature map
             ansatz_layers: Number of variational layers
@@ -488,8 +487,8 @@ class QuantumClassifier(BaseEstimator, ClassifierMixin):
         self.max_iter = max_iter
 
         self.is_fitted_ = False
-        self.parameters_: Optional[np.ndarray] = None
-        self.classes_: Optional[np.ndarray] = None
+        self.parameters_: np.ndarray | None = None
+        self.classes_: np.ndarray | None = None
         self.label_encoder_ = LabelEncoder()
 
     def _create_circuit(self, x: np.ndarray, parameters: np.ndarray) -> QuantumCircuit:
@@ -581,11 +580,11 @@ class QuantumClassifier(BaseEstimator, ClassifierMixin):
 
     def fit(self, X: np.ndarray, y: np.ndarray) -> "QuantumClassifier":
         """Fit quantum classifier
-        
+
         Args:
             X: Training data
             y: Training labels
-            
+
         Returns:
             Fitted model
 
@@ -613,10 +612,10 @@ class QuantumClassifier(BaseEstimator, ClassifierMixin):
 
     def predict_proba(self, X: np.ndarray) -> np.ndarray:
         """Predict class probabilities
-        
+
         Args:
             X: Input data
-            
+
         Returns:
             Class probabilities
 
@@ -628,10 +627,10 @@ class QuantumClassifier(BaseEstimator, ClassifierMixin):
 
     def predict(self, X: np.ndarray) -> np.ndarray:
         """Make predictions
-        
+
         Args:
             X: Input data
-            
+
         Returns:
             Predicted labels
 
@@ -649,11 +648,11 @@ class QuantumRegressor(BaseEstimator, RegressorMixin):
         self,
         feature_map: QuantumFeatureMap,
         ansatz_layers: int = 2,
-        client: Optional[SuperQuantXClient] = None,
+        client: SuperQuantXClient | None = None,
         optimizer: str = "SLSQP"
     ):
         """Initialize quantum regressor
-        
+
         Args:
             feature_map: Quantum feature map
             ansatz_layers: Number of variational layers
@@ -667,7 +666,7 @@ class QuantumRegressor(BaseEstimator, RegressorMixin):
         self.optimizer = optimizer
 
         self.is_fitted_ = False
-        self.parameters_: Optional[np.ndarray] = None
+        self.parameters_: np.ndarray | None = None
         self.scaler_ = StandardScaler()
 
     def _create_circuit(self, x: np.ndarray, parameters: np.ndarray) -> QuantumCircuit:
@@ -720,11 +719,11 @@ class QuantumRegressor(BaseEstimator, RegressorMixin):
 
     def fit(self, X: np.ndarray, y: np.ndarray) -> "QuantumRegressor":
         """Fit quantum regressor
-        
+
         Args:
             X: Training data
             y: Training targets
-            
+
         Returns:
             Fitted model
 
@@ -755,10 +754,10 @@ class QuantumRegressor(BaseEstimator, RegressorMixin):
 
     def predict(self, X: np.ndarray) -> np.ndarray:
         """Make predictions
-        
+
         Args:
             X: Input data
-            
+
         Returns:
             Predicted values
 
@@ -783,10 +782,10 @@ class QuantumGAN:
         num_qubits: int,
         generator_layers: int = 3,
         discriminator_layers: int = 2,
-        client: Optional[SuperQuantXClient] = None
+        client: SuperQuantXClient | None = None
     ):
         """Initialize Quantum GAN
-        
+
         Args:
             num_qubits: Number of qubits
             generator_layers: Generator circuit depth
@@ -800,8 +799,8 @@ class QuantumGAN:
         self.client = client
 
         # Parameters will be set during training
-        self.generator_params: Optional[np.ndarray] = None
-        self.discriminator_params: Optional[np.ndarray] = None
+        self.generator_params: np.ndarray | None = None
+        self.discriminator_params: np.ndarray | None = None
 
     def create_generator(self, noise: np.ndarray, params: np.ndarray) -> QuantumCircuit:
         """Create generator circuit"""
@@ -858,14 +857,14 @@ class QuantumGAN:
         training_data: np.ndarray,
         num_epochs: int = 100,
         learning_rate: float = 0.01
-    ) -> Dict[str, List[float]]:
+    ) -> dict[str, list[float]]:
         """Train Quantum GAN
-        
+
         Args:
             training_data: Real training data
             num_epochs: Number of training epochs
             learning_rate: Learning rate
-            
+
         Returns:
             Training history
 
@@ -918,7 +917,7 @@ class QuantumGAN:
 
         return circuit
 
-    def generate_samples(self, num_samples: int) -> List[np.ndarray]:
+    def generate_samples(self, num_samples: int) -> list[np.ndarray]:
         """Generate samples using trained generator"""
         if self.generator_params is None:
             raise ValueError("GAN must be trained before generating samples")
@@ -926,7 +925,7 @@ class QuantumGAN:
         samples = []
         for _ in range(num_samples):
             noise = np.random.uniform(0, 2*np.pi, self.num_qubits)
-            generator_circuit = self.create_generator(noise, self.generator_params)
+            self.create_generator(noise, self.generator_params)
 
             # Extract generated sample (simplified)
             # Would measure and extract amplitudes in practice