quantum-debugger 0.6.0__tar.gz → 0.6.1__tar.gz

quantum_debugger-0.6.1/CHANGELOG.md

@@ -0,0 +1,188 @@
+# Changelog
+
+All notable changes to QuantumDebugger will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.6.1] - 2026-07-16
+
+Release-hardening pass focused on correctness, performance, and robustness. No
+breaking API changes.
+
+### Added
+- **GPU state-vector simulation**: `QuantumCircuit.get_statevector(use_gpu=True,
+  precision='single'|'double')` runs the entire circuit on the GPU (CuPy) — the
+  state lives on the device across all gates with a single transfer back.
+  Verified identical to CPU in double precision; measured ~6x (double) and
+  50-75x (single) vs CPU at 20-22 qubits on an RTX 5060.
+- **Automatic Windows CUDA DLL discovery** so the GPU backend works out of the
+  box with the `cupy-cuda12x` + `nvidia-*-cu12` pip wheel setup.
+
+### Fixed
+- **Import robustness**: a broken or version-incompatible optional dependency
+  (e.g. PennyLane against a mismatched JAX) no longer crashes
+  `import quantum_debugger`. Optional-integration guards now degrade gracefully
+  to `<FRAMEWORK>_AVAILABLE = False` instead of only catching `ImportError`.
+- **QNN training**: `QuantumNeuralNetwork.fit` now uses the compiled optimizer
+  (Adam / SGD) instead of a hardcoded `params -= 0.01 * gradient` that ignored
+  `compile(...)`. Training now actually converges.
+- **QNN readout**: the network output is now a proper Pauli-Z expectation
+  `<Z_0>` over the full distribution, rather than `P(|0...0>) - P(|1...1>)`
+  which discarded almost all amplitudes for >2 qubits.
+- **AutoML**: `AutoQNN` now selects models on a held-out validation split (was
+  scoring on the training data — leakage) and refits the winning configuration
+  on all data.
+- **QAOA**: the cost layer now applies genuine two-qubit ZZ interactions
+  (CNOT·RZ·CNOT) instead of single-qubit RZ rotations, so the ansatz can
+  entangle and reach the true MaxCut optima.
+- **Hybrid (PyTorch)**: fixed a shape-mismatch crash in `HybridQNN` caused by a
+  duplicated output projection, and replaced the all-zero backward pass with
+  finite-difference gradients so the quantum layer (and any preceding classical
+  layers) actually train.
+- Corrected two test bugs exposed once the suite became collectable
+  (a swapped-argument `rx` call and a sign error in a QAOA convergence check).
+- **Windows CUDA DLL discovery**: with the common `cupy-cuda12x` + `nvidia-*-cu12`
+  wheel setup, the CUDA DLLs live under `site-packages/nvidia/*/bin` and are not
+  on the Windows DLL search path, so CuPy failed to load `nvrtc`/`cublas`. The
+  backend now adds those directories to `PATH` and the DLL search list before
+  importing CuPy, so the GPU backend works out of the box (verified on an
+  RTX 5060 / sm_120).
+
+### Reworked — placeholder features are now genuinely quantum
+Several advertised features previously returned classical surrogates, random
+values, or zero gradients. They are now real implementations, each verified:
+- **Quantum fidelity kernel / QSVM**: `FidelityKernel` computes
+  `|<phi(x1)|phi(x2)>|^2` by simulating the real feature-map circuits (was a
+  classical RBF). Gram matrix verified symmetric, unit-diagonal, PSD.
+  `ProjectedKernel` is now the real reduced-density-matrix kernel.
+- **Hybrid quantum layer** (`QuantumMiddleLayer`): forward is now a real
+  encoding + variational circuit measured in Z (was `cos(x + params)`), with
+  exact parameter-shift gradients wired into the PyTorch and TensorFlow layers
+  (were all-zero gradients). Gradients verified against finite differences.
+- **Quantum GAN**: real variational generator circuit and a trainable
+  discriminator with exact BCE gradients (was a global-phase no-op generator and
+  a random discriminator). Generator demonstrably learns a target distribution.
+- **Quantum RL**: real parameterized-circuit Q-function with parameter-shift TD
+  updates (was `tanh` of a dot product). Agent learns the gridworld to optimum.
+- **Error mitigation**: genuine PEC (quasi-probability Monte Carlo that recovers
+  the ideal expectation), CDR (exact Clifford simulation + regression), Quantum
+  Natural Gradient (true Fubini-Study metric, matches analytic values), and ZNE
+  noise scaling by real unitary folding (preserves the logical unitary).
+- **GPU module**: `DistributedQNN`/`DataParallelQNN` now genuinely train via real
+  data-parallel gradient averaging (base class no longer raises
+  `NotImplementedError`); mixed-precision `train_step` uses a real gradient (was
+  random). Multi-GPU wall-clock speedup still requires GPU hardware.
+
+### Changed
+- **Core simulator performance**: `QuantumState.apply_gate` now applies gates by
+  tensor contraction (O(2**n) per gate) instead of materializing the full
+  2**n x 2**n operator (O(4**n)). Results are numerically identical (verified
+  against the previous implementation over thousands of random configurations);
+  16-qubit circuits that were previously infeasible now run in tens of ms.
+- Reconciled version metadata: `__version__` is the single source of truth and
+  `setup.py` reads it (previously `0.4.2` in the package vs `0.6.0` in setup).
+
+## [0.4.2] - 2025-12-22
+
+### Added
+- **Complete pytest migration**: All 200 legacy script-style tests converted to pytest format
+- **Hardware profiles extended**: AWS Braket, Azure Quantum provider support
+- **2025 hardware updates**: IBM Heron, Google Willow, IonQ Forte profiles
+- **Advanced backend tests**: 8 edge case and performance tests
+- **GPU backend support**: CuPy backend availability testing
+- **Enhanced test coverage**: 656 comprehensive tests (all passing ✅)
+
+### Changed
+- Migrated all legacy test files from script execution to pytest format
+- Updated test structure for better CI/CD compatibility
+- Enhanced backend validation with 6 comprehensive backend tests
+- Improved hardware profile testing (18 tests total)
+
+### Fixed
+- Test suite compatibility issues
+- Backend detection for GPU/CuPy
+- Hardware profile version tracking
+
+### Documentation
+- Updated README.md with v0.4.2 features and test count
+- Added comprehensive testing section in README
+- Created FINAL_TEST_SUMMARY.md with complete 656 test breakdown
+- Fixed all documentation links (tutorials, examples, LICENSE)
+- Updated version numbers across all files
+
+### Testing
+- **656 total tests** (all passing ✅)
+- All script-style tests converted to pytest
+- Complete test coverage documentation
+
+## [0.4.1] - 2024-12-XX
+
+### Added
+- Additional QML features and optimizations
+- Performance improvements
+
+## [0.4.0] - 2024-12-XX
+
+### Added
+- **Quantum Machine Learning Module**
+- Parameterized gates (RX, RY, RZ with trainable parameters)
+- VQE algorithm for molecular chemistry
+- QAOA for combinatorial optimization
+- Training framework with 4 optimizers (Adam, SGD, SPSA, RMSprop)
+- Gradient computation (parameter shift rule, finite differences)
+- 316 comprehensive tests
+- 3 tutorials, 4 example scripts
+
+### Changed
+- Enhanced circuit profiling
+- Improved state visualization
+
+## [0.3.0] - 2024-12-XX
+
+### Added
+- Realistic noise models (4 types)
+- Hardware profiles (IBM, Google, IonQ, Rigetti)
+- Qiskit Aer validation
+- 89 new tests
+
+## [0.2.0] - 2024-XX-XX
+
+### Added
+- Bidirectional circuit conversion with Qiskit
+- CP gate support
+- 12-qubit support
+
+## [0.1.1] - 2024-12-03
+
+### Fixed
+- Fixed SWAP gate matrix for little-endian qubit ordering
+- Fixed CNOT gate matrix for little-endian qubit ordering
+- Fixed Toffoli gate matrix for little-endian qubit ordering
+- Fixed entanglement detection for Bell states
+- Rewrote multi-qubit gate expansion algorithm using tensor products
+
+### Added
+- 69 comprehensive tests (100% pass rate)
+- Test suites: quickstart, advanced, comprehensive, extreme, validation, production, edge cases
+- Numerical stability tests (100+ consecutive operations)
+- Quantum mechanics validation tests
+- Production readiness tests
+
+### Changed
+- Improved gate expansion algorithm for better accuracy
+- Enhanced test coverage to 69 tests across 7 test suites
+
+## [0.1.0] - 2024-11-30
+
+### Added
+- Initial release
+- Core quantum state representation
+- 15+ quantum gates (H, X, Y, Z, S, T, RX, RY, RZ, PHASE, CNOT, CZ, SWAP, Toffoli)
+- Step-through debugger with breakpoints
+- Circuit profiler with optimization suggestions
+- State visualization tools
+- Bloch sphere representation
+- Support for up to 15 qubits
+- Example circuits and demos
+- Comprehensive documentation

