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

superquantx/backends/pennylane_backend.py

@@ -5,7 +5,8 @@ and variational quantum algorithms.
 """
 
 import logging
-from typing import Any, Callable, Dict, List, Optional, Union
+from collections.abc import Callable
+from typing import Any
 
 import numpy as np
 
@@ -26,11 +27,11 @@ except ImportError:
 
 class PennyLaneBackend(BaseBackend):
     """PennyLane backend for quantum computing operations.
-    
+
     This backend provides access to PennyLane's quantum devices and
     automatic differentiation capabilities for variational quantum
     algorithms.
-    
+
     Args:
         device: PennyLane device name ('default.qubit', 'qiskit.aer', etc.)
         wires: Number of qubits/wires
@@ -86,19 +87,19 @@ class PennyLaneBackend(BaseBackend):
 
         return circuit_template
 
-    def add_gate(self, circuit: Callable, gate: str, qubits: Union[int, List[int]],
-                 params: Optional[List[float]] = None) -> Callable:
+    def add_gate(self, circuit: Callable, gate: str, qubits: int | list[int],
+                 params: list[float] | None = None) -> Callable:
         """Add a quantum gate to the circuit (conceptual - PennyLane uses functions)."""
         # In PennyLane, gates are added within quantum functions
         # This method is more for compatibility with the base interface
         logger.debug(f"Gate {gate} would be added to qubits {qubits} with params {params}")
         return circuit
 
-    def add_measurement(self, circuit: Callable, qubits: Optional[List[int]] = None) -> Callable:
+    def add_measurement(self, circuit: Callable, qubits: list[int] | None = None) -> Callable:
         """Add measurement operations (conceptual in PennyLane)."""
         return circuit
 
-    def execute_circuit(self, circuit: Callable, shots: Optional[int] = None) -> Dict[str, Any]:
+    def execute_circuit(self, circuit: Callable, shots: int | None = None) -> dict[str, Any]:
         """Execute quantum circuit and return results."""
         try:
             # Create QNode
@@ -221,7 +222,7 @@ class PennyLaneBackend(BaseBackend):
         return angle_encoding_map
 
     def compute_kernel_matrix(self, X1: np.ndarray, X2: np.ndarray,
-                            feature_map: Callable, shots: Optional[int] = None) -> np.ndarray:
+                            feature_map: Callable, shots: int | None = None) -> np.ndarray:
         """Compute quantum kernel matrix using PennyLane."""
         n1, n2 = len(X1), len(X2)
         kernel_matrix = np.zeros((n1, n2))
@@ -376,7 +377,7 @@ class PennyLaneBackend(BaseBackend):
         return uccsd_circuit
 
     def compute_expectation(self, circuit: Callable, hamiltonian: Any,
-                          shots: Optional[int] = None) -> float:
+                          shots: int | None = None) -> float:
         """Compute expectation value of Hamiltonian."""
         try:
             # If hamiltonian is a PennyLane Hamiltonian
@@ -400,7 +401,7 @@ class PennyLaneBackend(BaseBackend):
             logger.error(f"Expectation computation failed: {e}")
             return 0.0
 
-    def _compute_matrix_expectation(self, circuit: Callable, H: np.ndarray, shots: Optional[int]) -> float:
+    def _compute_matrix_expectation(self, circuit: Callable, H: np.ndarray, shots: int | None) -> float:
         """Compute expectation value for matrix Hamiltonian."""
         # Get statevector
         statevector = self.get_statevector(circuit)
@@ -409,7 +410,7 @@ class PennyLaneBackend(BaseBackend):
         expectation = np.real(np.conj(statevector) @ H @ statevector)
         return float(expectation)
 
