quantum-debugger 0.1.1__py3-none-any.whl

quantum_debugger/__init__.py

@@ -0,0 +1,22 @@
+"""
+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.1.0"
+__author__ = "Your Name"
+__license__ = "MIT"
+
+from quantum_debugger.core.circuit import QuantumCircuit
+from quantum_debugger.core.quantum_state import QuantumState
+from quantum_debugger.debugger.debugger import QuantumDebugger
+from quantum_debugger.profiler.profiler import CircuitProfiler
+
+__all__ = [
+    "QuantumCircuit",
+    "QuantumState",
+    "QuantumDebugger",
+    "CircuitProfiler",
+]

quantum_debugger/core/__init__.py

@@ -0,0 +1,7 @@
+"""Core quantum computing components"""
+
+from quantum_debugger.core.quantum_state import QuantumState
+from quantum_debugger.core.circuit import QuantumCircuit
+from quantum_debugger.core.gates import GateLibrary
+
+__all__ = ["QuantumState", "QuantumCircuit", "GateLibrary"]

quantum_debugger/core/circuit.py

@@ -0,0 +1,269 @@
+"""
+Quantum circuit representation and execution
+"""
+
+import numpy as np
+from typing import List, Optional, Union
+from quantum_debugger.core.quantum_state import QuantumState
+from quantum_debugger.core.gates import GateLibrary, Gate
+
+
+class QuantumCircuit:
+    """Quantum circuit with gate operations"""
+    
+    def __init__(self, num_qubits: int, num_classical: int = 0):
+        """
+        Initialize a quantum circuit
+        
+        Args:
+            num_qubits: Number of quantum bits
+            num_classical: Number of classical bits for measurements
+        """
+        self.num_qubits = num_qubits
+        self.num_classical = num_classical if num_classical > 0 else num_qubits
+        self.gates: List[Gate] = []
+        self.measurements: List[tuple] = []
+        self._initial_state = QuantumState(num_qubits)
+    
+    def _add_gate(self, name: str, matrix: np.ndarray, qubits: Union[int, List[int]], params: dict = None):
+        """Add a gate to the circuit"""
+        if isinstance(qubits, int):
+            qubits = [qubits]
+        
+        gate = Gate(name, matrix, qubits, params)
+        self.gates.append(gate)
+        return self
+    
+    # Single-qubit gates
+    def h(self, qubit: int):
+        """Apply Hadamard gate"""
+        return self._add_gate('H', GateLibrary.H, qubit)
+    
+    def x(self, qubit: int):
+        """Apply Pauli-X (NOT) gate"""
+        return self._add_gate('X', GateLibrary.X, qubit)
+    
+    def y(self, qubit: int):
+        """Apply Pauli-Y gate"""
+        return self._add_gate('Y', GateLibrary.Y, qubit)
+    
+    def z(self, qubit: int):
+        """Apply Pauli-Z gate"""
+        return self._add_gate('Z', GateLibrary.Z, qubit)
+    
+    def s(self, qubit: int):
+        """Apply S (phase) gate"""
+        return self._add_gate('S', GateLibrary.S, qubit)
+    
+    def t(self, qubit: int):
+        """Apply T gate"""
+        return self._add_gate('T', GateLibrary.T, qubit)
+    
+    def rx(self, theta: float, qubit: int):
+        """Apply RX rotation gate"""
+        return self._add_gate('RX', GateLibrary.RX(theta), qubit, {'theta': theta})
+    
+    def ry(self, theta: float, qubit: int):
+        """Apply RY rotation gate"""
+        return self._add_gate('RY', GateLibrary.RY(theta), qubit, {'theta': theta})
+    
+    def rz(self, theta: float, qubit: int):
+        """Apply RZ rotation gate"""
+        return self._add_gate('RZ', GateLibrary.RZ(theta), qubit, {'theta': theta})
+    
+    def phase(self, theta: float, qubit: int):
+        """Apply phase shift gate"""
+        return self._add_gate('PHASE', GateLibrary.PHASE(theta), qubit, {'theta': theta})
+    
+    # Two-qubit gates
+    def cnot(self, control: int, target: int):
+        """Apply CNOT (controlled-NOT) gate"""
+        return self._add_gate('CNOT', GateLibrary.CNOT, [control, target])
+    
+    def cx(self, control: int, target: int):
+        """Alias for CNOT"""
+        return self.cnot(control, target)
+    
+    def cz(self, control: int, target: int):
+        """Apply CZ (controlled-Z) gate"""
+        return self._add_gate('CZ', GateLibrary.CZ, [control, target])
+    
+    def swap(self, qubit1: int, qubit2: int):
+        """Apply SWAP gate"""
+        return self._add_gate('SWAP', GateLibrary.SWAP, [qubit1, qubit2])
+    
+    # Three-qubit gates
+    def toffoli(self, control1: int, control2: int, target: int):
+        """Apply Toffoli (CCNOT) gate"""
+        return self._add_gate('TOFFOLI', GateLibrary.TOFFOLI, [control1, control2, target])
+    
+    def ccx(self, control1: int, control2: int, target: int):
+        """Alias for Toffoli"""
+        return self.toffoli(control1, control2, target)
+    
+    # Measurements
+    def measure(self, qubit: int, classical_bit: int = None):
+        """
+        Measure a qubit
+        
+        Args:
+            qubit: Qubit index to measure
+            classical_bit: Classical bit to store result (defaults to same as qubit)
+        """
+        if classical_bit is None:
+            classical_bit = qubit
+        self.measurements.append((qubit, classical_bit))
+        return self
+    
+    def measure_all(self):
+        """Measure all qubits"""
+        for i in range(self.num_qubits):
+            self.measure(i, i)
+        return self
+    
+    # Circuit information
+    def depth(self) -> int:
+        """Calculate circuit depth (number of gate layers)"""
+        if not self.gates:
+            return 0
+        
+        # Track when each qubit is last used
+        qubit_times = [0] * self.num_qubits
+        
+        for gate in self.gates:
+            # Get max time of qubits involved
+            max_time = max(qubit_times[q] for q in gate.qubits)
+            
+            # Update all involved qubits
+            for q in gate.qubits:
+                qubit_times[q] = max_time + 1
+        
+        return max(qubit_times)
+    
+    def size(self) -> int:
+        """Total number of gates"""
+        return len(self.gates)
+    
+    def count_gates(self, gate_name: str = None) -> int:
+        """
+        Count gates of specific type
+        
+        Args:
+            gate_name: Name of gate to count (None for all gates)
+        """
+        if gate_name is None:
+            return len(self.gates)
+        return sum(1 for g in self.gates if g.name == gate_name)
+    
+    # Execution
+    def run(self, shots: int = 1, initial_state: Optional[QuantumState] = None) -> dict:
+        """
+        Execute the circuit
+        
+        Args:
+            shots: Number of times to run the circuit
+            initial_state: Optional initial state (defaults to |0...0>)
+            
+        Returns:
+            Dictionary with measurement results and statistics
+        """
+        results = []
+        
+        for _ in range(shots):
+            state = initial_state.copy() if initial_state else QuantumState(self.num_qubits)
+            
+            # Apply all gates
+            for gate in self.gates:
+                state.apply_gate(gate.matrix, gate.qubits)
+            
+            # Perform measurements
+            classical_bits = [0] * self.num_classical
+            for qubit, classical_bit in self.measurements:
+                classical_bits[classical_bit] = state.measure(qubit)
+            
+            results.append(classical_bits)
+        
+        # Analyze results
+        counts = {}
+        for result in results:
+            key = ''.join(map(str, result))
+            counts[key] = counts.get(key, 0) + 1
+        
+        return {
+            'counts': counts,
+            'results': results,
+            'shots': shots
+        }
+    
+    def get_statevector(self, initial_state: Optional[QuantumState] = None) -> QuantumState:
+        """
+        Get final state vector without measurements
+        
+        Args:
+            initial_state: Optional initial state
+            
+        Returns:
+            Final quantum state
+        """
+        state = initial_state.copy() if initial_state else QuantumState(self.num_qubits)
+        
+        for gate in self.gates:
+            state.apply_gate(gate.matrix, gate.qubits)
+        
+        return state
+    
+    # Visualization helpers
+    def draw(self, output: str = 'text') -> str:
+        """
+        Draw the circuit
+        
+        Args:
+            output: Output format ('text' for ASCII art)
+            
+        Returns:
+            String representation of circuit
+        """
+        if output == 'text':
+            return self._draw_text()
+        return str(self)
+    
+    def _draw_text(self) -> str:
+        """Draw circuit as ASCII art"""
+        lines = []
+        
+        # Header
+        lines.append(f"Circuit with {self.num_qubits} qubits, {len(self.gates)} gates")
+        lines.append("")
+        
+        # Qubit lines
+        for q in range(self.num_qubits):
+            line = f"q{q}: |0>─"
+            
+            for i, gate in enumerate(self.gates):
+                if q in gate.qubits:
+                    # This qubit is involved in this gate
+                    if len(gate.qubits) == 1:
+                        # Single-qubit gate
+                        gate_str = f"[{gate.name}]"
+                    elif gate.qubits[0] == q:
+                        # First qubit (control or first target)
+                        gate_str = "●" if gate.name in ['CNOT', 'CZ'] else "┬"
+                    else:
+                        # Target qubit
+                        gate_str = "⊕" if gate.name == 'CNOT' else "┴"
+                    
+                    line += gate_str + "─"
+                else:
+                    # Not involved, just continue line
+                    line += "─" * (len(gate.name) + 3)
+            
+            lines.append(line)
+        
+        return "\n".join(lines)
+    
+    def __repr__(self):
+        gate_str = ", ".join(str(g) for g in self.gates)
+        return f"QuantumCircuit({self.num_qubits} qubits, gates=[{gate_str}])"
+    
+    def __str__(self):
+        return self.draw()

quantum_debugger/core/gates.py

@@ -0,0 +1,153 @@
+"""
+Quantum gate definitions and operations
+"""
+
+import numpy as np
+from typing import Dict, Callable
+
+
+class GateLibrary:
+    """Library of standard quantum gates"""
+
+    # Single-qubit gates
+    I = np.array([[1, 0], [0, 1]], dtype=complex)  # Identity
+    X = np.array([[0, 1], [1, 0]], dtype=complex)  # Pauli-X (NOT)
+    Y = np.array([[0, -1j], [1j, 0]], dtype=complex)  # Pauli-Y
+    Z = np.array([[1, 0], [0, -1]], dtype=complex)  # Pauli-Z
+    H = np.array([[1, 1], [1, -1]], dtype=complex) / np.sqrt(2)  # Hadamard
+    S = np.array([[1, 0], [0, 1j]], dtype=complex)  # Phase gate
+    T = np.array([[1, 0], [0, np.exp(1j * np.pi / 4)]], dtype=complex)  # T gate
+    
+    # Rotation gates (parameterized)
+    @staticmethod
+    def RX(theta: float) -> np.ndarray:
+        """Rotation around X-axis"""
+        return np.array([
+            [np.cos(theta / 2), -1j * np.sin(theta / 2)],
+            [-1j * np.sin(theta / 2), np.cos(theta / 2)]
+        ], dtype=complex)
+    
+    @staticmethod
+    def RY(theta: float) -> np.ndarray:
+        """Rotation around Y-axis"""
+        return np.array([
+            [np.cos(theta / 2), -np.sin(theta / 2)],
+            [np.sin(theta / 2), np.cos(theta / 2)]
+        ], dtype=complex)
+    
+    @staticmethod
+    def RZ(theta: float) -> np.ndarray:
+        """Rotation around Z-axis"""
+        return np.array([
+            [np.exp(-1j * theta / 2), 0],
+            [0, np.exp(1j * theta / 2)]
+        ], dtype=complex)
+    
+    @staticmethod
+    def PHASE(theta: float) -> np.ndarray:
+        """Phase shift gate"""
+        return np.array([
+            [1, 0],
+            [0, np.exp(1j * theta)]
+        ], dtype=complex)
+    
+    # Two-qubit gates (little-endian: qubit 0 is LSB)
+    # CNOT: control=qubit 0, target=qubit 1
+    # Flips target when control is 1: |10⟩↔|11⟩ (indices 1↔3)
+    CNOT = np.array([
+        [1, 0, 0, 0],  # |00⟩ → |00⟩
+        [0, 0, 0, 1],  # |10⟩ → |11⟩
+        [0, 0, 1, 0],  # |01⟩ → |01⟩
+        [0, 1, 0, 0],  # |11⟩ → |10⟩
+    ], dtype=complex)
+    
+    CZ = np.array([
+        [1, 0, 0, 0],
+        [0, 1, 0, 0],
+        [0, 0, 1, 0],
+        [0, 0, 0, -1]
+    ], dtype=complex)
+    
+    SWAP = np.array([
+        [1, 0, 0, 0],
+        [0, 0, 1, 0],
+        [0, 1, 0, 0],
+        [0, 0, 0, 1]
+    ], dtype=complex)
+    
+    # Three-qubit gates
+    # Toffoli (CCNOT) for little-endian: controls on qubits 0,1; target is qubit 2
+    # Flips target when both controls are 1 (indices 3↔7 in little-endian)
+    TOFFOLI = np.array([
+        [1, 0, 0, 0, 0, 0, 0, 0],
+        [0, 1, 0, 0, 0, 0, 0, 0],
+        [0, 0, 1, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0, 0, 1],  # |110⟩ ↔ |111⟩
+        [0, 0, 0, 0, 1, 0, 0, 0],
+        [0, 0, 0, 0, 0, 1, 0, 0],
+        [0, 0, 0, 0, 0, 0, 1, 0],
+        [0, 0, 0, 1, 0, 0, 0, 0],  # |111⟩ ↔ |110⟩
+    ], dtype=complex)
+    
+    @staticmethod
+    def controlled_gate(gate: np.ndarray) -> np.ndarray:
+        """Create a controlled version of a single-qubit gate"""
+        n = gate.shape[0]
+        controlled = np.eye(2 * n, dtype=complex)
+        controlled[n:, n:] = gate
+        return controlled
+    
+    @staticmethod
+    def tensor_product(*gates) -> np.ndarray:
+        """Compute tensor product of multiple gates"""
+        result = gates[0]
+        for gate in gates[1:]:
+            result = np.kron(result, gate)
+        return result
+
+
+class Gate:
+    """Represents a quantum gate operation"""
+    
+    def __init__(self, name: str, matrix: np.ndarray, qubits: list, params: dict = None):
+        """
+        Initialize a gate
+        
+        Args:
+            name: Gate name (e.g., 'H', 'CNOT', 'RX')
+            matrix: Unitary matrix representing the gate
+            qubits: List of qubit indices the gate acts on
+            params: Optional parameters (e.g., rotation angles)
+        """
+        self.name = name
+        self.matrix = matrix
+        self.qubits = qubits if isinstance(qubits, list) else [qubits]
+        self.params = params or {}
+    
+    def __repr__(self):
+        qubit_str = ','.join(map(str, self.qubits))
+        if self.params:
+            param_str = ','.join(f"{k}={v}" for k, v in self.params.items())
+            return f"{self.name}({param_str})[q{qubit_str}]"
+        return f"{self.name}[q{qubit_str}]"
+    
+    def __str__(self):
+        return self.__repr__()
+    
+    @property
+    def num_qubits(self):
+        """Number of qubits this gate acts on"""
+        return len(self.qubits)
+    
+    def is_controlled(self):
+        """Check if this is a controlled gate"""
+        return self.num_qubits > 1 and self.name.startswith('C')
+    
+    def dagger(self):
+        """Return the conjugate transpose of this gate"""
+        return Gate(
+            name=f"{self.name}†",
+            matrix=self.matrix.conj().T,
+            qubits=self.qubits,
+            params=self.params
+        )