quantum-debugger 0.1.1__py3-none-any.whl

quantum_debugger/debugger/inspector.py

@@ -0,0 +1,219 @@
+"""
+State inspection utilities for debugging
+"""
+
+import numpy as np
+from typing import Dict, List, Tuple
+from quantum_debugger.core.quantum_state import QuantumState
+
+
+class StateInspector:
+    """Utilities for inspecting quantum states during debugging"""
+    
+    @staticmethod
+    def get_state_summary(state: QuantumState) -> Dict:
+        """
+        Get a comprehensive summary of a quantum state
+        
+        Args:
+            state: Quantum state to inspect
+            
+        Returns:
+            Dictionary with state information
+        """
+        probabilities = state.get_probabilities()
+        
+        summary = {
+            'num_qubits': state.num_qubits,
+            'dimension': state.dim,
+            'norm': np.linalg.norm(state.state_vector),
+            'entropy': state.entropy(),
+            'is_entangled': state.is_entangled() if state.num_qubits == 2 else None,
+            'max_amplitude': float(np.max(np.abs(state.state_vector))),
+            'nonzero_amplitudes': int(np.sum(np.abs(state.state_vector) > 1e-10)),
+            'most_likely_state': int(np.argmax(probabilities)),
+            'max_probability': float(np.max(probabilities))
+        }
+        
+        return summary
+    
+    @staticmethod
+    def get_measurement_stats(state: QuantumState) -> Dict[str, float]:
+        """
+        Get measurement statistics for all computational basis states
+        
+        Args:
+            state: Quantum state
+            
+        Returns:
+            Dictionary mapping basis states to probabilities
+        """
+        probabilities = state.get_probabilities()
+        stats = {}
+        
+        for i, prob in enumerate(probabilities):
+            if prob > 1e-10:  # Only include non-negligible probabilities
+                binary = format(i, f'0{state.num_qubits}b')
+                stats[binary] = float(prob)
+        
+        return dict(sorted(stats.items(), key=lambda x: x[1], reverse=True))
+    
+    @staticmethod
+    def get_qubit_probabilities(state: QuantumState, qubit: int) -> Tuple[float, float]:
+        """
+        Get measurement probabilities for a specific qubit
+        
+        Args:
+            state: Quantum state
+            qubit: Qubit index
+            
+        Returns:
+            (probability of 0, probability of 1)
+        """
+        prob_0 = state.get_measurement_probability(qubit, 0)
+        prob_1 = state.get_measurement_probability(qubit, 1)
+        return (prob_0, prob_1)
+    
+    @staticmethod
+    def get_amplitude_info(state: QuantumState) -> List[Dict]:
+        """
+        Get detailed amplitude information for all basis states
+        
+        Args:
+            state: Quantum state
+            
+        Returns:
+            List of dictionaries with amplitude information
+        """
+        amplitudes = []
+        
+        for i, amplitude in enumerate(state.state_vector):
+            if abs(amplitude) > 1e-10:
+                binary = format(i, f'0{state.num_qubits}b')
+                amplitudes.append({
+                    'basis_state': binary,
+                    'index': i,
+                    'amplitude': complex(amplitude),
+                    'magnitude': float(abs(amplitude)),
+                    'phase': float(np.angle(amplitude)),
+                    'probability': float(abs(amplitude) ** 2)
+                })
+        
+        return sorted(amplitudes, key=lambda x: x['probability'], reverse=True)
+    
+    @staticmethod
+    def compare_states(state1: QuantumState, state2: QuantumState) -> Dict:
+        """
+        Compare two quantum states
+        
+        Args:
+            state1: First quantum state
+            state2: Second quantum state
+            
+        Returns:
+            Dictionary with comparison metrics
+        """
+        if state1.num_qubits != state2.num_qubits:
+            raise ValueError("States must have same number of qubits")
+        
+        fidelity = state1.fidelity(state2)
+        
+        # Calculate trace distance
+        trace_distance = np.linalg.norm(
+            state1.state_vector - state2.state_vector
+        ) / np.sqrt(2)
+        
+        return {
+            'fidelity': float(fidelity),
+            'trace_distance': float(trace_distance),
+            'are_equal': fidelity > 0.9999
+        }
+    
+    @staticmethod
+    def check_superposition(state: QuantumState, qubit: int, threshold: float = 0.1) -> bool:
+        """
+        Check if a qubit is in superposition
+        
+        Args:
+            state: Quantum state
+            qubit: Qubit index
+            threshold: Threshold for considering a state in superposition
+            
+        Returns:
+            True if qubit is in superposition
+        """
+        prob_0, prob_1 = StateInspector.get_qubit_probabilities(state, qubit)
+        
+        # In superposition if neither probability is close to 0 or 1
+        return threshold < prob_0 < (1 - threshold) and threshold < prob_1 < (1 - threshold)
+    
+    @staticmethod
+    def format_state_string(state: QuantumState, max_terms: int = 10) -> str:
+        """
+        Format quantum state as readable string
+        
+        Args:
+            state: Quantum state
+            max_terms: Maximum number of terms to show
+            
+        Returns:
+            Formatted string representation
+        """
+        amplitudes = StateInspector.get_amplitude_info(state)
+        
+        if not amplitudes:
+            return "|0>"
+        
+        terms = []
+        for amp_info in amplitudes[:max_terms]:
+            magnitude = amp_info['magnitude']
+            phase = amp_info['phase']
+            basis = amp_info['basis_state']
+            
+            # Format coefficient
+            if abs(phase) < 1e-10:
+                coef = f"{magnitude:.3f}"
+            elif abs(phase - np.pi) < 1e-10:
+                coef = f"-{magnitude:.3f}"
+            else:
+                coef = f"{magnitude:.3f}e^({phase:.2f}i)"
+            
+            terms.append(f"{coef}|{basis}>")
+        
+        if len(amplitudes) > max_terms:
+            terms.append("...")
+        
+        return " + ".join(terms)
+    
+    @staticmethod
+    def print_state_info(state: QuantumState):
+        """
+        Print comprehensive state information to console
+        
+        Args:
+            state: Quantum state to inspect
+        """
+        print("=" * 60)
+        print("QUANTUM STATE INSPECTION")
+        print("=" * 60)
+        
+        summary = StateInspector.get_state_summary(state)
+        print(f"\nState Vector: {StateInspector.format_state_string(state)}")
+        print(f"\nNumber of Qubits: {summary['num_qubits']}")
+        print(f"Dimension: {summary['dimension']}")
+        print(f"Entropy: {summary['entropy']:.4f}")
+        
+        if summary['is_entangled'] is not None:
+            print(f"Entangled: {summary['is_entangled']}")
+        
+        print(f"\nMeasurement Statistics:")
+        stats = StateInspector.get_measurement_stats(state)
+        for basis_state, prob in list(stats.items())[:5]:
+            print(f"  |{basis_state}>: {prob:.4f} ({prob*100:.2f}%)")
+        
+        print(f"\nPer-Qubit Probabilities:")
+        for q in range(state.num_qubits):
+            prob_0, prob_1 = StateInspector.get_qubit_probabilities(state, q)
+            print(f"  Qubit {q}: |0>={prob_0:.4f}, |1>={prob_1:.4f}")
+        
+        print("=" * 60)