-    def get_version_info(self) -> Dict[str, Any]:
+    def get_version_info(self) -> dict[str, Any]:
         """Get PennyLane version information."""
         info = super().get_version_info()
         info.update({

superquantx/backends/qiskit_backend.py

@@ -5,7 +5,7 @@ operations and access to IBM Quantum hardware.
 """
 
 import logging
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Any
 
 import numpy as np
 
@@ -52,10 +52,10 @@ except ImportError:
 
 class QiskitBackend(BaseBackend):
     """Qiskit backend for quantum computing operations.
-    
+
     This backend provides access to Qiskit simulators and IBM Quantum
     hardware for quantum algorithm execution.
-    
+
     Args:
         device: Qiskit backend name ('aer_simulator', 'ibmq_qasm_simulator', etc.)
         provider: IBM Quantum provider (if using IBMQ)
@@ -64,7 +64,7 @@ class QiskitBackend(BaseBackend):
 
     """
 
-    def __init__(self, device: str = 'aer_simulator', provider: Optional[str] = None,
+    def __init__(self, device: str = 'aer_simulator', provider: str | None = None,
                  shots: int = 1024, **kwargs):
         if not QISKIT_AVAILABLE:
             raise ImportError("Qiskit is required for QiskitBackend. Install with: pip install qiskit")
@@ -130,8 +130,8 @@ class QiskitBackend(BaseBackend):
         circuit = QuantumCircuit(qreg, creg)
         return circuit
 
-    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."""
         if isinstance(qubits, int):
             qubits = [qubits]
@@ -169,7 +169,7 @@ class QiskitBackend(BaseBackend):
 
         return circuit
 
-    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."""
         if qubits is None:
             qubits = list(range(circuit.num_qubits))
@@ -180,7 +180,7 @@ class QiskitBackend(BaseBackend):
 
         return circuit
 
-    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."""
         shots = shots or self.shots
 
@@ -293,7 +293,7 @@ class QiskitBackend(BaseBackend):
         return circuit
 
     def compute_kernel_matrix(self, X1: np.ndarray, X2: np.ndarray,
-                            feature_map: QuantumCircuit, shots: Optional[int] = None) -> np.ndarray:
+                            feature_map: QuantumCircuit, shots: int | None = None) -> np.ndarray:
         """Compute quantum kernel matrix using Qiskit."""
         n1, n2 = len(X1), len(X2)
         kernel_matrix = np.zeros((n1, n2))
@@ -377,7 +377,7 @@ class QiskitBackend(BaseBackend):
         return circuit
 
     def compute_expectation(self, circuit: Any, hamiltonian: Any,
-                          shots: Optional[int] = None) -> float:
+                          shots: int | None = None) -> float:
         """Compute expectation value of Hamiltonian."""
         try:
             # For Qiskit, we need to decompose Hamiltonian into Pauli terms
@@ -405,7 +405,7 @@ class QiskitBackend(BaseBackend):
             circuit.h(i)
 
         # QAOA layers
-        for gamma, beta in zip(gammas, betas):
+        for gamma, beta in zip(gammas, betas, strict=False):
             # Problem Hamiltonian layer
             self._apply_problem_hamiltonian(circuit, gamma, problem_instance)
 
@@ -434,7 +434,7 @@ class QiskitBackend(BaseBackend):
         for i in range(circuit.num_qubits):
             circuit.rx(2 * beta, i)
 
-    def get_version_info(self) -> Dict[str, Any]:
+    def get_version_info(self) -> dict[str, Any]:
         """Get Qiskit version information."""
         info = super().get_version_info()
 

superquantx/backends/simulator_backend.py

@@ -5,7 +5,8 @@ require external quantum computing libraries, useful for testing and fallback.
 """
 
 import logging
-from typing import Any, Callable, Dict, List, Optional, Union
+from collections.abc import Callable
+from typing import Any
 
 import numpy as np
 
@@ -22,7 +23,7 @@ class QuantumState:
         self.state = np.zeros(2**n_qubits, dtype=complex)
         self.state[0] = 1.0  # |00...0⟩ state
 
-    def apply_gate(self, gate_matrix: np.ndarray, qubits: List[int]) -> None:
+    def apply_gate(self, gate_matrix: np.ndarray, qubits: list[int]) -> None:
         """Apply gate matrix to specified qubits."""
         if len(qubits) == 1:
             self._apply_single_qubit_gate(gate_matrix, qubits[0])
@@ -56,7 +57,7 @@ class QuantumState:
         # Apply gate
         self.state = full_gate @ self.state
 
-    def _apply_two_qubit_gate(self, gate: np.ndarray, qubits: List[int]) -> None:
+    def _apply_two_qubit_gate(self, gate: np.ndarray, qubits: list[int]) -> None:
         """Apply two qubit gate."""
         # Simplified implementation for CNOT and other 2-qubit gates
         q1, q2 = qubits
@@ -95,7 +96,7 @@ class QuantumState:
                 return False
         return True
 
-    def measure(self, shots: int = 1024) -> Dict[str, int]:
+    def measure(self, shots: int = 1024) -> dict[str, int]:
         """Measure the quantum state."""
         probabilities = np.abs(self.state)**2
 
@@ -116,11 +117,11 @@ class QuantumState:
 
 class SimulatorBackend(BaseBackend):
     """Pure Python quantum simulator backend.
