Feature: Interactive Graph Visualization Tool #388

examples/interactive_viz_demo.py

@@ -0,0 +1,41 @@
+"""
+Interactive Visualization Demo
+==============================
+
+This example demonstrates the interactive graph visualizer using a simple
+manually constructed pattern. It shows how to step through the visualization
+and observe state changes.
+"""
+
+from __future__ import annotations
+
+from graphix.command import E, M, N, X, Z
+from graphix.measurements import Measurement
+from graphix.pattern import Pattern
+from graphix.visualization_interactive import InteractiveGraphVisualizer
+
+
+def main() -> None:
+    # optimized pattern for QFT
+    # Create a simple pattern manually for demonstration
+    p = Pattern(input_nodes=[0, 1])
+    p.add(N(node=2))
+    p.add(E(nodes=(0, 2)))
+    p.add(E(nodes=(1, 2)))
+    p.add(M(node=0, measurement=Measurement.XY(0.5)))
+    p.add(M(node=1, measurement=Measurement.XY(0.25)))
+    p.add(X(node=2, domain={0, 1}))
+    p.add(Z(node=2, domain={0}))
+
+    # Or standardization to make it interesting
+    # p.standardize()
+
+    print("Pattern created with", len(p), "commands.")
+    print("Launching interactive visualization with real-time simulation...")
+
+    viz = InteractiveGraphVisualizer(p)
+    viz.visualize()
+
+
+if __name__ == "__main__":
+    main()

examples/interactive_viz_qaoa.py

@@ -0,0 +1,64 @@
+"""
+QAOA Interactive Visualization (Optimized)
+==========================================
+
+This example generates a QAOA pattern using the Graphix Circuit API
+and launches the interactive visualizer in simulation-free mode
+to demonstrate performance on complex patterns.
+"""
+
+from __future__ import annotations
+
+import networkx as nx
+import numpy as np
+
+from graphix import Circuit
+from graphix.visualization_interactive import InteractiveGraphVisualizer
+
+
+def main() -> None:
+    print("Generating QAOA pattern...")
+
+    # 1. Define QAOA Circuit
+    n_qubits = 4
+    rng = np.random.default_rng(42)  # Fixed seed for reproducibility
+
+    # Random parameters for the circuit
+    xi = rng.random(6)
+    theta = rng.random(4)
+
+    # Create a complete graph for the problem hamiltonian
+    g = nx.complete_graph(n_qubits)
+    circuit = Circuit(n_qubits)
+
+    # Apply unitary evolution for the problem Hamiltonian
+    for i, (u, v) in enumerate(g.edges):
+        circuit.cnot(u, v)
+        circuit.rz(v, float(xi[i]))  # Rotation by random angle
+        circuit.cnot(u, v)
+
+    # Apply unitary evolution for the mixing Hamiltonian
+    for v in g.nodes:
+        circuit.rx(v, float(theta[v]))
+
+    # 2. Transpile to MBQC Pattern
+    # This automatically generates the measurement pattern from the gate circuit
+    pattern = circuit.transpile().pattern
+
+    # Standardize the pattern to ensure it follows the standard MBQC form (N, E, M, C)
+    pattern.standardize()
+    pattern.shift_signals()
+
+    print(f"Pattern generated with {len(pattern)} commands.")
+    print("Launching interactive visualizer...")
+    print("Optimization enabled: Simulation is DISABLED for performance.")
+    print("You will see the graph structure and command flow without quantum state calculation.")
+
+    # 3. Launch Visualization
+    # enable_simulation=False prevents high RAM usage for this complex pattern
+    viz = InteractiveGraphVisualizer(pattern, node_distance=(1.5, 1.5), enable_simulation=False)
+    viz.visualize()
+
+
+if __name__ == "__main__":
+    main()