quantum_debugger/profiler/__init__.py

@@ -0,0 +1,6 @@
+"""Profiler module for quantum circuit analysis"""
+
+from quantum_debugger.profiler.profiler import CircuitProfiler
+from quantum_debugger.profiler.metrics import CircuitMetrics
+
+__all__ = ["CircuitProfiler", "CircuitMetrics"]

quantum_debugger/profiler/metrics.py

@@ -0,0 +1,129 @@
+"""
+Circuit metrics and analysis
+"""
+
+from typing import Dict, List
+from quantum_debugger.core.circuit import QuantumCircuit
+
+
+class CircuitMetrics:
+    """Container for circuit analysis metrics"""
+    
+    def __init__(self, circuit: QuantumCircuit):
+        self.circuit = circuit
+        self._compute_metrics()
+    
+    def _compute_metrics(self):
+        """Compute all metrics"""
+        self.num_qubits = self.circuit.num_qubits
+        self.total_gates = len(self.circuit.gates)
+        self.depth = self.circuit.depth()
+        
+        # Gate type counts
+        self.gate_counts = {}
+        for gate in self.circuit.gates:
+            name = gate.name
+            self.gate_counts[name] = self.gate_counts.get(name, 0) + 1
+        
+        # Special counts
+        self.single_qubit_gates = sum(
+            1 for g in self.circuit.gates if g.num_qubits == 1
+        )
+        self.two_qubit_gates = sum(
+            1 for g in self.circuit.gates if g.num_qubits == 2
+        )
+        self.three_qubit_gates = sum(
+            1 for g in self.circuit.gates if g.num_qubits == 3
+        )
+        
+        self.cnot_count = self.gate_counts.get('CNOT', 0) + self.gate_counts.get('CX', 0)
+        self.t_count = self.gate_counts.get('T', 0)
+        
+        # Critical path analysis
+        self.critical_path = self._find_critical_path()
+        
+        # Parallelism factor
+        self.parallelism = self.total_gates / self.depth if self.depth > 0 else 0
+    
+    def _find_critical_path(self) -> List[int]:
+        """Find the critical path (longest dependency chain)"""
+        if not self.circuit.gates:
+            return []
+        
+        # Track dependencies
+        qubit_last_gate = {}
+        gate_start_time = []
+        
+        for i, gate in enumerate(self.circuit.gates):
+            # Find latest dependency
+            start_time = 0
+            for q in gate.qubits:
+                if q in qubit_last_gate:
+                    start_time = max(start_time, gate_start_time[qubit_last_gate[q]] + 1)
+            
+            gate_start_time.append(start_time)
+            
+            # Update last gate for each qubit
+            for q in gate.qubits:
+                qubit_last_gate[q] = i
+        
+        # Find path with maximum start time
+        max_time = max(gate_start_time)
+        critical_gates = [i for i, t in enumerate(gate_start_time) if t == max_time]
+        
+        return critical_gates
+    
+    def get_summary(self) -> Dict:
+        """Get summary dictionary of all metrics"""
+        return {
+            'num_qubits': self.num_qubits,
+            'total_gates': self.total_gates,
+            'depth': self.depth,
+            'single_qubit_gates': self.single_qubit_gates,
+            'two_qubit_gates': self.two_qubit_gates,
+            'three_qubit_gates': self.three_qubit_gates,
+            'cnot_count': self.cnot_count,
+            't_count': self.t_count,
+            'parallelism_factor': self.parallelism,
+            'gate_counts': self.gate_counts,
+            'critical_path_length': len(self.critical_path)
+        }
+    
+    def estimate_execution_time(self, gate_time: float = 1.0, 
+                               cnot_time: float = 10.0) -> float:
+        """
+        Estimate execution time on quantum hardware
+        
+        Args:
+            gate_time: Time for single-qubit gate (μs)
+            cnot_time: Time for CNOT gate (μs)
+            
+        Returns:
+            Estimated time in microseconds
+        """
+        single_time = self.single_qubit_gates * gate_time
+        two_time = self.two_qubit_gates * cnot_time
+        
+        return single_time + two_time
+    
+    def estimate_error_rate(self, single_error: float = 0.001, 
+                           cnot_error: float = 0.01) -> float:
+        """
+        Estimate cumulative error rate
+        
+        Args:
+            single_error: Error rate for single-qubit gates
+            cnot_error: Error rate for CNOT gates
+            
+        Returns:
+            Estimated cumulative error rate
+        """
+        # Simplified error model (multiplicative)
+        single_fidelity = (1 - single_error) ** self.single_qubit_gates
+        two_fidelity = (1 - cnot_error) ** self.two_qubit_gates
+        
+        total_fidelity = single_fidelity * two_fidelity
+        return 1 - total_fidelity
+    
+    def __repr__(self):
+        return f"CircuitMetrics({self.num_qubits} qubits, {self.total_gates} gates, depth {self.depth})"

