qcompile 0.1.0__py3-none-any.whl

qcompile/__init__.py

@@ -0,0 +1,585 @@
+# ============================================================================
+# ALPHAZERO + A* NEURAL QUANTUM COMPILER (LIVE IBM HARDWARE AWARE)
+# Reusable Module for AI-Guided SWAP, DEPTH & NOISE Reduction
+# ============================================================================
+
+import numpy as np
+import warnings
+import networkx as nx
+import random
+import sys
+import time
+import threading
+import logging
+from joblib import Parallel, delayed
+
+from qiskit import QuantumCircuit
+from qiskit.transpiler import CouplingMap, Layout
+from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
+from qiskit_ibm_runtime import QiskitRuntimeService
+
+import torch
+import torch.nn.functional as F
+from torch_geometric.data import Data, DataLoader
+from torch_geometric.nn import GATv2Conv
+
+# Suppress warnings to keep the terminal beautiful
+warnings.filterwarnings("ignore")
+logging.getLogger("qiskit_runtime_service").setLevel(logging.ERROR)
+logging.getLogger("qiskit_ibm_runtime").setLevel(logging.ERROR) # <-- ADD THIS LINE
+# ============================================================================
+# UTILITY: TERMINAL SPINNER
+# ============================================================================
+class TerminalSpinner:
+    def __init__(self, message="Processing..."):
+        self.spinner_chars = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
+        self.message = message
+        self.running = False
+        self.thread = None
+
+    def spin(self):
+        while self.running:
+            for char in self.spinner_chars:
+                if not self.running:
+                    break
+                sys.stdout.write(f"\r\033[36m{char}\033[0m {self.message}")
+                sys.stdout.flush()
+                time.sleep(0.08)
+
+    def start(self):
+        self.running = True
+        self.thread = threading.Thread(target=self.spin)
+        self.thread.start()
+
+    def stop(self, success_msg=None):
+        self.running = False
+        if self.thread:
+            self.thread.join()
+        sys.stdout.write('\r' + ' ' * (len(self.message) + 20) + '\r') 
+        if success_msg:
+            sys.stdout.write(f"\033[32m✓\033[0m {success_msg}\n")
+        sys.stdout.flush()
+
+
+# ============================================================================
+# UTILITY: LIVE IBM HARDWARE & ESP CALCULATION
+# ============================================================================
+def fetch_live_ibm_hardware_data(backend_name="ibm_fez", max_physical_qubits=30):
+    try:
+        service = QiskitRuntimeService()
+        backend = service.backend(backend_name)
+    except Exception as e:
+        sys.stdout.write('\r' + ' ' * 80 + '\r') 
+        print(f"\n\033[91m\033[1m[IBM AUTH ERROR] Failed to connect to IBM Quantum Service.\033[0m")
+        print(f"\033[93mDetails: {e}\033[0m")
+        print("\n\033[1mTo fix this, ensure you have saved your IBM token using:")
+        print("    from qiskit_ibm_runtime import QiskitRuntimeService")
+        print("    QiskitRuntimeService.save_account(token=\"YOUR_IBM_API_TOKEN\", overwrite=True)\033[0m\n")
+        sys.exit(1)
+
+    target = backend.target
+    num_phys_qubits = target.num_qubits
+
+    readout_errors_raw = []
+    for q in range(num_phys_qubits):
+        try:
+            err = target['measure'][(q,)].error
+            readout_errors_raw.append(err if err is not None else 0.05)
+        except Exception:
+            readout_errors_raw.append(0.05)
+    
+    start_node = int(np.argmin(readout_errors_raw))
+    raw_cmap = target.build_coupling_map()
+    
+    graph = nx.Graph()
+    graph.add_edges_from(list(raw_cmap.get_edges()))
+    
+    visited = set([start_node])
+    queue = [start_node]
+    
+    while queue and len(visited) < max_physical_qubits:
+        current = queue.pop(0)
+        neighbors = sorted(list(graph.neighbors(current)), key=lambda n: readout_errors_raw[n])
+        for neighbor in neighbors:
+            if neighbor not in visited:
+                visited.add(neighbor)
+                queue.append(neighbor)
+                if len(visited) == max_physical_qubits:
+                    break
+
+    active_nodes = list(visited)
+    node_mapping = {old_idx: new_idx for new_idx, old_idx in enumerate(active_nodes)}
+    
+    sliced_edges = []
+    for u, v in raw_cmap.get_edges():
+        if u in visited and v in visited:
+            sliced_edges.append((node_mapping[u], node_mapping[v]))
+            
+    cmap = CouplingMap(sliced_edges)
+    
+    readout_errors = np.zeros(max_physical_qubits)
+    for old_idx, new_idx in node_mapping.items():
+        try:
+            readout_errors[new_idx] = target['measure'][(old_idx,)].error
+        except Exception:
+            readout_errors[new_idx] = 0.05
+            
+    gate_errors = {}
+    two_q_gate = 'ecr' if 'ecr' in target else ('cx' if 'cx' in target else 'cz')
+    
+    for old_u, old_v in raw_cmap.get_edges():
+            if old_u in visited and old_v in visited:
+                new_u, new_v = node_mapping[old_u], node_mapping[old_v]
+                try:
+                    err = target[two_q_gate][(old_u, old_v)].error
+                    if err is None or err >= 1.0:
+                        gate_errors[(new_u, new_v)] = 0.10
+                    else:
+                        gate_errors[(new_u, new_v)] = err
+                except Exception:
+                    gate_errors[(new_u, new_v)] = 0.10
+
+    # Return the full raw target device data alongside the slice mapping for proper benchmarking
+    return cmap, readout_errors, gate_errors, backend, node_mapping
+
+
+def calculate_esp_global(routed_qc, backend):
+    """Calculates full-chip ESP directly from Qiskit's native target data."""
+    esp = 1.0
+    target = backend.target
+    two_q_gate = 'ecr' if 'ecr' in target else ('cx' if 'cx' in target else 'cz')
+    
+    used_physical_qubits = set()
+    for inst in routed_qc.data:
+        if inst.operation.name not in ['barrier']:
+            for q in inst.qubits:
+                used_physical_qubits.add(routed_qc.find_bit(q).index)
+            
+    for q in used_physical_qubits:
+        try:
+            err = target['measure'][(q,)].error
+            esp *= (1.0 - (err if err is not None else 0.05))
+        except Exception:
+            esp *= 0.95
+        
+    for inst in routed_qc.data:
+        op_name = inst.operation.name
+        if op_name in ['cx', 'swap', 'ecr', 'cz']:
+            q_indices = [routed_qc.find_bit(q).index for q in inst.qubits]
+            if len(q_indices) == 2:
+                u, v = q_indices[0], q_indices[1]
+                try:
+                    err = target[two_q_gate][(u, v)].error
+                    if err is None: err = 0.02
+                except Exception:
+                    err = 0.02
+                esp *= (1.0 - err)**3 if op_name == 'swap' else (1.0 - err)
+                    
+    return esp
+
+
+# ============================================================================
+# 1. CORE GRAPH NEURAL NETWORK
+# ============================================================================
+class QAOAPolicyGNN(torch.nn.Module):
+    def __init__(self, num_node_features, hidden_dim=64):
+        super().__init__()
+        self.conv1 = GATv2Conv(num_node_features, hidden_dim, heads=4, concat=True)
+        self.conv2 = GATv2Conv(hidden_dim * 4, hidden_dim, heads=1, concat=False)
+        self.fc    = torch.nn.Linear(hidden_dim, 1)
+
+    def forward(self, data):
+        x, edge_index = data.x, data.edge_index
+        if hasattr(data, 'batch') and data.batch is not None:
+            batch = data.batch
+        else:
+            batch = torch.zeros(x.size(0), dtype=torch.long, device=x.device)
+            
+        x = F.elu(self.conv1(x, edge_index))
+        x = F.elu(self.conv2(x, edge_index))
+        logits = self.fc(x).squeeze(-1)
+        batch_size = data.num_graphs if hasattr(data, 'num_graphs') and data.num_graphs is not None else 1
+        
+        num_nodes = x.size(0) // batch_size
+        return logits.view(batch_size, num_nodes)
+
+
+# ============================================================================
+# 2. THE REUSABLE COMPILER CLASS
+# ============================================================================
+class NeuralAStarCompiler:
+    HARVEST_VERIFY_SEEDS = [42, 123, 456]
+    FINAL_VERIFY_SEEDS   = [42, 123, 456]
+    FINAL_TOP_BEAMS      = 25
+
+    def __init__(self, num_qubits, logical_edges, cmap, readout_errs, gate_errs, beam_width=50, alpha=0.5):
+        self.num_qubits    = num_qubits 
+        self.logical_edges = logical_edges
+        self.beam_width    = beam_width
+        self.alpha         = alpha
+
+        self.cmap         = cmap
+        self.num_phys     = self.cmap.size() 
+        self.readout_errs = readout_errs
+        self.gate_errs    = gate_errs
+
+        self.dist_matrix = self._build_reliability_matrix()
+        
+        self.hw_graph = nx.Graph(list(self.cmap.get_edges()))
+        self.phys_degrees = np.array([self.hw_graph.degree(i) for i in range(self.num_phys)])
+
+        self.hw_noise_feats = self._get_static_noise_features()
+        
+        hw_edges         = list(self.cmap.get_edges())
+        self.edge_index  = torch.tensor(hw_edges, dtype=torch.long).t().contiguous()
+
+        self.device   = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        self._use_amp = self.device.type == 'cuda'
+
+        raw_model = QAOAPolicyGNN(
+            num_node_features=(3 * num_qubits) + 7
+        ).to(self.device)
+        try:
+            self.model = torch.compile(raw_model)
+        except Exception:
+            self.model = raw_model
+
+        self._adj = {i: [] for i in range(num_qubits)}
+        for u, v in logical_edges:
+            self._adj[u].append(v)
+            self._adj[v].append(u)
+
+        logical_nx = nx.Graph(logical_edges)
+        b_centrality = nx.betweenness_centrality(logical_nx)
+        self.routing_order = [i for i, _ in sorted(b_centrality.items(), key=lambda x: x[1], reverse=True)]
+
+    def _build_reliability_matrix(self):
+        G = nx.Graph()
+        for u, v in self.cmap.get_edges():
+            err = self.gate_errs.get((u, v), 0.02)
+            weight = 1.0 - np.log(1 - err + 1e-10)
+            G.add_edge(u, v, weight=weight)
+        
+        path_lengths = dict(nx.all_pairs_dijkstra_path_length(G))
+        dist = np.zeros((self.num_phys, self.num_phys))
+        for i in range(self.num_phys):
+            for j in range(self.num_phys):
+                dist[i, j] = path_lengths.get(i, {}).get(j, 999.0)
+        return dist
+
+    def _get_static_noise_features(self):
+        feats = np.zeros((self.num_phys, 3))
+        for i in range(self.num_phys):
+            feats[i, 0] = self.readout_errs[i]
+            adj_errs = [self.gate_errs[(i, v)] for v in self.cmap.neighbors(i) if (i, v) in self.gate_errs]
+            feats[i, 1] = np.mean(adj_errs) if adj_errs else 0.02
+            feats[i, 2] = self.phys_degrees[i] / max(self.phys_degrees) if max(self.phys_degrees) > 0 else 0
+        return torch.tensor(feats, dtype=torch.float)
+
+    def _build_circuit(self):
+        qc = QuantumCircuit(self.num_qubits)
+        qc.h(range(self.num_qubits))
+        for i, j in self.logical_edges:
+            qc.cx(i, j)
+            qc.rz(0.5, j)
+            qc.cx(i, j)
+        qc.rx(1.0, range(self.num_qubits))
+        qc.measure_all()
+        return qc
+
+    def _layout_to_pyg_data(self, layout, target_q):
+        total_features = (3 * self.num_qubits) + 1
+        x = torch.zeros((self.num_phys, total_features), dtype=torch.float)
+        phys_to_logical = {phys: log for log, phys in enumerate(layout) if phys != -1}
+        placed_phys = [p for p in layout if p != -1]
+
+        demand = {i: [] for i in range(self.num_qubits)}
+        for u, v in self.logical_edges:
+            demand[u].append(v)
+            demand[v].append(u)
+
+        extra_feats = torch.zeros((self.num_phys, 3))
+
+        for phys_node in range(self.num_phys):
+            if phys_node in phys_to_logical:
+                logical_q = phys_to_logical[phys_node]
+                x[phys_node, logical_q] = 1.0
+                for nb in demand[logical_q]: x[phys_node, self.num_qubits + 1 + nb] = 1.0
+            else:
+                x[phys_node, self.num_qubits] = 1.0
+            x[phys_node, (2 * self.num_qubits) + 1 + target_q] = 1.0
+
+            if placed_phys:
+                extra_feats[phys_node, 0] = np.min(self.dist_matrix[phys_node, placed_phys])
+                neighbor_count = sum(1 for nb in self.hw_graph.neighbors(phys_node) if nb in placed_phys)
+                extra_feats[phys_node, 1] = neighbor_count
+            
+            extra_feats[phys_node, 2] = 1.0 if phys_node not in placed_phys else 0.0
+
+        x_full = torch.cat([x, self.hw_noise_feats, extra_feats], dim=-1)
+        return Data(x=x_full, edge_index=self.edge_index)
+
+    def _harvest_single_expert(self, seed_offset, qc):
+        def calc_esp_local(routed_qc, readout_errs, gate_errs):
+            esp = 1.0
+            used = set()
+            for inst in routed_qc.data:
+                if inst.operation.name not in ['barrier']:
+                    for q in inst.qubits: used.add(routed_qc.find_bit(q).index)
+            for q in used:
+                if q < len(readout_errs): esp *= (1.0 - readout_errs[q])
+            for inst in routed_qc.data:
+                op = inst.operation.name
+                if op in ['cx', 'swap', 'ecr', 'cz']:
+                    q_idx = [routed_qc.find_bit(q).index for q in inst.qubits]
+                    if len(q_idx) == 2:
+                        u, v = q_idx[0], q_idx[1]
+                        err = gate_errs.get((u, v), gate_errs.get((v, u), 0.02))
+                        esp *= (1.0 - err)**3 if op == 'swap' else (1.0 - err)
+            return esp
+
+        pm = generate_preset_pass_manager(optimization_level=3, coupling_map=self.cmap, seed_transpiler=42 + seed_offset)
+        routed_qc = pm.run(qc)
+
+        layout = [-1] * self.num_qubits
+        init_layout = routed_qc.layout.initial_layout
+        for i, vq in enumerate(qc.qubits):
+            layout[i] = init_layout[vq]
+
+        best_swaps = routed_qc.count_ops().get("swap", 0)
+        best_esp = calc_esp_local(routed_qc, self.readout_errs, self.gate_errs)
+        
+        qiskit_layout = Layout({qc.qubits[i]: int(layout[i]) for i in range(len(layout))})
+        for vseed in self.HARVEST_VERIFY_SEEDS:
+            pm_v = generate_preset_pass_manager(optimization_level=3, coupling_map=self.cmap, initial_layout=qiskit_layout, seed_transpiler=vseed)
+            routed_v = pm_v.run(qc)
+            s = routed_v.count_ops().get("swap", 0)
+            e = calc_esp_local(routed_v, self.readout_errs, self.gate_errs)
+            
+            if s < best_swaps or (s == best_swaps and e > best_esp):
+                best_swaps = s
+                best_esp = e
+
+        return layout, best_swaps, best_esp
+
+    def train(self, num_samples, epochs=40, batch_size=64, spinner=None):
+        qc = self._build_circuit()
+
+        results = Parallel(n_jobs=-1)(delayed(self._harvest_single_expert)(i, qc) for i in range(num_samples))
+        results.sort(key=lambda x: (x[1], -x[2]))
+
+        keep_count    = max(10, int(num_samples * 0.25))
+        expert_layouts = [res[0] for res in results[:keep_count]]
+
+        pyg_data_list = []
+        for expert_layout in expert_layouts:
+            partial = [-1] * self.num_qubits
+            for q in self.routing_order:
+                target_node = expert_layout[q]
+                data   = self._layout_to_pyg_data(partial, q)
+                data.y = torch.tensor([target_node], dtype=torch.long)
+                pyg_data_list.append(data)
+                partial[q] = target_node
+
+        pin    = self._use_amp
+        loader = DataLoader(
+            pyg_data_list, batch_size=batch_size, shuffle=True,
+            num_workers=4, pin_memory=pin, persistent_workers=True
+        )
+        optimizer = torch.optim.Adam(self.model.parameters(), lr=0.005)
+        criterion = torch.nn.CrossEntropyLoss()
+        scaler    = torch.cuda.amp.GradScaler(enabled=self._use_amp)
+
+        self.model.train()
+        for epoch in range(epochs):
+            epoch_loss = 0.0
+            batches = 0
+            for data in loader:
+                data = data.to(self.device, non_blocking=True)
+                optimizer.zero_grad(set_to_none=True)
+                with torch.autocast(device_type=self.device.type, enabled=self._use_amp):
+                    logits = self.model(data)
+                    loss   = criterion(logits, data.y)
+                scaler.scale(loss).backward()
+                scaler.step(optimizer)
+                scaler.update()
+                
+                epoch_loss += loss.item()
+                batches += 1
+            
+            if spinner:
+                avg_loss = epoch_loss / max(1, batches)
+                spinner.message = f"Harvesting layouts & training GNN... [\033[93mEpoch {epoch+1}/{epochs}\033[0m | Loss: \033[35m{avg_loss:.4f}\033[0m]"
+
+    def _local_search_refine(self, qc_base, initial_layout, iterations=200):
+        best_layout = list(initial_layout)
+        
+        def get_metrics(l):
+            q_map = Layout({qc_base.qubits[i]: int(l[i]) for i in range(len(l))})
+            pm = generate_preset_pass_manager(optimization_level=3, coupling_map=self.cmap, initial_layout=q_map, seed_transpiler=42)
+            routed = pm.run(qc_base)
+            s = routed.count_ops().get("swap", 0)
+            
+            # Simple local tracking
+            esp = 1.0
+            used = set()
+            for inst in routed.data:
+                if inst.operation.name not in ['barrier']:
+                    for q in inst.qubits: used.add(routed.find_bit(q).index)
+            for q in used:
+                if q < len(self.readout_errs): esp *= (1.0 - self.readout_errs[q])
+            return s, esp
+
+        current_swaps, current_esp = get_metrics(best_layout)
+        
+        for _ in range(iterations):
+            test_layout = list(best_layout)
+            idx1, idx2 = random.sample(range(self.num_qubits), 2)
+            test_layout[idx1], test_layout[idx2] = test_layout[idx2], test_layout[idx1]
+            
+            new_swaps, new_esp = get_metrics(test_layout)
+            
+            if new_swaps < current_swaps or (new_swaps == current_swaps and new_esp > current_esp):
+                current_swaps = new_swaps
+                current_esp = new_esp
+                best_layout = test_layout
+                
+        return best_layout
+
+    def route(self):
+        self.model.eval()
+        dist_matrix = self.dist_matrix
+        adj         = self._adj
+
+        beams = [(0.0, [-1] * self.num_qubits, list(range(self.num_phys)))]
+
+        for current_q in self.routing_order:
+            batch_graphs = []
+            batch_meta   = []
+
+            for score, current_layout, current_avail in beams:
+                batch_graphs.append(self._layout_to_pyg_data(current_layout, current_q))
+                batch_meta.append((score, current_layout, current_avail))
+
+            if not batch_graphs: break
+
+            search_loader = DataLoader(batch_graphs, batch_size=len(batch_graphs), shuffle=False, pin_memory=self._use_amp)
+            next_beams = []
+
+            with torch.no_grad():
+                for batch_data in search_loader:
+                    batch_data = batch_data.to(self.device, non_blocking=True)
+                    with torch.autocast(device_type=self.device.type, enabled=self._use_amp):
+                        logits = self.model(batch_data)
+                    log_probs = F.log_softmax(logits, dim=-1).cpu().numpy()
+
+                    neighbors_of_q = adj[current_q]
+
+                    for b_i, (base_score, current_layout, current_avail) in enumerate(batch_meta):
+                        lp_row    = log_probs[b_i]
+                        avail_arr = np.array(current_avail, dtype=np.int32)
+
+                        if neighbors_of_q:
+                            placed = [current_layout[nb] for nb in neighbors_of_q if current_layout[nb] != -1]
+                            avg_dist = dist_matrix[np.ix_(avail_arr, placed)].min(axis=1) if placed else np.zeros(len(avail_arr))
+                        else:
+                            avg_dist = np.zeros(len(avail_arr))
+
+                        scores     = base_score + lp_row[avail_arr] - (self.alpha * avg_dist)
+                        layout_arr = np.array(current_layout, dtype=np.int32)
+
+                        for k, test_node in enumerate(avail_arr):
+                            new_layout        = layout_arr.copy()
+                            new_layout[current_q] = test_node
+                            new_avail = [n for n in current_avail if n != int(test_node)]
+                            next_beams.append((float(scores[k]), new_layout.tolist(), new_avail))
+
+            next_beams.sort(key=lambda x: x[0], reverse=True)
+            beams = next_beams[:self.beam_width]
+
+        return [b[1] for b in beams]
+
+
+# ============================================================================
+# MAIN ENTRY POINT FOR PACKAGE (UNFILTERED DEVICE-WIDE COMPETITION)
+# ============================================================================
+def generate_optimized_layout(num_qubits, logical_edges, backend_name="ibm_fez", train_samples=2500):
+    print("\n\033[1m\033[94m>>> ALPHAZERO NEURAL QUANTUM COMPILER <<<\033[0m")
+    
+    # 1. Fetch Data
+    spin_hw = TerminalSpinner(f"Connecting to \033[33m{backend_name}\033[0m to extract high-fidelity topology...")
+    spin_hw.start()
+    cmap, readout, gate, backend, node_mapping = fetch_live_ibm_hardware_data(backend_name, max_physical_qubits=30)
+    spin_hw.stop(f"Extracted 30-qubit training slice from {backend_name}.")
+    
+    compiler = NeuralAStarCompiler(num_qubits, logical_edges, cmap, readout, gate)
+    qc_base = compiler._build_circuit()
+    
+    # 2. Train GNN
+    spin_train = TerminalSpinner("Harvesting layout experts and training GNN...")
+    spin_train.start()
+    compiler.train(num_samples=train_samples, spinner=spin_train)
+    spin_train.stop("GNN model trained successfully.")
+    
+    # 3. Route A*
+    spin_route = TerminalSpinner("Navigating hardware topology via A* Beam Search...")
+    spin_route.start()
+    predicted_layouts = compiler.route()
+    spin_route.stop("Top predicted paths generated.")
+    
+    # 4. Local Search
+    spin_ls = TerminalSpinner("Refining top layout via local hill-climbing search...")
+    spin_ls.start()
+    best_raw_layout = compiler._local_search_refine(qc_base, predicted_layouts[0])
+    spin_ls.stop("Refinement complete. Final layout finalized.")
+    
+    # Create the inverse mapping to transform 0..29 internal indices back to full hardware IDs
+    inverse_mapping = {new_idx: old_idx for old_idx, new_idx in node_mapping.items()}
+    
+    # Generate the global physical hardware layout mapping
+    global_layout = Layout({
+        qc_base.qubits[i]: int(inverse_mapping[best_raw_layout[i]]) 
+        for i in range(num_qubits)
+    })
+    
+    # ========================================================================
+    # UNFILTERED GLOBAL DEVICE BENCHMARK REPORT
+    # ========================================================================
+    print("\n\033[1m\033[96m============================================================\033[0m")
+    print("\033[1m\033[96m        UNFILTERED DEVICE-WIDE COMPILATION BENCHMARK        \033[0m")
+    print("\033[1m\033[96m============================================================\033[0m")
+    
+    # Baseline: Run against the UNRESTRICTED full chip target map
+    pm_baseline = generate_preset_pass_manager(optimization_level=3, backend=backend, seed_transpiler=42)
+    routed_baseline = pm_baseline.run(qc_base)
+    base_swaps = routed_baseline.count_ops().get("swap", 0)
+    base_esp = calculate_esp_global(routed_baseline, backend)
+    
+    # AI Performance: Injected global layout layout applied to the full chip target map
+    pm_ai = generate_preset_pass_manager(optimization_level=3, backend=backend, initial_layout=global_layout, seed_transpiler=42)
+    routed_ai = pm_ai.run(qc_base)
+    ai_swaps = routed_ai.count_ops().get("swap", 0)
+    ai_esp = calculate_esp_global(routed_ai, backend)
+    
+    # Metrics Printout
+    print(f" Target Hardware System     : {backend.name} ({backend.target.num_qubits} Total Qubits)")
+    print(f" AI Training Constraint     : Optimized inside best local 30-qubit slice")
+    print(f" Qiskit Search Constraint   : \033[91mNone\033[0m (Allowed to scan full {backend.target.num_qubits}-qubit graph)")
+    print("------------------------------------------------------------")
+    
+    # Formatting Swaps Improvement Comparison
+    if ai_swaps < base_swaps:
+        swap_color = "\033[92m" # Green if AI won
+        status = f"[✓ Saved {base_swaps - ai_swaps} SWAPs]"
+    elif ai_swaps == base_swaps:
+        swap_color = "\033[93m" # Yellow if tied
+        status = "[Tied Standard Level 3]"
+    else:
+        swap_color = "\033[91m" # Red if Qiskit won standard
+        status = "[Standard Full-Graph Pick Preferred]"
+        
+    print(f" Standard Qiskit Level 3    : {base_swaps} SWAP gates | ESP: {base_esp*100:.2f}%")
+    print(f" {swap_color}AlphaZero + A* Seeded       : {ai_swaps} SWAP gates | ESP: {ai_esp*100:.2f}%  {status}\033[0m")
+    print("\033[1m\033[96m============================================================\033[0m\n")
+    
+    return global_layout