-    
+
     This backend provides a simple quantum simulator implementation
     that doesn't require external libraries. Useful for testing,
     development, and as a fallback when other backends are unavailable.
-    
+
     Args:
         device: Device name (always 'simulator')
         max_qubits: Maximum number of qubits to simulate
@@ -140,6 +141,8 @@ class SimulatorBackend(BaseBackend):
             'supports_backprop': False,
             'supports_hardware': False,
             'supports_noise_models': False,
+            'supports_measurements': True,  # Can perform measurements
+            'supports_parameterized_circuits': True,  # Can handle parameterized circuits
         }
 
         # Gate matrices
@@ -149,10 +152,10 @@ class SimulatorBackend(BaseBackend):
         """Initialize simulator backend."""
         logger.info(f"Initialized Python quantum simulator with max {self.max_qubits} qubits")
 
-    def _define_gates(self) -> Dict[str, np.ndarray]:
+    def _define_gates(self) -> dict[str, np.ndarray]:
         """Define quantum gate matrices."""
         # Pauli matrices
-        I = np.array([[1, 0], [0, 1]], dtype=complex)
+        identity = np.array([[1, 0], [0, 1]], dtype=complex)
         X = np.array([[0, 1], [1, 0]], dtype=complex)
         Y = np.array([[0, -1j], [1j, 0]], dtype=complex)
         Z = np.array([[1, 0], [0, -1]], dtype=complex)
@@ -189,7 +192,7 @@ class SimulatorBackend(BaseBackend):
         ], dtype=complex)
 
         return {
-            'I': I, 'X': X, 'Y': Y, 'Z': Z, 'H': H, 'S': S, 'T': T,
+            'I': identity, 'X': X, 'Y': Y, 'Z': Z, 'H': H, 'S': S, 'T': T,
             'CNOT': CNOT, 'CX': CNOT, 'CZ': CZ, 'SWAP': SWAP,
             'PAULI_X': X, 'PAULI_Y': Y, 'PAULI_Z': Z, 'HADAMARD': H
         }
@@ -222,8 +225,8 @@ class SimulatorBackend(BaseBackend):
 
         return QuantumState(n_qubits)
 
-    def add_gate(self, circuit: QuantumState, gate: str, qubits: Union[int, List[int]],
-                 params: Optional[List[float]] = None) -> QuantumState:
+    def add_gate(self, circuit: QuantumState, gate: str, qubits: int | list[int],
+                 params: list[float] | None = None) -> QuantumState:
         """Add a quantum gate to the circuit."""
         if isinstance(qubits, int):
             qubits = [qubits]
@@ -257,7 +260,7 @@ class SimulatorBackend(BaseBackend):
 
         return circuit
 
-    def _apply_toffoli(self, circuit: QuantumState, qubits: List[int]) -> None:
+    def _apply_toffoli(self, circuit: QuantumState, qubits: list[int]) -> None:
         """Apply Toffoli gate (simplified implementation)."""
         # This is a simplified implementation
         # Full implementation would require proper 3-qubit gate matrix
@@ -268,12 +271,12 @@ class SimulatorBackend(BaseBackend):
         cnot_matrix = self.gates['CNOT']
         circuit.apply_gate(cnot_matrix, qubits[1:3])
 
-    def add_measurement(self, circuit: QuantumState, qubits: Optional[List[int]] = None) -> QuantumState:
+    def add_measurement(self, circuit: QuantumState, qubits: list[int] | None = None) -> QuantumState:
         """Add measurement operations (no-op in this implementation)."""
         # Measurements are handled in execute_circuit
         return circuit
 
-    def execute_circuit(self, circuit: QuantumState, shots: Optional[int] = None) -> Dict[str, Any]:
+    def execute_circuit(self, circuit: QuantumState, shots: int | None = None) -> dict[str, Any]:
         """Execute quantum circuit and return results."""
         shots = shots or self.shots
 
