QWnet 2.0.0__py3-none-any.whl

QWnet/__init__.py

@@ -0,0 +1,73 @@
+from .lattice import LatticeQuantumWalk
+from .graphs import run_chawla_ranking, run_szegedy_service, run_community_detection, run_quantum_pagerank, run_hadamard
+
+def run_simulation(model: str, **kwargs):
+    """
+    Unified entry point for Quantum Walk simulations.
+    
+    Args:
+        model (str): The type of simulation to run.
+                     Options: '1d', '2d', '3d' (Lattice Walks)
+                              'ChawlaQW' (Chawla Directed Ranking)
+                              'QPageRank' (Quantum PageRank)
+                              'HadamardQW' (Hadamard Edge Importance)
+                              'SzegedyQW' (Szegedy Walk)
+                              'community' (Community Detection)
+                              'directSumQW' (Direct Sum Quantum Walk)
+        **kwargs: Parameters specific to the chosen model.
+    """
+    # 处理模型名称（不区分大小写）
+    model_upper = model
+    
+    # Lattice Walks
+    if model_upper in ['1d', '2d', '3d']:
+        dim_map = {'1d': 1, '2d': 2, '3d': 3}
+        dimension = dim_map[model_upper]
+        network_size = kwargs.get('network_size', 100 if dimension==1 else 20 if dimension==2 else 25)
+        steps = kwargs.get('steps', 100)
+        initial_dist = kwargs.get('initial_dist', 'uniform')
+        compare_classical = kwargs.get('compare_classical', False)
+        if dimension in [1, 2] and 'compare_classical' not in kwargs: compare_classical = True
+        
+        qw = LatticeQuantumWalk(dimension=dimension, network_size=network_size)
+        qw.run(steps=steps, initial_dist=initial_dist, compare_classical=compare_classical)
+        qw.visualize()
+        return qw.results
+
+    # Graph Walks
+    elif model_upper == 'ChawlaQW':
+        return run_chawla_ranking(file_path=kwargs.get('file_path'), 
+                                  steps=kwargs.get('steps', 100), 
+                                  coin_type=kwargs.get('coin_type', 'fourier'))
+    
+    elif model_upper == 'SzegedyQW':
+        return run_szegedy_service(G=kwargs.get('G'),
+                                   steps=kwargs.get('steps', 10),
+                                   initial_type=kwargs.get('initial_type', 'uniform'),
+                                   initial_node=kwargs.get('initial_node'))
+
+    elif model_upper == 'community':
+        return run_community_detection(G=kwargs.get('G'),
+                                       initial_state=kwargs.get('initial_state', 'uniform'),
+                                       coin_type=kwargs.get('coin_type', 'fourier'))
+
+    elif model_upper == 'QPageRank':
+        return run_quantum_pagerank(file_path=kwargs.get('file_path'),
+                                    steps=kwargs.get('steps', 20),
+                                    alpha=kwargs.get('alpha', 0.85),
+                                    initial_type=kwargs.get('initial_type', 'uniform'))
+                                    
+    elif model_upper == 'HadamardQW':
+        return run_hadamard(steps=kwargs.get('steps', 100),
+                            top_p=kwargs.get('top_p', 0.05))
+    
+    elif model_upper == 'directSumQW':
+        # 暂时使用 run_chawla_ranking 作为 directSumQW 的实现
+        # 后续可以根据需要添加专门的实现
+        return run_chawla_ranking(file_path=kwargs.get('file_path'), 
+                                  steps=kwargs.get('steps', 100), 
+                                  coin_type=kwargs.get('coin_type', 'fourier'))
+    
+    else:
+        available_models = ['1d', '2d', '3d', 'ChawlaQW', 'QPageRank', 'HadamardQW', 'SzegedyQW', 'community', 'directSumQW']
+        raise ValueError(f"Unknown model type: {model}. Available: {', '.join(available_models)}")

QWnet/graphs.py