qcompile-0.1.0.dist-info/METADATA

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: qcompile
+Version: 0.1.0
+Summary: AI-guided hardware-aware quantum circuit layout optimization for Qiskit
+Author-email: Shagun Tembhurne <shaxtembhurne@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/shaxtembhurne/qcompile
+Project-URL: Repository, https://github.com/shaxtembhurne/qcompile
+Project-URL: Issues, https://github.com/shaxtembhurne/qcompile/issues
+Keywords: quantum-computing,qiskit,compiler,transpiler,layout,optimization,graph-neural-network,machine-learning
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.24
+Requires-Dist: networkx>=3.0
+Requires-Dist: joblib>=1.3
+Requires-Dist: qiskit>=1.0
+Requires-Dist: qiskit-ibm-runtime>=0.20
+Requires-Dist: torch>=2.0
+Requires-Dist: torch-geometric>=2.3

qcompile-0.1.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+qcompile/__init__.py,sha256=rlvc-7CMRY9jIlgpOoSV4S0Lyw-A7ZUDV9ygj_MWaAE,25451
+qcompile-0.1.0.dist-info/METADATA,sha256=yYR9pFS5iIZ3Sgq68y1fDwFCjosswNtV6-aQevwrJFI,1295
+qcompile-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+qcompile-0.1.0.dist-info/top_level.txt,sha256=2PT05p070QuWjJas4bUWIKUPUk4UYUdkXA6zx3-MeGQ,9
+qcompile-0.1.0.dist-info/RECORD,,

qcompile-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

qcompile-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+qcompile