@@ -310,7 +313,7 @@ class SimulatorBackend(BaseBackend):
     # ========================================================================
 
     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 using simulator."""
         n1, n2 = len(X1), len(X2)
         kernel_matrix = np.zeros((n1, n2))
@@ -423,7 +426,7 @@ class SimulatorBackend(BaseBackend):
         return ansatz_circuit
 
     def compute_expectation(self, circuit: QuantumState, hamiltonian: Any,
-                          shots: Optional[int] = None) -> float:
+                          shots: int | None = None) -> float:
         """Compute expectation value of Hamiltonian."""
         try:
             if isinstance(hamiltonian, np.ndarray):
@@ -440,7 +443,7 @@ class SimulatorBackend(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 simulator version information."""
         info = super().get_version_info()
         info.update({
@@ -450,6 +453,17 @@ class SimulatorBackend(BaseBackend):
         })
         return info
 
+    def get_backend_info(self) -> dict[str, Any]:
+        """Get backend information."""
+        return {
+            'backend_name': self.__class__.__name__,
+            'device': self.device_name,
+            'capabilities': self.capabilities,
+            'simulator_type': 'pure_python',
+            'max_qubits': self.max_qubits,
+            'available_gates': list(self.gates.keys()),
+        }
+
     def is_available(self) -> bool:
         """Check if the backend is available."""
         return True

superquantx/backends/tket_backend.py

@@ -5,7 +5,7 @@ hardware for advanced quantum circuit compilation and optimization.
 """
 
 import logging
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any
 
 import numpy as np
 
@@ -47,21 +47,21 @@ except ImportError:
 
 class TKETBackend(BaseBackend):
     """TKET (Quantum Toolkit) backend for quantum computing operations.
-    
+
     This backend provides access to TKET's quantum circuit compilation,
     optimization, and execution capabilities, including Quantinuum hardware.
-    
+
     Args:
         device: Device name (e.g., 'aer_simulator', 'H1-1E', 'H1-2E', 'simulator')
         shots: Number of measurement shots
         machine: Specific Quantinuum machine for hardware execution
         api_key: Quantinuum API key (required for hardware)
         **kwargs: Additional backend configuration
-        
+
     Example:
         >>> # Local simulator
         >>> backend = TKETBackend(device='aer_simulator')
-        >>> 
+        >>>
         >>> # Quantinuum hardware (requires API key)
         >>> backend = TKETBackend(
         ...     device='H1-1E',
@@ -74,8 +74,8 @@ class TKETBackend(BaseBackend):
         self,
         device: str = 'aer_simulator',
         shots: int = 1024,
-        machine: Optional[str] = None,
-        api_key: Optional[str] = None,
+        machine: str | None = None,
+        api_key: str | None = None,
         **kwargs
     ) -> None:
         if not TKET_AVAILABLE:
@@ -150,7 +150,7 @@ class TKETBackend(BaseBackend):
                 device_info = self._backend.device
                 if hasattr(device_info, 'n_nodes'):
                     return device_info.n_nodes
-            except:
+            except (AttributeError, Exception):
                 pass
 
         # Default estimates based on device name
@@ -163,7 +163,7 @@ class TKETBackend(BaseBackend):
         else:
             return 32  # Conservative estimate
 