quantum_debugger/profiler/profiler.py

@@ -0,0 +1,174 @@
+"""
+Circuit profiler for performance analysis
+"""
+
+from typing import Dict, List
+from quantum_debugger.core.circuit import QuantumCircuit
+from quantum_debugger.profiler.metrics import CircuitMetrics
+
+
+class CircuitProfiler:
+    """Profiler for analyzing quantum circuit performance"""
+    
+    def __init__(self, circuit: QuantumCircuit):
+        """
+        Initialize profiler
+        
+        Args:
+            circuit: Quantum circuit to profile
+        """
+        self.circuit = circuit
+        self.metrics = CircuitMetrics(circuit)
+    
+    def analyze(self) -> CircuitMetrics:
+        """
+        Analyze the circuit and return metrics
+        
+        Returns:
+            CircuitMetrics object with analysis results
+        """
+        return self.metrics
+    
+    def get_optimization_suggestions(self) -> List[str]:
+        """
+        Get suggestions for circuit optimization
+        
+        Returns:
+            List of optimization suggestions
+        """
+        suggestions = []
+        
+        # High CNOT count
+        if self.metrics.cnot_count > self.metrics.num_qubits * 3:
+            suggestions.append(
+                f"⚠️  High CNOT count ({self.metrics.cnot_count}). "
+                "Consider CNOT reduction techniques."
+            )
+        
+        # High T count
+        if self.metrics.t_count > self.metrics.num_qubits * 2:
+            suggestions.append(
+                f"⚠️  High T-gate count ({self.metrics.t_count}). "
+                "T-gates are expensive on fault-tolerant hardware."
+            )
+        
+        # High depth
+        if self.metrics.depth > self.metrics.num_qubits * 5:
+            suggestions.append(
+                f"⚠️  Circuit depth ({self.metrics.depth}) is high. "
+                "Consider parallelizing gates."
+            )
+        
+        # Low parallelism
+        if self.metrics.parallelism < 1.5 and self.metrics.num_qubits > 2:
+            suggestions.append(
+                f"💡 Low parallelism factor ({self.metrics.parallelism:.2f}). "
+                "Look for opportunities to execute gates in parallel."
+            )
+        
+        # Consecutive gates on same qubit
+        consecutive = self._find_consecutive_single_qubit_gates()
+        if consecutive:
+            suggestions.append(
+                f"💡 Found {len(consecutive)} sequences of consecutive single-qubit gates. "
+                "These could be combined into single rotations."
+            )
+        
+        if not suggestions:
+            suggestions.append("✅ Circuit appears well optimized!")
+        
+        return suggestions
+    
+    def _find_consecutive_single_qubit_gates(self) -> List[tuple]:
+        """Find consecutive single-qubit gates on the same qubit"""
+        consecutive = []
+        
+        for q in range(self.circuit.num_qubits):
+            sequence = []
+            for i, gate in enumerate(self.circuit.gates):
+                if gate.qubits == [q] and gate.num_qubits == 1:
+                    sequence.append(i)
+                else:
+                    if len(sequence) >= 2:
+                        consecutive.append((q, sequence))
+                    sequence = []
+            
+            if len(sequence) >= 2:
+                consecutive.append((q, sequence))
+        
+        return consecutive
+    
+    def compare_with_ideal(self) -> Dict:
+        """
+        Compare circuit with theoretical ideal
+        
+        Returns:
+            Comparison metrics
+        """
+        # Theoretical minimum for common algorithms
+        ideal_depth = self.metrics.num_qubits  # Very rough estimate
+        
+        return {
+            'actual_depth': self.metrics.depth,
+            'ideal_depth': ideal_depth,
+            'depth_overhead': self.metrics.depth / ideal_depth if ideal_depth > 0 else 0,
+            'gate_efficiency': self.metrics.parallelism
+        }
+    
+    def print_report(self):
+        """Print comprehensive profiling report"""
+        print("\n" + "=" * 70)
+        print(" " * 20 + "CIRCUIT PROFILING REPORT")
+        print("=" * 70)
+        
+        # Basic metrics
+        print(f"\n📊 BASIC METRICS")
+        print(f"   Number of Qubits: {self.metrics.num_qubits}")
+        print(f"   Total Gates: {self.metrics.total_gates}")
+        print(f"   Circuit Depth: {self.metrics.depth}")
+        print(f"   Parallelism Factor: {self.metrics.parallelism:.2f}")
+        
+        # Gate breakdown
+        print(f"\n🔧 GATE BREAKDOWN")
+        print(f"   Single-Qubit Gates: {self.metrics.single_qubit_gates}")
+        print(f"   Two-Qubit Gates: {self.metrics.two_qubit_gates}")
+        if self.metrics.three_qubit_gates > 0:
+            print(f"   Three-Qubit Gates: {self.metrics.three_qubit_gates}")
+        
+        print(f"\n   Gate Type Counts:")
+        for gate_name, count in sorted(self.metrics.gate_counts.items(), 
+                                       key=lambda x: x[1], reverse=True):
+            print(f"      {gate_name}: {count}")
+        
+        # Special metrics
+        print(f"\n⚡ SPECIAL METRICS")
+        print(f"   CNOT Count: {self.metrics.cnot_count}")
+        print(f"   T-Gate Count: {self.metrics.t_count}")
+        print(f"   Critical Path Length: {len(self.metrics.critical_path)} gates")
+        
+        # Performance estimates
+        exec_time = self.metrics.estimate_execution_time()
+        error_rate = self.metrics.estimate_error_rate()
+        
+        print(f"\n⏱️  PERFORMANCE ESTIMATES")
+        print(f"   Estimated Execution Time: {exec_time:.2f} μs")
+        print(f"   Estimated Error Rate: {error_rate*100:.4f}%")
+        print(f"   Estimated Fidelity: {(1-error_rate)*100:.4f}%")
+        
+        # Optimization suggestions
+        suggestions = self.get_optimization_suggestions()
+        print(f"\n💡 OPTIMIZATION SUGGESTIONS")
+        for suggestion in suggestions:
+            print(f"   {suggestion}")
+        
+        # Comparison with ideal
+        comparison = self.compare_with_ideal()
+        print(f"\n📈 COMPARISON WITH IDEAL")
+        print(f"   Actual Depth: {comparison['actual_depth']}")
+        print(f"   Theoretical Minimum: {comparison['ideal_depth']}")
+        print(f"   Depth Overhead: {comparison['depth_overhead']:.2f}x")
+        
+        print("=" * 70 + "\n")
+    
+    def __repr__(self):
+        return f"CircuitProfiler({self.metrics})"