@@ -0,0 +1,330 @@
+import numpy as np
+import networkx as nx
+import matplotlib.pyplot as plt
+from matplotlib.colors import Normalize
+from matplotlib.cm import ScalarMappable
+import os
+
+def run_chawla_ranking(file_path=None, steps=100, coin_type='fourier'):
+    """
+    Discrete-time quantum walk algorithm for ranking nodes on a network
+    Chawla, P ; Mangal, R  ; Chandrashekar, CM
+    QUANTUM INFORMATION PROCESSING
+    19(5): 158, 2020.
+    """
+    if file_path and os.path.exists(file_path):
+        G = nx.read_edgelist(file_path, create_using=nx.DiGraph())
+    else:
+        G = nx.gnp_random_graph(15, 0.2, directed=True, seed=42)
+
+    nodes = list(G.nodes())
+    N = len(nodes)
+    mapping = {node: i for i, node in enumerate(nodes)}
+    edges = list(G.edges())
+    M = len(edges)
+
+    if M == 0: raise ValueError("Graph must have edges.")
+
+    idx_map = {edge: i for i, edge in enumerate(edges)}
+    U = np.zeros((M, M), dtype=np.complex128)
+
+    for v in nodes:
+        in_edges = [e for e in edges if e[1] == v]
+        out_edges = [e for e in edges if e[0] == v]
+        d_in = len(in_edges); d_out = len(out_edges)
+
+        if d_in > 0 and d_out > 0:
+            if coin_type == 'fourier':
+                for k in range(d_out):
+                    for l in range(d_in):
+                        phase = np.exp(2j * np.pi * k * l / max(d_in, d_out))
+                        U[idx_map[out_edges[k]], idx_map[in_edges[l]]] = phase / np.sqrt(d_in)
+            else:
+                for k in range(d_out):
+                    for l in range(d_in):
+                        U[idx_map[out_edges[k]], idx_map[in_edges[l]]] = np.sqrt(1.0 / d_in)
+
+    state = np.ones(M, dtype=np.complex128) / np.sqrt(M)
+    prob_accumulator = np.zeros(M)
+    curr_state = state
+
+    for t in range(steps):
+        curr_state = np.dot(U, curr_state)
+        norm = np.linalg.norm(curr_state)
+        if norm > 0: curr_state /= norm
+        prob_accumulator += np.abs(curr_state) ** 2
+
+    node_ranks = np.zeros(N)
+    for i, (u, v) in enumerate(edges):
+        node_ranks[mapping[v]] += prob_accumulator[i] / steps
+
+    pos = nx.kamada_kawai_layout(G)
+    fig, ax = plt.subplots(figsize=(6, 4))
+    cmap = plt.cm.YlOrRd
+    norm = Normalize(vmin=node_ranks.min(), vmax=node_ranks.max())
+
+    nx.draw_networkx_edges(G, pos, ax=ax, edge_color='#dddddd', alpha=0.7, arrowsize=12, connectionstyle='arc3,rad=0.1')
+    nx.draw_networkx_nodes(G, pos, ax=ax, node_size=220, node_color=node_ranks, cmap=cmap, edgecolors='#444444', linewidths=0.8)
+
+    for i, node in enumerate(nodes):
+        score = node_ranks[i]
+        rgb = cmap(norm(score))[:3]
+        brightness = 0.299 * rgb[0] + 0.587 * rgb[1] + 0.114 * rgb[2]
+        t_color = 'white' if brightness < 0.45 else 'black'
+        ax.text(pos[node][0], pos[node][1], s=str(node), color=t_color, fontsize=8, ha='center', va='center', fontweight='bold')
+
+    sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm)
+    cb = plt.colorbar(sm, ax=ax, fraction=0.046, pad=0.04)
+    cb.outline.set_visible(False)
+    cb.ax.tick_params(labelsize=8)
+    ax.axis('off')
+    plt.tight_layout()
+    plt.show()
+    return node_ranks
+
+def run_szegedy_service(G=None, steps=10, initial_type='uniform', initial_node=None):
+    """
+    Quantum speed-up of Markov chain based algorithms
+    Szegedy M
+    Proceedings of the 45th Annual IEEE Symposium on Foundations of Computer Science
+    2004: 32–41.
+    """
+    if G is None: G = nx.karate_club_graph()
+    nodes = list(G.nodes())
+    N = len(nodes)
+    mapping = {node: i for i, node in enumerate(nodes)}
+    A = nx.to_numpy_array(G, nodelist=nodes)
+    degrees = np.sum(A, axis=0)
+    degrees[degrees == 0] = 1
+    P = A / degrees
+
+    psi = np.zeros((N * N, N), dtype=np.complex128)
+    for i in range(N):
+        vec_psi_i = np.zeros((N, N), dtype=np.complex128)
+        vec_psi_i[:, i] = np.sqrt(P[:, i])
+        psi[:, i] = vec_psi_i.flatten()
+
+    S = 2 * np.dot(psi, psi.conj().T) - np.eye(N * N)
+    SWAP = np.zeros((N * N, N * N))
+    for i in range(N):
+        for j in range(N): SWAP[i * N + j, j * N + i] = 1
+    U = np.dot(SWAP, S)
+
+    if initial_type == 'node' and initial_node in mapping:
+        idx = mapping[initial_node]
+        init_matrix = np.zeros((N, N), dtype=np.complex128)
+        init_matrix[:, idx] = np.sqrt(P[:, idx])
+        state_vec = init_matrix.flatten()
+    else:
+        state_vec = np.sum(psi, axis=1) / np.sqrt(N)
+
+    for _ in range(steps):
+        state_vec = np.dot(U, state_vec)
+
+    node_probs = np.sum(np.abs(state_vec.reshape((N, N))) ** 2, axis=1)
+    node_probs /= np.sum(node_probs)
+
+    pos = nx.spring_layout(G, seed=42)
+    fig, ax = plt.subplots(figsize=(6, 4))
+    cmap = plt.cm.YlGnBu
+    norm = Normalize(vmin=node_probs.min(), vmax=node_probs.max())
+    nx.draw_networkx_edges(G, pos, ax=ax, edge_color='#bbbbbb', width=1.0)
+    nx.draw_networkx_nodes(G, pos, ax=ax, node_size=180, node_color=node_probs, cmap=cmap, edgecolors='#444444', linewidths=1.0)
+
+    for node in nodes:
+        prob = node_probs[mapping[node]]
+        rgb = cmap(norm(prob))[:3]
+        brightness = 0.299 * rgb[0] + 0.587 * rgb[1] + 0.114 * rgb[2]
+        t_color = 'white' if brightness < 0.38 else 'black'
+        ax.text(pos[node][0], pos[node][1], s=str(node), color=t_color, fontsize=9, ha='center', va='center')
+
+    sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm)
+    sm.set_array([])
+    plt.colorbar(sm, ax=ax, fraction=0.046, pad=0.04).outline.set_visible(False)
+    ax.axis('off')
+    plt.tight_layout()
+    plt.show()
+    return node_probs
+
+def run_community_detection(G=None, initial_state='uniform', coin_type='fourier'):
+    """
+    Discrete-time quantum walk on complex networks for community detection
+    Kanae Mukai and Naomichi Hatano
+    Phys. Rev. Research 2, 023378 (2020)
+    """
+    if G is None: G = nx.karate_club_graph()
+    nodes = list(G.nodes())
+    N = len(nodes)
+    mapping = {node: i for i, node in enumerate(nodes)}
+    edges = list(G.edges())
+
+    dir_edges = []
+    for u, v in edges:
+        dir_edges.append((u, v)); dir_edges.append((v, u))
+    idx_map = {edge: i for i, edge in enumerate(dir_edges)}
+    dim = len(dir_edges)
+
+    C = np.zeros((dim, dim), dtype=np.complex128)
+    for j in nodes:
+        neighbors = list(G.neighbors(j))
+        d_j = len(neighbors)
+        if d_j == 0: continue
+        
+        if coin_type.lower() == 'fourier':
+            coin_matrix = np.exp(2j * np.pi * np.outer(np.arange(d_j), np.arange(d_j)) / d_j) / np.sqrt(d_j)
+        elif coin_type.lower() == 'grover':
+            coin_matrix = np.full((d_j, d_j), 2.0 / d_j) - np.eye(d_j)
+        else: raise ValueError("Unsupported coin_type")
+
+        for k in range(d_j):
+            for l in range(d_j):
+                row = idx_map[(j, neighbors[k])]
+                col = idx_map[(neighbors[l], j)]
+                C[row, col] = coin_matrix[k, l]
+
+    S = np.zeros((dim, dim))
+    for i, j in dir_edges:
+        S[idx_map[(j, i)], idx_map[(i, j)]] = 1
+    U = S @ C
+
+    if initial_state == 'uniform':
+        phi_0 = np.ones(dim, dtype=np.complex128) / np.sqrt(dim)
+    else:
+        phi_0 = np.zeros(dim, dtype=np.complex128)
+        # Note: 'initial_state' when not uniform implies an index or node logic, keeping simple here
+        # Assuming initial_state passed is a valid node index if it's an integer
+        if isinstance(initial_state, int) and 0 <= initial_state < N:
+             seed_neighbors = list(G.neighbors(nodes[initial_state]))
+             for nb in seed_neighbors:
+                 phi_0[idx_map[(nodes[initial_state], nb)]] = 1.0 / np.sqrt(len(seed_neighbors))
+
+    vals, vecs = np.linalg.eig(U)
+    unique_vals, inverse_indices = np.unique(np.round(vals, 10), return_inverse=True)
+    inf_probs = np.zeros(dim)
+
+    for i in range(len(unique_vals)):
+        indices = np.where(inverse_indices == i)[0]
+        subspace_vecs = vecs[:, indices]
+        proj = subspace_vecs @ (np.conj(subspace_vecs.T) @ phi_0)
+        inf_probs += np.abs(proj) ** 2
+
+    node_scores = np.zeros(N)
+    for i, (u, v) in enumerate(dir_edges):
+        node_scores[mapping[v]] += np.real(inf_probs[i])
+
+    return dict(zip(nodes, node_scores))
+
+def run_quantum_pagerank(file_path=None, steps=20, alpha=0.85, initial_type='uniform'):
+    """
+    Quantum Google in a Complex Network (Paparo et al.)
+    """
+    if file_path and os.path.exists(file_path):
+        G = nx.read_edgelist(file_path, create_using=nx.Graph())
+    else:
+        G = nx.karate_club_graph()
+
+    nodes = list(G.nodes())
+    N = len(nodes)
+    mapping = {node: i for i, node in enumerate(nodes)}
+    A = nx.to_numpy_array(G, nodelist=nodes)
+    degrees = np.sum(A, axis=1)
+
+    P_classic = np.zeros((N, N))
+    for i in range(N):
+        if degrees[i] > 0: P_classic[:, i] = A[i, :] / degrees[i]
+        else: P_classic[:, i] = 1.0 / N
+    P = alpha * P_classic + (1 - alpha) / N * np.ones((N, N))
+
+    psi = np.zeros((N * N, N), dtype=np.complex128)
+    for j in range(N):
+        column_j = np.zeros((N, N), dtype=np.complex128)
+        column_j[:, j] = np.sqrt(P[:, j])
+        psi[:, j] = column_j.flatten()
+
+    S = 2 * np.dot(psi, psi.conj().T) - np.eye(N * N)
+    SWAP = np.zeros((N * N, N * N))
+    for i in range(N):
+        for j in range(N): SWAP[i * N + j, j * N + i] = 1
+    U = np.dot(SWAP, S)
+
+    state = np.sum(psi, axis=1) / np.sqrt(N) if initial_type == 'uniform' else psi[:, 0]
+    prob_accumulator = np.zeros(N)
+    curr_state = state
+
+    for t in range(1, steps + 1):
+        curr_state = np.dot(U, curr_state)
+        probs = np.sum(np.abs(curr_state.reshape((N, N))) ** 2, axis=1)
+        prob_accumulator += probs
+    q_pagerank_scores = prob_accumulator / steps
+
+    pos = nx.spring_layout(G, seed=42)
+    fig, ax = plt.subplots(figsize=(6, 4))
+    cmap = plt.cm.YlGnBu
+    norm = Normalize(vmin=q_pagerank_scores.min(), vmax=q_pagerank_scores.max())
+    nx.draw_networkx_edges(G, pos, ax=ax, edge_color='#bbbbbb', alpha=0.4, arrows=False)
+    nx.draw_networkx_nodes(G, pos, ax=ax, node_size=180, node_color=q_pagerank_scores, cmap=cmap, edgecolors='#444444', linewidths=0.8)
+
+    for node in nodes:
+        score = q_pagerank_scores[mapping[node]]
+        rgb = cmap(norm(score))[:3]
+        brightness = 0.299 * rgb[0] + 0.587 * rgb[1] + 0.114 * rgb[2]
+        t_color = 'white' if brightness < 0.38 else 'black'
+        ax.text(pos[node][0], pos[node][1], s=str(node), color=t_color, fontsize=8, ha='center', va='center')
+
+    plt.colorbar(plt.cm.ScalarMappable(cmap=cmap, norm=norm), ax=ax, fraction=0.046, pad=0.04)
+    ax.axis('off')
+    plt.tight_layout()
+    plt.show()
+    return q_pagerank_scores
+
+def run_hadamard(steps=100, top_p=0.05):
+    """
+    A Hadamard walk model and its application in identification of important edges in complex networks
+    Liang et al.
+    """
+    G = nx.karate_club_graph()
+    nodes, edges = list(G.nodes()), list(G.edges())
+    N, M = len(nodes), len(edges)
+
+    directed_edges = []
+    for u, v in edges: directed_edges.extend([(u, v), (v, u)])
+    dim = len(directed_edges)
+    idx_map = {edge: i for i, edge in enumerate(directed_edges)}
+
+    H = np.array([[1, 1], [1, -1]]) / np.sqrt(2)
+    C = np.zeros((dim, dim))
+    for i in range(0, dim, 2): C[i:i + 2, i:i + 2] = H
+    S = np.zeros((dim, dim))
+    for u, v in directed_edges: S[idx_map[(v, u)], idx_map[(u, v)]] = 1
+    U = S @ C
+
+    psi = np.ones(dim, dtype=np.complex128) / np.sqrt(dim)
+    node_probs_accum = np.zeros(N)
+    for _ in range(steps):
+        psi = U @ psi
+        curr_p = np.abs(psi) ** 2
+        for i, (u, v) in enumerate(directed_edges):
+            node_probs_accum[nodes.index(v)] += curr_p[i]
+    node_avg_p = node_probs_accum / steps
+
+    edge_scores = np.array([node_avg_p[nodes.index(u)] + node_avg_p[nodes.index(v)] for u, v in edges])
+    num_top = max(1, int(M * top_p))
+    top_indices = np.argsort(edge_scores)[-num_top:]
+    top_edges = [edges[i] for i in top_indices]
+    top_scores = edge_scores[top_indices]
+
+    pos = nx.spring_layout(G, seed=42)
+    fig, ax = plt.subplots(figsize=(10, 7))
+    target_cmap = plt.cm.plasma
+    norm = Normalize(vmin=top_scores.min(), vmax=top_scores.max())
+
+    nx.draw_networkx_nodes(G, pos, ax=ax, node_size=250, node_color='green', edgecolors='white', linewidths=0.6)
+    nx.draw_networkx_edges(G, pos, ax=ax, edgelist=edges, edge_color='#444444', width=0.8, alpha=0.3, arrows=False)
+    nx.draw_networkx_edges(G, pos, ax=ax, edgelist=top_edges, edge_color=top_scores, edge_cmap=target_cmap,
+                           edge_vmin=top_scores.min(), edge_vmax=top_scores.max(), width=2.5, alpha=1.0, arrows=False)
+    nx.draw_networkx_labels(G, pos, font_size=8, font_color='white', font_weight='bold')
+    ax.set_title(f"Hadamard Walk: Top {num_top}", fontsize=12)
+    ax.axis('off')
+    plt.tight_layout()
+    plt.show()
+    return edge_scores