-    def _get_native_gates(self) -> List[str]:
+    def _get_native_gates(self) -> list[str]:
         """Get native gates supported by TKET."""
         # TKET supports a rich set of gates
         return [
@@ -187,8 +187,8 @@ class TKETBackend(BaseBackend):
         circuit = Circuit(n_qubits)
         return circuit
 
-    def add_gate(self, circuit: Circuit, gate: str, qubits: Union[int, List[int]],
-                 params: Optional[List[float]] = None) -> Circuit:
+    def add_gate(self, circuit: Circuit, gate: str, qubits: int | list[int],
+                 params: list[float] | None = None) -> Circuit:
         """Add a quantum gate to the circuit."""
         if isinstance(qubits, int):
             qubits = [qubits]
@@ -239,7 +239,7 @@ class TKETBackend(BaseBackend):
 
         return circuit
 
-    def add_measurement(self, circuit: Circuit, qubits: Union[int, List[int]]) -> Circuit:
+    def add_measurement(self, circuit: Circuit, qubits: int | list[int]) -> Circuit:
         """Add measurement instructions to specified qubits."""
         if isinstance(qubits, int):
             qubits = [qubits]
@@ -254,7 +254,7 @@ class TKETBackend(BaseBackend):
 
         return circuit
 
-    def execute_circuit(self, circuit: Circuit, shots: Optional[int] = None) -> Dict[str, Any]:
+    def execute_circuit(self, circuit: Circuit, shots: int | None = None) -> dict[str, Any]:
         """Execute quantum circuit and return results."""
         shots = shots or self.shots
 
@@ -360,7 +360,7 @@ class TKETBackend(BaseBackend):
             logger.error(f"Circuit optimization failed: {e}")
             return circuit
 
-    def create_parameterized_circuit(self, n_qubits: int, n_params: int) -> Tuple[Circuit, List[str]]:
+    def create_parameterized_circuit(self, n_qubits: int, n_params: int) -> tuple[Circuit, list[str]]:
         """Create a parameterized quantum circuit for variational algorithms."""
         from pytket.circuit import fresh_symbol
 
@@ -376,7 +376,7 @@ class TKETBackend(BaseBackend):
 
         return circuit, param_names
 
-    def bind_parameters(self, circuit: Circuit, param_values: Dict[str, float]) -> Circuit:
+    def bind_parameters(self, circuit: Circuit, param_values: dict[str, float]) -> Circuit:
         """Bind parameter values to parameterized circuit."""
         try:
             bound_circuit = circuit.copy()
@@ -384,7 +384,7 @@ class TKETBackend(BaseBackend):
             # Create symbol substitution map
             if hasattr(circuit, '_symbols'):
                 symbol_map = {}
-                for symbol, name in zip(circuit._symbols, circuit._param_names):
+                for symbol, name in zip(circuit._symbols, circuit._param_names, strict=False):
                     if name in param_values:
                         symbol_map[symbol] = param_values[name]
 
@@ -397,8 +397,8 @@ class TKETBackend(BaseBackend):
             logger.error(f"Parameter binding failed: {e}")
             return circuit
 
-    def expectation_value(self, circuit: Circuit, observable: Union[str, np.ndarray],
-                         shots: Optional[int] = None) -> float:
+    def expectation_value(self, circuit: Circuit, observable: str | np.ndarray,
+                         shots: int | None = None) -> float:
         """Calculate expectation value of observable using TKET."""
         shots = shots or self.shots
 
@@ -436,7 +436,7 @@ class TKETBackend(BaseBackend):
     # Backend Information
     # ========================================================================
 
-    def get_backend_info(self) -> Dict[str, Any]:
+    def get_backend_info(self) -> dict[str, Any]:
         """Get information about the TKET backend."""
         info = {
             'backend_name': 'tket',
@@ -459,21 +459,21 @@ class TKETBackend(BaseBackend):
 
         return info
 
-    def get_version_info(self) -> Dict[str, str]:
+    def get_version_info(self) -> dict[str, str]:
         """Get version information for TKET dependencies."""
         version_info = {'backend_version': '1.0.0'}
 
         try:
             import pytket
             version_info['pytket'] = pytket.__version__
-        except:
+        except (ImportError, AttributeError):
             pass
 
         if QUANTINUUM_AVAILABLE:
             try:
                 import pytket.extensions.quantinuum
                 version_info['pytket_quantinuum'] = getattr(pytket.extensions.quantinuum, '__version__', 'unknown')
-            except:
+            except (ImportError, AttributeError):
                 pass
 
         return version_info
@@ -482,7 +482,7 @@ class TKETBackend(BaseBackend):
         """Check if the backend is available and properly configured."""
         return TKET_AVAILABLE
 
-    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/circuits.py

@@ -3,7 +3,7 @@
 
 import json
 from copy import deepcopy
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any
 
 from pydantic import BaseModel, Field
 
@@ -13,14 +13,14 @@ class QuantumGate(BaseModel):
     """
 
     name: str = Field(..., description="Gate name (e.g., 'H', 'CNOT', 'RZ')")
-    qubits: List[int] = Field(..., description="Target qubit indices")
-    parameters: List[float] = Field(default_factory=list, description="Gate parameters")
-    classical_condition: Optional[Tuple[str, int]] = Field(
+    qubits: list[int] = Field(..., description="Target qubit indices")
+    parameters: list[float] = Field(default_factory=list, description="Gate parameters")
+    classical_condition: tuple[str, int] | None = Field(
         default=None,
         description="Classical register condition (register_name, value)"
     )
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         """Convert gate to dictionary representation"""
         return {
             "name": self.name,
@@ -30,7 +30,7 @@ class QuantumGate(BaseModel):
         }
 
     @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "QuantumGate":
+    def from_dict(cls, data: dict[str, Any]) -> "QuantumGate":
         """Create gate from dictionary representation"""
         return cls(**data)
 
@@ -62,7 +62,7 @@ class QuantumRegister(BaseModel):
 
 class QuantumCircuit:
     """Quantum circuit representation with gate operations and measurements
-    
+
     This class provides a high-level interface for building and manipulating
     quantum circuits compatible with multiple quantum computing frameworks.
     """
@@ -70,11 +70,11 @@ class QuantumCircuit:
     def __init__(
         self,
         num_qubits: int,
-        num_classical_bits: Optional[int] = None,
-        name: Optional[str] = None
+        num_classical_bits: int | None = None,
+        name: str | None = None
     ):
         """Initialize a quantum circuit
-        
+
         Args:
             num_qubits: Number of qubits in the circuit
             num_classical_bits: Number of classical bits (defaults to num_qubits)
@@ -85,16 +85,16 @@ class QuantumCircuit:
         self.num_classical_bits = num_classical_bits or num_qubits
         self.name = name or f"circuit_{id(self)}"
 
-        self.quantum_registers: List[QuantumRegister] = [
+        self.quantum_registers: list[QuantumRegister] = [
             QuantumRegister(name="q", size=num_qubits)
         ]
-        self.classical_registers: List[ClassicalRegister] = [
+        self.classical_registers: list[ClassicalRegister] = [
             ClassicalRegister(name="c", size=self.num_classical_bits)
         ]
 
-        self.gates: List[QuantumGate] = []
-        self.measurements: List[Tuple[int, int]] = []  # (qubit_index, classical_bit_index)
-        self.barriers: List[List[int]] = []  # Barrier positions
+        self.gates: list[QuantumGate] = []
+        self.measurements: list[tuple[int, int]] = []  # (qubit_index, classical_bit_index)
+        self.barriers: list[list[int]] = []  # Barrier positions
 
     def __len__(self) -> int:
         """Return the number of gates in the circuit"""
@@ -107,7 +107,7 @@ class QuantumCircuit:
         """Create a deep copy of the circuit"""
         return deepcopy(self)
 
-    def add_register(self, register: Union[QuantumRegister, ClassicalRegister]) -> None:
+    def add_register(self, register: QuantumRegister | ClassicalRegister) -> None:
         """Add a quantum or classical register to the circuit"""
         if isinstance(register, QuantumRegister):
             self.quantum_registers.append(register)
@@ -260,7 +260,7 @@ class QuantumCircuit:
             self.measure(i, i)
         return self
 
-    def barrier(self, qubits: Optional[List[int]] = None) -> "QuantumCircuit":
+    def barrier(self, qubits: list[int] | None = None) -> "QuantumCircuit":
         """Add a barrier (prevents gate reordering across barrier)"""
         if qubits is None:
             qubits = list(range(self.num_qubits))
@@ -268,13 +268,13 @@ class QuantumCircuit:
         return self
 
     # Circuit composition
-    def compose(self, other: "QuantumCircuit", qubits: Optional[List[int]] = None) -> "QuantumCircuit":
+    def compose(self, other: "QuantumCircuit", qubits: list[int] | None = None) -> "QuantumCircuit":
         """Compose this circuit with another circuit
-        
+
         Args:
             other: Circuit to compose with
             qubits: Qubit mapping for the other circuit
-            
+
         Returns:
             New composed circuit
 
@@ -354,7 +354,7 @@ class QuantumCircuit:
             return gate
 
     # Export functions
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         """Convert circuit to dictionary representation"""
         return {
             "name": self.name,
@@ -372,7 +372,7 @@ class QuantumCircuit:
         return json.dumps(self.to_dict(), indent=indent)
 
     @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "QuantumCircuit":
+    def from_dict(cls, data: dict[str, Any]) -> "QuantumCircuit":
         """Create circuit from dictionary representation"""
         circuit = cls(
             num_qubits=data["num_qubits"],
@@ -400,10 +400,10 @@ class QuantumCircuit:
 
     def draw(self, output: str = "text") -> str:
         """Draw the circuit in text format
-        
+
         Args:
             output: Output format ("text" only for now)
-            
+
         Returns:
             String representation of the circuit
 
@@ -417,7 +417,7 @@ class QuantumCircuit:
             lines.append(line)
 
         for gate in self.gates:
-            max_qubit = max(gate.qubits)
+            max(gate.qubits)
             gate_repr = gate.name
 
             if len(gate.qubits) == 1: