quantum-debugger 0.1.1__tar.gz → 0.2.0__tar.gz

quantum_debugger-0.2.0/PKG-INFO

@@ -0,0 +1,237 @@
+Metadata-Version: 2.4
+Name: quantum-debugger
+Version: 0.2.0
+Summary: Interactive debugger and profiler for quantum circuits
+Home-page: https://github.com/yourusername/quantum-debugger
+Author: warlord9004
+Author-email: your.email@example.com
+Project-URL: Bug Reports, https://github.com/yourusername/quantum-debugger/issues
+Project-URL: Source, https://github.com/yourusername/quantum-debugger
+Project-URL: Documentation, https://quantum-debugger.readthedocs.io
+Keywords: quantum computing debugging profiling quantum-circuit visualization
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Topic :: Software Development :: Debuggers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: matplotlib>=3.5.0
+Requires-Dist: scipy>=1.7.0
+Provides-Extra: qiskit
+Requires-Dist: qiskit>=0.39.0; extra == "qiskit"
+Provides-Extra: cirq
+Requires-Dist: cirq>=1.0.0; extra == "cirq"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=3.0.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: flake8>=4.0.0; extra == "dev"
+Requires-Dist: sphinx>=4.5.0; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# QuantumDebugger
+
+**Interactive debugger and profiler for quantum circuits with Qiskit integration**
+
+[![PyPI version](https://badge.fury.io/py/quantum-debugger.svg)](https://pypi.org/project/quantum-debugger/)
+[![Tests](https://img.shields.io/badge/tests-88%2F88%20passing-brightgreen)]()
+[![Python](https://img.shields.io/badge/python-3.8%2B-blue)]()
+[![License](https://img.shields.io/badge/license-MIT-green)]()
+
+A powerful Python library for step-through debugging, state inspection, and performance analysis of quantum circuits. Now with **production-grade Qiskit integration**!
+
+## ✨ Features
+
+- 🐛 **Step-through Debugging** - Execute circuits gate-by-gate with breakpoints
+- 🔍 **State Inspection** - Analyze quantum states at any point
+- 📊 **Circuit Profiling** - Depth analysis, gate statistics, optimization suggestions  
+- 🎨 **Visualization** - State vectors, Bloch spheres, and more
+- 🔗 **Qiskit Integration** - Import/export circuits from Qiskit (NEW in v0.2.0!)
+- ✅ **100% Tested** - 88 comprehensive tests, production-ready
+
+## 🚀 Quick Start
+
+### Installation
+
+```bash
+pip install quantum-debugger
+```
+
+### Basic Usage
+
+```python
+from quantum_debugger import QuantumCircuit, QuantumDebugger
+
+# Create a Bell state
+qc = QuantumCircuit(2)
+qc.h(0)
+qc.cnot(0, 1)
+
+# Debug step-by-step
+debugger = QuantumDebugger(qc)
+debugger.step()  # Execute first gate
+print(debugger.get_current_state())
+debugger.step()  # Execute second gate
+print(debugger.get_current_state())
+```
+
+### Qiskit Integration (NEW!)
+
+```python
+from qiskit import QuantumCircuit as QiskitCircuit
+from quantum_debugger.integrations.qiskit_adapter import QiskitAdapter
+
+# Import from Qiskit
+qc_qiskit = QiskitCircuit(2)
+qc_qiskit.h(0)
+qc_qiskit.cx(0, 1)
+
+qc_qd = QiskitAdapter.from_qiskit(qc_qiskit)
+
+# Debug with our tools
+debugger = QuantumDebugger(qc_qd)
+debugger.add_breakpoint_at_gate(1)
+debugger.continue_execution()
+
+# Export back to Qiskit
+qc_back = QiskitAdapter.to_qiskit(qc_qd)
+```
+
+## 📚 Core Features
+
+### Supported Gates
+
+**Single-qubit**: H, X, Y, Z, S, T, RX, RY, RZ, PHASE  
+**Two-qubit**: CNOT, CZ, CP (controlled-phase), SWAP  
+**Three-qubit**: Toffoli (CCNOT)
+
+### Debugging Features
+
+- ✅ Forward/backward stepping
+- ✅ Breakpoints (gate-based & conditional)
+- ✅ Execution history tracking
+- ✅ State comparison
+- ✅ Circuit profiling
+
+### Validated Algorithms
+
+Grover's Search • Deutsch-Jozsa • Shor's Period Finding • Quantum Phase Estimation • VQE • Quantum Teleportation • QAOA • Error Correction
+
+## 🎯 Examples
+
+### Debugging Grover's Algorithm
+
+```python
+from quantum_debugger import QuantumCircuit, QuantumDebugger
+
+# 2-qubit Grover's
+qc = QuantumCircuit(2)
+qc.h(0).h(1)  # Superposition
+qc.cz(0, 1)   # Oracle
+qc.h(0).h(1)  # Diffusion
+qc.z(0).z(1)
+qc.cz(0, 1)
+qc.h(0).h(1)
+
+# Debug with breakpoints
+debugger = QuantumDebugger(qc)
+debugger.add_breakpoint_at_gate(2)  # Break after oracle
+debugger.continue_execution()
+print(f"After oracle: {debugger.get_current_state()}")
+```
+
+### Circuit Profiling
+
+```python
+from quantum_debugger import QuantumCircuit, CircuitProfiler
+
+qc = QuantumCircuit(3)
+for i in range(10):
+    qc.h(i % 3)
+    qc.cnot(i % 3, (i + 1) % 3)
+
+profiler = CircuitProfiler(qc)
+metrics = profiler.analyze()
+
+print(f"Depth: {metrics.depth}")
+print(f"Gates: {metrics.total_gates}")
+print("Optimization suggestions:")
+for suggestion in profiler.get_optimization_suggestions():
+    print(f"  • {suggestion}")
+```
+
+## 📊 Testing & Quality
+
+- **88/88 tests passing** (100%)
+- Validated up to **12 qubits** (4,096-D state space)
+- **100+ gate circuits** tested
+- Perfect Qiskit integration fidelity
+- Numerical precision < 1e-10
+
+See [TEST_SUMMARY.md](TEST_SUMMARY.md) for details.
+
+## 🔧 Requirements
+
+- Python 3.8+
+- NumPy >= 1.21.0
+- SciPy >= 1.7.0
+- Matplotlib >= 3.5.0
+- Qiskit >= 2.0 (optional, for integration features)
+
+## 📖 Documentation
+
+- [Examples](examples/) - Interactive demos
+- [Test Summary](TEST_SUMMARY.md) - Complete test coverage
+- [Changelog](CHANGELOG.md) - Version history
+- [Roadmap](ROADMAP.md) - Future features
+
+## 🤝 Contributing
+
+Contributions welcome! See [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md).
+
+## 📄 License
+
+MIT License - see [LICENSE](LICENSE) file.
+
+## 🌟 What's New in v0.2.0
+
+- ✨ **Qiskit Integration** - Bidirectional circuit conversion
+- ✨ **CP Gate** - Controlled-phase gate support  
+- ✨ **19 New Tests** - Qiskit integration fully validated
+- ✨ **12-Qubit Support** - Tested on extreme-scale circuits
+- 🐛 **Bug Fixes** - Improved debugger API compatibility
+
+## 🚀 Roadmap
+
+- [ ] Noise simulation
+- [ ] Web-based debugger UI
+- [ ] Cirq integration
+- [ ] Hardware backend support
+- [ ] Quantum machine learning tools
+
+---
+
+**PyPI**: https://pypi.org/project/quantum-debugger/  
+**Author**: warlord9004  
+**Version**: 0.2.0

quantum_debugger-0.2.0/README.md

@@ -0,0 +1,185 @@
+# QuantumDebugger
+
+**Interactive debugger and profiler for quantum circuits with Qiskit integration**
+
+[![PyPI version](https://badge.fury.io/py/quantum-debugger.svg)](https://pypi.org/project/quantum-debugger/)
+[![Tests](https://img.shields.io/badge/tests-88%2F88%20passing-brightgreen)]()
+[![Python](https://img.shields.io/badge/python-3.8%2B-blue)]()
+[![License](https://img.shields.io/badge/license-MIT-green)]()
+
+A powerful Python library for step-through debugging, state inspection, and performance analysis of quantum circuits. Now with **production-grade Qiskit integration**!
+
+## ✨ Features
+
+- 🐛 **Step-through Debugging** - Execute circuits gate-by-gate with breakpoints
+- 🔍 **State Inspection** - Analyze quantum states at any point
+- 📊 **Circuit Profiling** - Depth analysis, gate statistics, optimization suggestions  
+- 🎨 **Visualization** - State vectors, Bloch spheres, and more
+- 🔗 **Qiskit Integration** - Import/export circuits from Qiskit (NEW in v0.2.0!)
+- ✅ **100% Tested** - 88 comprehensive tests, production-ready
+
+## 🚀 Quick Start
+
+### Installation
+
+```bash
+pip install quantum-debugger
+```
+
+### Basic Usage
+
+```python
+from quantum_debugger import QuantumCircuit, QuantumDebugger
+
+# Create a Bell state
+qc = QuantumCircuit(2)
+qc.h(0)
+qc.cnot(0, 1)
+
+# Debug step-by-step
+debugger = QuantumDebugger(qc)
+debugger.step()  # Execute first gate
+print(debugger.get_current_state())
+debugger.step()  # Execute second gate
+print(debugger.get_current_state())
+```
+
+### Qiskit Integration (NEW!)
+
+```python
+from qiskit import QuantumCircuit as QiskitCircuit
+from quantum_debugger.integrations.qiskit_adapter import QiskitAdapter
+
+# Import from Qiskit
+qc_qiskit = QiskitCircuit(2)
+qc_qiskit.h(0)
+qc_qiskit.cx(0, 1)
+
+qc_qd = QiskitAdapter.from_qiskit(qc_qiskit)
+
+# Debug with our tools
+debugger = QuantumDebugger(qc_qd)
+debugger.add_breakpoint_at_gate(1)
+debugger.continue_execution()
+
+# Export back to Qiskit
+qc_back = QiskitAdapter.to_qiskit(qc_qd)
+```
+
+## 📚 Core Features
+
+### Supported Gates
+
+**Single-qubit**: H, X, Y, Z, S, T, RX, RY, RZ, PHASE  
+**Two-qubit**: CNOT, CZ, CP (controlled-phase), SWAP  
+**Three-qubit**: Toffoli (CCNOT)
+
+### Debugging Features
+
+- ✅ Forward/backward stepping
+- ✅ Breakpoints (gate-based & conditional)
+- ✅ Execution history tracking
+- ✅ State comparison
+- ✅ Circuit profiling
+
+### Validated Algorithms
+
+Grover's Search • Deutsch-Jozsa • Shor's Period Finding • Quantum Phase Estimation • VQE • Quantum Teleportation • QAOA • Error Correction
+
+## 🎯 Examples
+
+### Debugging Grover's Algorithm
+
+```python
+from quantum_debugger import QuantumCircuit, QuantumDebugger
+
+# 2-qubit Grover's
+qc = QuantumCircuit(2)
+qc.h(0).h(1)  # Superposition
+qc.cz(0, 1)   # Oracle
+qc.h(0).h(1)  # Diffusion
+qc.z(0).z(1)
+qc.cz(0, 1)
+qc.h(0).h(1)
+
+# Debug with breakpoints
+debugger = QuantumDebugger(qc)
+debugger.add_breakpoint_at_gate(2)  # Break after oracle
+debugger.continue_execution()
+print(f"After oracle: {debugger.get_current_state()}")
+```
+
+### Circuit Profiling
+
+```python
+from quantum_debugger import QuantumCircuit, CircuitProfiler
+
+qc = QuantumCircuit(3)
+for i in range(10):
+    qc.h(i % 3)
+    qc.cnot(i % 3, (i + 1) % 3)
+
+profiler = CircuitProfiler(qc)
+metrics = profiler.analyze()
+
+print(f"Depth: {metrics.depth}")
+print(f"Gates: {metrics.total_gates}")
+print("Optimization suggestions:")
+for suggestion in profiler.get_optimization_suggestions():
+    print(f"  • {suggestion}")
+```
+
+## 📊 Testing & Quality
+
+- **88/88 tests passing** (100%)
+- Validated up to **12 qubits** (4,096-D state space)
+- **100+ gate circuits** tested
+- Perfect Qiskit integration fidelity
+- Numerical precision < 1e-10
+
+See [TEST_SUMMARY.md](TEST_SUMMARY.md) for details.
+
+## 🔧 Requirements
+
+- Python 3.8+
+- NumPy >= 1.21.0
+- SciPy >= 1.7.0
+- Matplotlib >= 3.5.0
+- Qiskit >= 2.0 (optional, for integration features)
+
+## 📖 Documentation
+
+- [Examples](examples/) - Interactive demos
+- [Test Summary](TEST_SUMMARY.md) - Complete test coverage
+- [Changelog](CHANGELOG.md) - Version history
+- [Roadmap](ROADMAP.md) - Future features
+
+## 🤝 Contributing
+
+Contributions welcome! See [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md).
+
+## 📄 License
+
+MIT License - see [LICENSE](LICENSE) file.
+
+## 🌟 What's New in v0.2.0
+
+- ✨ **Qiskit Integration** - Bidirectional circuit conversion
+- ✨ **CP Gate** - Controlled-phase gate support  
+- ✨ **19 New Tests** - Qiskit integration fully validated
+- ✨ **12-Qubit Support** - Tested on extreme-scale circuits
+- 🐛 **Bug Fixes** - Improved debugger API compatibility
+
+## 🚀 Roadmap
+
+- [ ] Noise simulation
+- [ ] Web-based debugger UI
+- [ ] Cirq integration
+- [ ] Hardware backend support
+- [ ] Quantum machine learning tools
+
+---
+
+**PyPI**: https://pypi.org/project/quantum-debugger/  
+**Author**: warlord9004  
+**Version**: 0.2.0

quantum_debugger-0.2.0/examples/qiskit_integration_demo.py

@@ -0,0 +1,161 @@
+"""
+Qiskit Integration Example
+
+Demonstrates how to use QuantumDebugger with Qiskit circuits.
+"""
+
+from qiskit import QuantumCircuit as QiskitCircuit
+from quantum_debugger import QuantumCircuit, QuantumDebugger
+from quantum_debugger.integrations import QiskitAdapter
+
+
+def example_1_import_qiskit():
+    """Example 1: Import a Qiskit circuit into QuantumDebugger"""
+    print("\n" + "="*70)
+    print("Example 1: Import Qiskit Circuit")
+    print("="*70)
+    
+    # Create a Qiskit circuit (Grover's algorithm for 2 qubits)
+    qc_qiskit = QiskitCircuit(2)
+    qc_qiskit.h(0)
+    qc_qiskit.h(1)
+    qc_qiskit.cz(0, 1)
+    qc_qiskit.h(0)
+    qc_qiskit.h(1)
+    
+    print("\n✓ Created Qiskit circuit (Grover iteration)")
+    print(f"  Qiskit gates: {len(qc_qiskit.data)}")
+    
+    # Convert to QuantumDebugger
+    qc_qd = QiskitAdapter.from_qiskit(qc_qiskit)
+    
+    print(f"\n✓ Imported into QuantumDebugger")
+    print(f"  QuantumDebugger gates: {len(qc_qd.gates)}")
+    
+    # Now use QuantumDebugger features!
+    debugger = QuantumDebugger(qc_qd)
+    
+    print(f"\n✓ Debugging with QuantumDebugger:")
+    for i in range(3):
+        debugger.step()
+        state = debugger.get_current_state()
+        print(f"  Step {i+1}: {state}")
+
+
+def example_2_export_to_qiskit():
+    """Example 2: Create in QuantumDebugger, export to Qiskit"""
+    print("\n" + "="*70)
+    print("Example 2: Export to Qiskit")
+    print("="*70)
+    
+    # Create circuit in QuantumDebugger
+    qc_qd = QuantumCircuit(3)
+    qc_qd.h(0)
+    qc_qd.cnot(0, 1)
+    qc_qd.cnot(1, 2)
+    
+    print("\n✓ Created GHZ state in QuantumDebugger")
+    print(f"  Gates: {len(qc_qd.gates)}")
+    
+    # Convert to Qiskit
+    qc_qiskit = QiskitAdapter.to_qiskit(qc_qd)
+    
+    print(f"\n✓ Exported to Qiskit")
+    print(f"  Qiskit gates: {len(qc_qiskit.data)}")
+    
+    # Now you can use Qiskit features (simulators, hardware, etc.)
+    print("\n✓ Can now use with Qiskit ecosystem:")
+    print("  - Run on IBM Quantum hardware")
+    print("  - Use Qiskit simulators")
+    print("  - Transpile for specific backends")
+
+
+def example_3_debug_qiskit_algorithm():
+    """Example 3: Debug a Qiskit algorithm step-by-step"""
+    print("\n" + "="*70)
+    print("Example 3: Debug Qiskit Algorithm")
+    print("="*70)
+    
+    # Create a parameterized Qiskit circuit (VQE ansatz)
+    import numpy as np
+    qc_qiskit = QiskitCircuit(2)
+    qc_qiskit.ry(np.pi/4, 0)
+    qc_qiskit.ry(np.pi/3, 1)
+    qc_qiskit.cx(0, 1)
+    qc_qiskit.rz(np.pi/2, 1)
+    
+    print("\n✓ Created parameterized Qiskit circuit (VQE ansatz)")
+    
+    # Import to QuantumDebugger
+    qc_qd = QiskitAdapter.from_qiskit(qc_qiskit)
+    
+    # Set up debugger with breakpoint
+    debugger = QuantumDebugger(qc_qd)
+    debugger.add_breakpoint_at_gate(2)  # Break before CNOT
+    
+    print("\n✓ Debugging with breakpoint:")
+    
+    # Step through
+    debugger.step()
+    print(f"  After gate 1: {debugger.get_current_state()}")
+    
+    debugger.step()
+    print(f"  After gate 2: {debugger.get_current_state()}")
+    
+    debugger.continue_execution()
+    print(f"  Final state: {debugger.get_current_state()}")
+
+
+def example_4_compare_results():
+    """Example 4: Compare Qiskit and QuantumDebugger execution"""
+    print("\n" + "="*70)
+    print("Example 4: Compare Results")
+    print("="*70)
+    
+    # Create same circuit in both
+    qc_qiskit = QiskitCircuit(2)
+    qc_qiskit.h(0)
+    qc_qiskit.cx(0, 1)
+    
+    qc_qd = QuantumCircuit(2)
+    qc_qd.h(0)
+    qc_qd.cnot(0, 1)
+    
+    print("\n✓ Created identical Bell state circuits")
+    
+    # Execute in QuantumDebugger
+    state_qd = qc_qd.get_statevector()
+    
+    # Import Qiskit circuit and execute
+    qc_qd_from_qiskit = QiskitAdapter.from_qiskit(qc_qiskit)
+    state_from_qiskit = qc_qd_from_qiskit.get_statevector()
+    
+    # Compare
+    fidelity = state_qd.fidelity(state_from_qiskit)
+    
+    print(f"\n✓ Results comparison:")
+    print(f"  QD state: {state_qd}")
+    print(f"  From Qiskit: {state_from_qiskit}")
+    print(f"  Fidelity: {fidelity:.10f}")
+    
+    if fidelity > 0.9999:
+        print("  ✓ Results match perfectly!")
+
+
+if __name__ == "__main__":
+    print("\n" + "="*70)
+    print(" "*15 + "QISKIT INTEGRATION EXAMPLES")
+    print("="*70)
+    
+    example_1_import_qiskit()
+    example_2_export_to_qiskit()
+    example_3_debug_qiskit_algorithm()
+    example_4_compare_results()
+    
+    print("\n" + "="*70)
+    print("✨ Qiskit integration allows you to:")
+    print("  • Import existing Qiskit circuits")
+    print("  • Debug step-by-step with breakpoints")
+    print("  • Export back to Qiskit for hardware execution")
+    print("  • Leverage both ecosystems together!")
+    print("="*70 + "\n")

quantum_debugger-0.2.0/quantum_debugger/__init__.py

@@ -0,0 +1,42 @@
+"""
+QuantumDebugger - Interactive debugging and profiling for quantum circuits
+
+A powerful Python library for step-through debugging, state inspection,
+and performance analysis of quantum circuits.
+"""
+
+__version__ = "0.2.0"
+__author__ = "warlord9004"
+__license__ = "MIT"
+
+from .core.circuit import QuantumCircuit
+from .core.quantum_state import QuantumState
+from .core.gates import GateLibrary
+from .debugger.debugger import QuantumDebugger
+from .debugger.breakpoints import Breakpoint, BreakpointManager
+from .debugger.inspector import StateInspector
+from .profiler.profiler import CircuitProfiler
+from .profiler.metrics import CircuitMetrics
+from .visualization.state_viz import StateVisualizer
+from .visualization.bloch_sphere import BlochSphere
+
+# Optional integrations
+try:
+    from .integrations import QiskitAdapter
+    __all_integrations__ = ['QiskitAdapter']
+except ImportError:
+    __all_integrations__ = []
+
+__all__ = [
+    'QuantumCircuit',
+    'QuantumState',
+    'GateLibrary',
+    'QuantumDebugger',
+    'Breakpoint',
+    'BreakpointManager',
+    'StateInspector',
+    'CircuitProfiler',
+    'CircuitMetrics',
+    'StateVisualizer',
+    'BlochSphere',
+] + __all_integrations__

{quantum_debugger-0.1.1 → quantum_debugger-0.2.0}/quantum_debugger/core/circuit.py

@@ -88,6 +88,10 @@ class QuantumCircuit:
         """Apply CZ (controlled-Z) gate"""
         return self._add_gate('CZ', GateLibrary.CZ, [control, target])
     
+    def cp(self, theta: float, control: int, target: int):
+        """Apply controlled-phase gate"""
+        return self._add_gate('CP', GateLibrary.CP(theta), [control, target], {'theta': theta})
+    
     def swap(self, qubit1: int, qubit2: int):
         """Apply SWAP gate"""
         return self._add_gate('SWAP', GateLibrary.SWAP, [qubit1, qubit2])