QWnet/lattice.py

@@ -0,0 +1,195 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.colors import LogNorm
+
+class LatticeQuantumWalk:
+    """
+    Unified class for 1D, 2D, and 3D Quantum Walk Simulations on regular lattices.
+    """
+    def __init__(self, dimension: int, network_size: int = 100):
+        if dimension not in [1, 2, 3]:
+            raise ValueError("Dimension must be 1, 2, or 3.")
+        
+        self.dimension = dimension
+        self.N = network_size
+        self.LSIZE = 2 * self.N + 1
+        self.results = None
+        self.meta = {}
+
+    def run(self, steps: int = 100, initial_dist: str = 'uniform', compare_classical: bool = False) -> dict:
+        self.meta = {
+            "steps": steps,
+            "initial_dist": initial_dist,
+            "compare_classical": compare_classical,
+            "network_size": self.N
+        }
+        
+        if self.dimension == 1:
+            self.results = self._run_1d(steps, initial_dist, compare_classical)
+        elif self.dimension == 2:
+            self.results = self._run_2d(steps, initial_dist, compare_classical)
+        elif self.dimension == 3:
+            self.results = self._run_3d(steps, initial_dist)
+        
+        return self.results
+
+    def _run_1d(self, steps, initial_dist, compare_classical):
+        N = self.N
+        LSIZE = self.LSIZE
+        COINS = 1
+        TOTAL_DIM = LSIZE * COINS * 2
+        
+        TOSS = np.zeros(shape=(TOTAL_DIM, TOTAL_DIM), dtype=complex)
+        STEP = np.zeros(shape=(TOTAL_DIM, TOTAL_DIM), dtype=complex)
+        
+        for row in range(TOTAL_DIM):
+            for col in range(TOTAL_DIM):
+                if (row == col) and (row < LSIZE):     TOSS[row, col] = 1/np.sqrt(2)
+                elif (row == col) and (row >= LSIZE):  TOSS[row, col] = -1/np.sqrt(2)
+                elif (row == col + LSIZE):             TOSS[row, col] = 1/np.sqrt(2)
+                elif (col == row + LSIZE):             TOSS[row, col] = 1/np.sqrt(2)
+                
+                if (row == col + 1) and (row < LSIZE):   STEP[row, col] = 1
+                elif (col == row + 1) and (row >= LSIZE): STEP[row, col] = 1
+        
+        state0 = np.zeros(shape=(TOTAL_DIM, 1), dtype=complex)
+        def get_indices(lattice_x):
+            base_idx = int(lattice_x + N)
+            return [base_idx, base_idx + LSIZE]
+        center_indices = get_indices(0)
+        
+        if initial_dist == 'uniform':
+            state0[center_indices[0]] = 1/np.sqrt(2)
+            state0[center_indices[1]] = (0+1j)/np.sqrt(2)
+        elif initial_dist == 'biased':
+            state0[center_indices[0]] = 1.0
+        
+        current_state = state0
+        for t in range(steps):
+            current_state = np.dot(TOSS, current_state)
+            current_state = np.dot(STEP, current_state)
+
+        lattice_grid = np.arange(-N, N + 1)
+        quantum_probs = np.zeros(LSIZE)
+        for i, x in enumerate(lattice_grid):
+            locs = get_indices(x)
+            quantum_probs[i] = (np.abs(current_state[locs[0]])**2 + np.abs(current_state[locs[1]])**2).item()
+
+        classical_probs = None
+        if compare_classical:
+            walkers = 5000
+            positions = np.zeros(walkers)
+            for _ in range(steps):
+                positions += np.random.choice([-1, 1], size=walkers)
+            c_counts, _ = np.histogram(positions, bins=np.arange(-N, N + 2) - 0.5, density=True)
+            classical_probs = c_counts
+
+        return {"type": "1D", "grid": lattice_grid, "quantum_probs": quantum_probs, "classical_probs": classical_probs}
+
+    def _run_2d(self, steps, initial_dist, compare_classical):
+        N = self.N
+        LSIZE = self.LSIZE
+        state = np.zeros((2, 2, LSIZE, LSIZE), dtype=complex)
+        if initial_dist == 'uniform':
+            state[0, 0, N, N], state[0, 1, N, N] = 0.5, 0.5j
+            state[1, 0, N, N], state[1, 1, N, N] = -0.5j, 0.5
+        else:
+            state[0, 0, N, N] = 1.0
+
+        for _ in range(steps):
+            s = state
+            new_s = np.empty_like(s)
+            new_s[0, 0] = 0.5 * (s[0, 0] + s[0, 1] + s[1, 0] + s[1, 1])
+            new_s[0, 1] = 0.5 * (s[0, 0] - s[0, 1] + s[1, 0] - s[1, 1])
+            new_s[1, 0] = 0.5 * (s[0, 0] + s[0, 1] - s[1, 0] - s[1, 1])
+            new_s[1, 1] = 0.5 * (s[0, 0] - s[0, 1] - s[1, 0] + s[1, 1])
+            state[0, 0] = np.roll(new_s[0, 0], shift=(1, 1), axis=(0, 1))
+            state[0, 1] = np.roll(new_s[0, 1], shift=(1, -1), axis=(0, 1))
+            state[1, 0] = np.roll(new_s[1, 0], shift=(-1, 1), axis=(0, 1))
+            state[1, 1] = np.roll(new_s[1, 1], shift=(-1, -1), axis=(0, 1))
+
+        q_probs = np.sum(np.abs(state) ** 2, axis=(0, 1))
+        c_probs = None
+        if compare_classical:
+            walkers = 10000
+            x, y = np.zeros(walkers, dtype=int), np.zeros(walkers, dtype=int)
+            for _ in range(steps):
+                x += np.random.choice([-1, 1], size=walkers)
+                y += np.random.choice([-1, 1], size=walkers)
+            c_probs, _, _ = np.histogram2d(x, y, bins=[np.arange(-N, N + 2) - 0.5] * 2, density=True)
+            c_probs = c_probs.T
+        return {"type": "2D", "q_data": q_probs, "c_data": c_probs}
+
+    def _run_3d(self, steps, initial_dist):
+        N = self.N
+        LSIZE = self.LSIZE
+        COIN_DIM = 6
+        state = np.zeros((COIN_DIM, LSIZE, LSIZE, LSIZE), dtype=np.complex128)
+        center = N
+        if initial_dist == 'uniform':
+            state[:, center, center, center] = 1.0 / np.sqrt(COIN_DIM)
+        else:
+            state[0, center, center, center] = 1.0
+        grover_coin = (2.0 / COIN_DIM) * np.ones((COIN_DIM, COIN_DIM)) - np.eye(COIN_DIM)
+        
+        for _ in range(steps):
+            state = np.einsum('ij,jxyz->ixyz', grover_coin, state)
+            new_state = np.zeros_like(state)
+            new_state[0] = np.roll(state[0], 1, 0)
+            new_state[1] = np.roll(state[1], -1, 0)
+            new_state[2] = np.roll(state[2], 1, 1)
+            new_state[3] = np.roll(state[3], -1, 1)
+            new_state[4] = np.roll(state[4], 1, 2)
+            new_state[5] = np.roll(state[5], -1, 2)
+            state = new_state
+        q_probs = np.sum(np.abs(state) ** 2, axis=0)
+        return {"type": "3D", "q_data": q_probs}
+
+    def visualize(self):
+        if self.results is None: raise ValueError("No results. Run simulation first.")
+        if self.dimension == 1: self._visualize_1d()
+        elif self.dimension == 2: self._visualize_2d()
+        elif self.dimension == 3: self._visualize_3d()
+
+    def _visualize_1d(self):
+        result = self.results
+        plt.figure()
+        plt.plot(result['grid'], result['quantum_probs'], label='Quantum')
+        if result['classical_probs'] is not None:
+            plt.plot(result['grid'], result['classical_probs'], label='Classical', linestyle='--')
+        plt.legend()
+        plt.title(f"1D Quantum Walk (N={self.meta['network_size']}, T={self.meta['steps']})")
+        plt.show()
+
+    def _visualize_2d(self):
+        result = self.results
+        fig, axes = plt.subplots(1, 2 if self.meta['compare_classical'] else 1, figsize=(12, 5))
+        ax_q = axes[0] if self.meta['compare_classical'] else axes
+        im_q = ax_q.imshow(result['q_data'], cmap='Blues', origin='lower', extent=[-self.N, self.N, -self.N, self.N])
+        ax_q.set_title(f"Quantum Walk (Steps={self.meta['steps']})")
+        plt.colorbar(im_q, ax=ax_q)
+        if self.meta['compare_classical']:
+            ax_c = axes[1]
+            im_c = ax_c.imshow(result['c_data'], cmap='Blues', origin='lower', extent=[-self.N, self.N, -self.N, self.N])
+            ax_c.set_title("Classical Random Walk")
+            plt.colorbar(im_c, ax=ax_c)
+        plt.tight_layout()
+        plt.show()
+
+    def _visualize_3d(self):
+        q_probs = self.results['q_data']
+        N = self.N
+        center = N
+        xy = q_probs[:, :, center]
+        yz = q_probs[center, :, :]
+        xz = q_probs[:, center, :]
+        fig, axes = plt.subplots(1, 3, figsize=(18, 5), dpi=100)
+        cmap = 'YlGnBu'
+        norm = LogNorm(vmin=max(q_probs.min(), 1e-12), vmax=q_probs.max())
+        
+        for ax, data, title, xlabel, ylabel in zip(axes, [xy, yz, xz], ["XY Slice", "YZ Slice", "XZ Slice"], ["x","y","x"], ["y","z","z"]):
+            im = ax.imshow(data.T, cmap=cmap, norm=norm, origin='lower', extent=[-N, N, -N, N])
+            ax.set_title(title); ax.set_xlabel(xlabel); ax.set_ylabel(ylabel)
+        fig.colorbar(axes[2].images[0], ax=axes.ravel().tolist(), pad=0.02).set_label('Raw Probability Density')
+        plt.suptitle(f"3D Quantum Walk Analysis (Steps={self.meta['steps']})")
+        plt.show()