quantum_debugger/visualization/__init__.py

@@ -0,0 +1,6 @@
+"""Visualization module for quantum states and circuits"""
+
+from quantum_debugger.visualization.state_viz import StateVisualizer
+from quantum_debugger.visualization.bloch_sphere import BlochSphere
+
+__all__ = ["StateVisualizer", "BlochSphere"]

quantum_debugger/visualization/bloch_sphere.py

@@ -0,0 +1,152 @@
+"""
+Bloch sphere visualization for single-qubit states
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D
+from quantum_debugger.core.quantum_state import QuantumState
+
+
+class BlochSphere:
+    """Bloch sphere visualization for single qubits"""
+    
+    @staticmethod
+    def plot(state: QuantumState, qubit: int = 0, figsize: tuple = (8, 8)):
+        """
+        Plot qubit state on Bloch sphere
+        
+        Args:
+            state: Quantum state
+            qubit: Index of qubit to visualize (for multi-qubit systems)
+            figsize: Figure size
+        """
+        # Get Bloch vector
+        x, y, z = state.bloch_vector(qubit)
+        
+        # Create figure
+        fig = plt.figure(figsize=figsize)
+        ax = fig.add_subplot(111, projection='3d')
+        
+        # Draw sphere
+        u = np.linspace(0, 2 * np.pi, 50)
+        v = np.linspace(0, np.pi, 50)
+        x_sphere = np.outer(np.cos(u), np.sin(v))
+        y_sphere = np.outer(np.sin(u), np.sin(v))
+        z_sphere = np.outer(np.ones(np.size(u)), np.cos(v))
+        
+        ax.plot_surface(x_sphere, y_sphere, z_sphere, 
+                       color='lightblue', alpha=0.2, linewidth=0)
+        
+        # Draw axes
+        axis_length = 1.3
+        ax.plot([0, axis_length], [0, 0], [0, 0], 'k-', linewidth=1, alpha=0.5)
+        ax.plot([0, 0], [0, axis_length], [0, 0], 'k-', linewidth=1, alpha=0.5)
+        ax.plot([0, 0], [0, 0], [0, axis_length], 'k-', linewidth=1, alpha=0.5)
+        
+        # Labels
+        ax.text(axis_length, 0, 0, 'X', fontsize=14, fontweight='bold')
+        ax.text(0, axis_length, 0, 'Y', fontsize=14, fontweight='bold')
+        ax.text(0, 0, axis_length, '|0⟩', fontsize=14, fontweight='bold')
+        ax.text(0, 0, -axis_length, '|1⟩', fontsize=14, fontweight='bold')
+        
+        # Draw state vector
+        ax.quiver(0, 0, 0, x, y, z, color='red', arrow_length_ratio=0.15, 
+                 linewidth=3, label='State Vector')
+        
+        # Draw projection onto XY plane
+        ax.plot([x, x], [y, y], [0, z], 'r--', alpha=0.5, linewidth=1)
+        ax.plot([0, x], [0, y], [0, 0], 'r--', alpha=0.5, linewidth=1)
+        
+        # Mark poles
+        ax.scatter([0], [0], [1], color='blue', s=100, marker='o', label='|0⟩')
+        ax.scatter([0], [0], [-1], color='orange', s=100, marker='o', label='|1⟩')
+        
+        # Mark current state
+        ax.scatter([x], [y], [z], color='red', s=150, marker='*', 
+                  label=f'Qubit {qubit}', zorder=10)
+        
+        # Settings
+        ax.set_xlim([-1.2, 1.2])
+        ax.set_ylim([-1.2, 1.2])
+        ax.set_zlim([-1.2, 1.2])
+        ax.set_xlabel('X', fontsize=12)
+        ax.set_ylabel('Y', fontsize=12)
+        ax.set_zlabel('Z', fontsize=12)
+        ax.set_title(f'Bloch Sphere - Qubit {qubit}', fontsize=16, fontweight='bold')
+        ax.legend(loc='upper right')
+        
+        # Set viewing angle
+        ax.view_init(elev=20, azim=45)
+        
+        plt.tight_layout()
+        plt.show()
+    
+    @staticmethod
+    def plot_trajectory(states: list, qubit: int = 0, figsize: tuple = (8, 8)):
+        """
+        Plot trajectory of state evolution on Bloch sphere
+        
+        Args:
+            states: List of QuantumState objects
+            qubit: Qubit index to visualize
+            figsize: Figure size
+        """
+        # Get Bloch vectors for all states
+        vectors = [s.bloch_vector(qubit) for s in states]
+        xs, ys, zs = zip(*vectors)
+        
+        # Create figure
+        fig = plt.figure(figsize=figsize)
+        ax = fig.add_subplot(111, projection='3d')
+        
+        # Draw sphere
+        u = np.linspace(0, 2 * np.pi, 50)
+        v = np.linspace(0, np.pi, 50)
+        x_sphere = np.outer(np.cos(u), np.sin(v))
+        y_sphere = np.outer(np.sin(u), np.sin(v))
+        z_sphere = np.outer(np.ones(np.size(u)), np.cos(v))
+        
+        ax.plot_surface(x_sphere, y_sphere, z_sphere, 
+                       color='lightblue', alpha=0.15, linewidth=0)
+        
+        # Draw axes
+        axis_length = 1.3
+        ax.plot([0, axis_length], [0, 0], [0, 0], 'k-', linewidth=1, alpha=0.5)
+        ax.plot([0, 0], [0, axis_length], [0, 0], 'k-', linewidth=1, alpha=0.5)
+        ax.plot([0, 0], [0, 0], [0, axis_length], 'k-', linewidth=1, alpha=0.5)
+        
+        # Labels
+        ax.text(axis_length, 0, 0, 'X', fontsize=14, fontweight='bold')
+        ax.text(0, axis_length, 0, 'Y', fontsize=14, fontweight='bold')
+        ax.text(0, 0, axis_length, '|0⟩', fontsize=14, fontweight='bold')
+        ax.text(0, 0, -axis_length, '|1⟩', fontsize=14, fontweight='bold')
+        
+        # Draw trajectory
+        ax.plot(xs, ys, zs, 'r-', linewidth=2, alpha=0.7, label='Trajectory')
+        
+        # Mark start and end
+        ax.scatter([xs[0]], [ys[0]], [zs[0]], color='green', s=150, 
+                  marker='o', label='Start', zorder=10)
+        ax.scatter([xs[-1]], [ys[-1]], [zs[-1]], color='red', s=150, 
+                  marker='*', label='End', zorder=10)
+        
+        # Mark intermediate points
+        if len(states) > 2:
+            ax.scatter(xs[1:-1], ys[1:-1], zs[1:-1], color='orange', 
+                      s=50, alpha=0.6)
+        
+        # Settings
+        ax.set_xlim([-1.2, 1.2])
+        ax.set_ylim([-1.2, 1.2])
+        ax.set_zlim([-1.2, 1.2])
+        ax.set_xlabel('X', fontsize=12)
+        ax.set_ylabel('Y', fontsize=12)
+        ax.set_zlabel('Z', fontsize=12)
+        ax.set_title(f'State Evolution - Qubit {qubit}', fontsize=16, fontweight='bold')
+        ax.legend(loc='upper right')
+        
+        ax.view_init(elev=20, azim=45)
+        
+        plt.tight_layout()
+        plt.show()