{quantum_debugger-0.6.0 → quantum_debugger-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quantum-debugger
-Version: 0.6.0
+Version: 0.6.1
 Summary: Comprehensive quantum machine learning library with AutoML, GPU acceleration, advanced algorithms (QGANs, Quantum RL), transfer learning, and multi-framework support (Qiskit, PennyLane, Cirq, TensorFlow, PyTorch)
 Home-page: https://github.com/Raunakg2005/quantum-debugger
 Author: Raunak Kumar Gupta
@@ -28,6 +28,7 @@ License-File: AUTHORS.md
 Requires-Dist: numpy>=1.20.0
 Requires-Dist: scipy>=1.7.0
 Requires-Dist: matplotlib>=3.5.0
+Requires-Dist: scikit-learn>=1.0.0
 Provides-Extra: qiskit
 Requires-Dist: qiskit>=1.0.0; extra == "qiskit"
 Provides-Extra: pennylane
@@ -83,7 +84,22 @@ Dynamic: summary
 [![Python](https://img.shields.io/badge/python-3.9%2B-blue)](https://python.org)
 [![License](https://img.shields.io/badge/license-MIT-green)](LICENSE)
 
-A powerful Python library for quantum circuit debugging, state inspection, performance analysis, and **production-grade quantum machine learning**. From basic circuits to enterprise QML with one-line AutoML.
+A powerful Python library for quantum circuit debugging, state inspection, performance analysis, and quantum machine learning. From basic circuits to QML with one-line AutoML.
+
+## What's New in v0.6.1
+
+Correctness, performance, and "make the advertised features real" release:
+- **Faster core** - gate application is now O(2ⁿ) per gate (was O(4ⁿ)); optional
+  **GPU state-vector simulation** (`get_statevector(use_gpu=True)`, up to ~50-75x
+  at 20+ qubits in single precision).
+- **Genuinely quantum QML** - the quantum kernel/QSVM, hybrid PyTorch/TF layers,
+  Quantum GAN, Quantum RL, and error mitigation (PEC, CDR, QNG, ZNE) are now real
+  circuit-based implementations with real gradients, each verified — not the
+  classical/placeholder stand-ins they were before.
+- **Robust imports** - a broken optional dependency no longer breaks
+  `import quantum_debugger`.
+
+See [CHANGELOG.md](CHANGELOG.md) for the full list.
 
 ## What's New in v0.6.0
 
@@ -141,11 +157,16 @@ predictions = model.predict(X_test)
 - **Auto-Publishing** - Automatic PyPI releases
 - **Code Quality** - Linting, formatting checks
 
-**GPU Acceleration (Week 13 - NEW)**
-- **Multi-GPU** - Distribute training across GPUs (1.8-3x speedup)
-- **Mixed Precision** - FP16/FP32 for 2-3x faster training
-- **Memory Optimization** - Gradient checkpointing (50% reduction)
-- **GPU Benchmarking** - Performance profiling tools
+**GPU Acceleration (v0.6.1)**
+- **GPU state-vector simulation** - `circuit.get_statevector(use_gpu=True)` runs
+  the whole circuit on the GPU (CuPy). Measured on an RTX 5060 vs CPU: ~6x in
+  double precision, and 50-75x in single precision (`precision='single'`) at
+  20-22 qubits, where the CPU becomes the bottleneck.
+- **Distributed / mixed-precision training** - real data-parallel gradient
+  averaging and mixed-precision steps. (Multi-GPU wall-clock speedup requires
+  multiple physical GPUs; on one device these run correctly but sequentially.)
+- **Windows-friendly** - auto-discovers pip-installed CUDA runtime wheels
+  (`nvidia-*-cu12`) so the GPU backend works without a manual CUDA toolkit setup.
 
 See [complete documentation](https://github.com/Raunakg2005/quantum-debugger#documentation) for details.
 
@@ -376,10 +397,10 @@ pytest tests/ --cov=quantum_debugger --cov-report=html
 
 See [FINAL_TEST_SUMMARY.md](tests/FINAL_TEST_SUMMARY.md) for detailed test information.
 
-**Test Statistics:**
-- Total Tests: 384
-- Status: 100% passing
-- Skipped: 3 (AWS Braket - optional dependency)
+**Test Statistics (v0.6.1):**
+- ~980 tests passing (`pytest tests/ -m "not aws"`)
+- GPU-hardware tests require a working CUDA + CuPy install; they skip otherwise
+- A few tests are performance/timing based and may vary by machine
 
 ## Contributing
 
@@ -424,6 +445,5 @@ If you use quantum-debugger in your research, please cite:
 
 ---
 
-**Version:** 0.6.0  
-**Status:** Production Ready  
-**Last Updated:** January 14, 2026
+**Version:** 0.6.1  
+**Last Updated:** July 2026

{quantum_debugger-0.6.0 → quantum_debugger-0.6.1}/README.md

@@ -9,7 +9,22 @@
 [![Python](https://img.shields.io/badge/python-3.9%2B-blue)](https://python.org)
 [![License](https://img.shields.io/badge/license-MIT-green)](LICENSE)
 
-A powerful Python library for quantum circuit debugging, state inspection, performance analysis, and **production-grade quantum machine learning**. From basic circuits to enterprise QML with one-line AutoML.
+A powerful Python library for quantum circuit debugging, state inspection, performance analysis, and quantum machine learning. From basic circuits to QML with one-line AutoML.
+
+## What's New in v0.6.1
+
+Correctness, performance, and "make the advertised features real" release:
+- **Faster core** - gate application is now O(2ⁿ) per gate (was O(4ⁿ)); optional
+  **GPU state-vector simulation** (`get_statevector(use_gpu=True)`, up to ~50-75x
+  at 20+ qubits in single precision).
+- **Genuinely quantum QML** - the quantum kernel/QSVM, hybrid PyTorch/TF layers,
+  Quantum GAN, Quantum RL, and error mitigation (PEC, CDR, QNG, ZNE) are now real
+  circuit-based implementations with real gradients, each verified — not the
+  classical/placeholder stand-ins they were before.
+- **Robust imports** - a broken optional dependency no longer breaks
+  `import quantum_debugger`.
+
+See [CHANGELOG.md](CHANGELOG.md) for the full list.
 
 ## What's New in v0.6.0
 
@@ -67,11 +82,16 @@ predictions = model.predict(X_test)
 - **Auto-Publishing** - Automatic PyPI releases
 - **Code Quality** - Linting, formatting checks
 
-**GPU Acceleration (Week 13 - NEW)**
-- **Multi-GPU** - Distribute training across GPUs (1.8-3x speedup)
-- **Mixed Precision** - FP16/FP32 for 2-3x faster training
-- **Memory Optimization** - Gradient checkpointing (50% reduction)
-- **GPU Benchmarking** - Performance profiling tools
+**GPU Acceleration (v0.6.1)**
+- **GPU state-vector simulation** - `circuit.get_statevector(use_gpu=True)` runs
+  the whole circuit on the GPU (CuPy). Measured on an RTX 5060 vs CPU: ~6x in
+  double precision, and 50-75x in single precision (`precision='single'`) at
+  20-22 qubits, where the CPU becomes the bottleneck.
+- **Distributed / mixed-precision training** - real data-parallel gradient
+  averaging and mixed-precision steps. (Multi-GPU wall-clock speedup requires
+  multiple physical GPUs; on one device these run correctly but sequentially.)
+- **Windows-friendly** - auto-discovers pip-installed CUDA runtime wheels
+  (`nvidia-*-cu12`) so the GPU backend works without a manual CUDA toolkit setup.
 
 See [complete documentation](https://github.com/Raunakg2005/quantum-debugger#documentation) for details.
 
@@ -302,10 +322,10 @@ pytest tests/ --cov=quantum_debugger --cov-report=html
 
 See [FINAL_TEST_SUMMARY.md](tests/FINAL_TEST_SUMMARY.md) for detailed test information.
 
-**Test Statistics:**
-- Total Tests: 384
-- Status: 100% passing
-- Skipped: 3 (AWS Braket - optional dependency)
+**Test Statistics (v0.6.1):**
+- ~980 tests passing (`pytest tests/ -m "not aws"`)
+- GPU-hardware tests require a working CUDA + CuPy install; they skip otherwise
+- A few tests are performance/timing based and may vary by machine
 
 ## Contributing
 
@@ -350,6 +370,5 @@ If you use quantum-debugger in your research, please cite:
 
 ---
 
-**Version:** 0.6.0  
-**Status:** Production Ready  
-**Last Updated:** January 14, 2026
+**Version:** 0.6.1  
+**Last Updated:** July 2026

{quantum_debugger-0.6.0 → quantum_debugger-0.6.1}/quantum_debugger/__init__.py

@@ -11,14 +11,21 @@ Features:
 - Zero-noise extrapolation (v0.4.0)
 - Qiskit integration
 - Hardware profile support
-
-Version: 0.4.0-dev
 """
 
-__version__ = "0.4.2"
-__author__ = "warlord9004"
+__version__ = "0.6.1"
+__author__ = "Raunak Kumar Gupta"
 __license__ = "MIT"
 
+# Make pip-installed CUDA runtime DLLs discoverable (Windows) as early as
+# possible, before anything imports CuPy, so the GPU backend works out of the box.
+try:
+    from .backends._cuda_dll import ensure_cuda_dlls
+
+    ensure_cuda_dlls()
+except Exception:
+    pass
+
 from .core.circuit import QuantumCircuit
 from .core.quantum_state import QuantumState
 from .core.gates import GateLibrary
@@ -54,40 +61,38 @@ from .mitigation import (
 # Optional integrations
 try:
     from .integrations import QiskitAdapter
-    __all_integrations__ = ['QiskitAdapter']
-except ImportError:
+
+    __all_integrations__ = ["QiskitAdapter"]
+except Exception:  # optional integrations must never break the base import
     __all_integrations__ = []
 
 __all__ = [
     # Core
-    'QuantumCircuit',
-    'QuantumState',
-    'GateLibrary',
-    'QuantumDebugger',
-    'Breakpoint',
-    'BreakpointManager',
-    'StateInspector',
-    'CircuitProfiler',
-    'CircuitMetrics',
-    'StateVisualizer',
-    'BlochSphere',
-    
+    "QuantumCircuit",
+    "QuantumState",
+    "GateLibrary",
+    "QuantumDebugger",
+    "Breakpoint",
+    "BreakpointManager",
+    "StateInspector",
+    "CircuitProfiler",
+    "CircuitMetrics",
+    "StateVisualizer",
+    "BlochSphere",
     # Noise Models (v0.3.0)
-    'DepolarizingNoise',
-    'AmplitudeDamping',
-    'PhaseDamping',
-    'ThermalRelaxation',
-    'CompositeNoise',
-    
+    "DepolarizingNoise",
+    "AmplitudeDamping",
+    "PhaseDamping",
+    "ThermalRelaxation",
+    "CompositeNoise",
     # Hardware Profiles
-    'IBM_PERTH_2025',
-    'GOOGLE_SYCAMORE_2025',
-    'IONQ_ARIA_2025',
-    'RIGETTI_ASPEN_2025',
-    
+    "IBM_PERTH_2025",
+    "GOOGLE_SYCAMORE_2025",
+    "IONQ_ARIA_2025",
+    "RIGETTI_ASPEN_2025",
     # Error Mitigation (v0.4.0)
-    'zero_noise_extrapolation',
-    'global_fold',
-    'local_fold',
-    'adaptive_fold',
+    "zero_noise_extrapolation",
+    "global_fold",
+    "local_fold",
+    "adaptive_fold",
 ] + __all_integrations__

{quantum_debugger-0.6.0 → quantum_debugger-0.6.1}/quantum_debugger/backends/__init__.py

@@ -15,6 +15,7 @@ except ImportError:
 
 try:
     from .sparse_backend import SparseBackend
+
     HAS_SPARSE = True
 except ImportError:
     HAS_SPARSE = False
@@ -28,50 +29,48 @@ except ImportError:
 _backend_cache = {}
 
 
-def get_backend(name='auto'):
+def get_backend(name="auto"):
     """
     Get computational backend by name.
-    
+
     Args:
         name: Backend name ('auto', 'numpy', 'numba', 'sparse', 'cupy')
               'auto' selects best available backend
-    
+
     Returns:
         Backend instance
-        
+
     Example:
         >>> backend = get_backend('numba')
         >>> backend = get_backend()  # Auto-select
     """
     if name in _backend_cache:
         return _backend_cache[name]
-    
-    if name == 'auto':
+
+    if name == "auto":
         # Auto-select best available
         if HAS_NUMBA:
             backend = NumbaBackend()
         else:
             backend = NumPyBackend()
-    
-    elif name == 'numpy':
+
+    elif name == "numpy":
         backend = NumPyBackend()
-    
-    elif name == 'numba':
+
+    elif name == "numba":
         if not HAS_NUMBA:
             raise ImportError(
                 "Numba not available. Install with: pip install numba\n"
                 "Falling back to NumPy..."
             )
         backend = NumbaBackend()
-    
-    elif name == 'sparse':
+
+    elif name == "sparse":
         if not HAS_SPARSE:
-            raise ImportError(
-                "SciPy not available. Install with: pip install scipy"
-            )
+            raise ImportError("SciPy not available. Install with: pip install scipy")
         backend = SparseBackend()
-    
-    elif name == 'cupy' or name == 'gpu':
+
+    elif name == "cupy" or name == "gpu":
         if not HAS_CUPY:
             raise ImportError(
                 "CuPy not available. For GPU acceleration, install with:\n"
@@ -80,13 +79,13 @@ def get_backend(name='auto'):
                 "Check https://docs.cupy.dev/en/stable/install.html"
             )
         backend = CuPyBackend()
-    
+
     else:
         raise ValueError(
             f"Unknown backend '{name}'. "
             f"Available: 'auto', 'numpy', 'numba', 'sparse'"
         )
-    
+
     _backend_cache[name] = backend
     return backend
 
@@ -94,44 +93,41 @@ def get_backend(name='auto'):
 def list_available_backends():
     """
     List all available backends on this system.
-    
+
     Returns:
         dict: Backend name -> availability status
     """
     backends = {
-        'numpy': True,  # Always available
-        'numba': HAS_NUMBA,
-        'sparse': HAS_SPARSE,
-        'cupy': HAS_CUPY,
+        "numpy": True,  # Always available
+        "numba": HAS_NUMBA,
+        "sparse": HAS_SPARSE,
+        "cupy": HAS_CUPY,
     }
-    
+
     return backends
 
 
 __all__ = [
-    'Backend',
-    'NumPyBackend',
-    'get_backend',
-    'list_available_backends',
+    "Backend",
+    "NumPyBackend",
+    "get_backend",
+    "list_available_backends",
 ]
 
 if HAS_NUMBA:
-    __all__.append('NumbaBackend')
+    __all__.append("NumbaBackend")
 
 if HAS_SPARSE:
-    __all__.append('SparseBackend')
+    __all__.append("SparseBackend")
 
 if HAS_CUPY:
-    __all__.append('CuPyBackend')
+    __all__.append("CuPyBackend")
 
 # Add GPU backend
 try:
-    from .gpu_backend import (
-        GPUBackend,
-        get_optimal_backend,
-        benchmark_backends
-    )
-    __all__.extend(['GPUBackend', 'get_optimal_backend', 'benchmark_backends'])
+    from .gpu_backend import GPUBackend, get_optimal_backend, benchmark_backends
+
+    __all__.extend(["GPUBackend", "get_optimal_backend", "benchmark_backends"])
 except ImportError:
     pass
 
@@ -140,22 +136,23 @@ try:
     from .ibm_backend import IBMQuantumBackend, IBM_AVAILABLE
     from .aws_backend import AWSBraketBackend, AWS_AVAILABLE
     from .base_backend import QuantumBackend
-    
-    __all__.extend(['IBMQuantumBackend', 'AWSBraketBackend', 'QuantumBackend'])
-    
+
+    __all__.extend(["IBMQuantumBackend", "AWSBraketBackend", "QuantumBackend"])
+
     def get_available_backends():
         """Get list of available quantum backends."""
         backends = []
         if IBM_AVAILABLE:
-            backends.append('ibm')
+            backends.append("ibm")
         if AWS_AVAILABLE:
-            backends.append('aws')
+            backends.append("aws")
         return backends
-    
-    __all__.append('get_available_backends')
-    
+
+    __all__.append("get_available_backends")
+
 except ImportError:
     # Hardware backends not installed
     def get_available_backends():
         return []
-    __all__.append('get_available_backends')
+
+    __all__.append("get_available_backends")