qwnet-2.0.0.dist-info/METADATA

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: QWnet
+Version: 2.0.0
+Summary: A unified Quantum Walk simulation package
+Project-URL: Homepage, https://example.com/QWnet
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: networkx
+
+# QWnet Package
+
+This package provides a unified interface for various Quantum Walk simulations.
+
+## Installation
+
+```bash
+pip install QWnet
+```
+
+## Usage
+
+```python
+import QWnet as qw
+
+# 1D/2D/3D Lattice Walks
+qw.run_simulation('1d', steps=100)
+qw.run_simulation('2d', steps=50)
+qw.run_simulation('3d', steps=20)
+
+# Graph Walks
+qw.run_simulation('ranking', file_path='graph.edgelist')
+qw.run_simulation('pagerank')
+qw.run_simulation('hadamard')
+qw.run_simulation('szegedy')
+qw.run_simulation('community')
+```

qwnet-2.0.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+QWnet/__init__.py,sha256=el2pSuqEri_X-e6eMn57uxiQ7XUsXTYXK2oQiN94pK0,3777
+QWnet/graphs.py,sha256=N-tP9lUEVwiM4iRJJazA0oL4Udl4_BxXu4KRk8SMhSo,13167
+QWnet/lattice.py,sha256=wYjIyh1rhYB_ONgxmWfMAWtncOc0sJ13W2jMjEBYQ7Y,8852
+qwnet-2.0.0.dist-info/METADATA,sha256=gHVzVUkmMQ8brwIJlungRp8KG41hKCkEWf7lYsAzuSw,832
+qwnet-2.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+qwnet-2.0.0.dist-info/top_level.txt,sha256=h1QjXkEfsiVSIVldoV7OoylAVPE6lfyiFDfYB89yVwM,6
+qwnet-2.0.0.dist-info/RECORD,,

qwnet-2.0.0.dist-info/WHEEL

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

qwnet-2.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+QWnet