hdh 0.0.1__tar.gz

hdh-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Maria Gragera Garces
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

hdh-0.0.1/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.3
+Name: hdh
+Version: 0.0.1
+Summary: Hybrid Dependency Hypergraphs for quantum computation: translation, visualization, and partitioning.
+License: MIT
+Keywords: quantum,compiler,partitioning,hdh,hypergraph
+Author: Maria Gragera Garces
+Author-email: m.gragera.gaces@gmail.com
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: matplotlib (>=3.0,<4.0)
+Requires-Dist: networkx (>=3.0,<4.0)
+Requires-Dist: qiskit (>=1.0,<2.0)
+Project-URL: Homepage, https://pypi.org/project/hdh/
+Project-URL: Repository, https://github.com/grageragarces/hdh
+Description-Content-Type: text/markdown
+
+# hdh
+
+**Hybrid Dependency Hypergraphs for Quantum Computation**
+
+🚧 **Work in Progress**  
+This library translates quantum computations into Hybrid Dependency Hypergraph (HDH) representations for analysis, visualization, and partitioning.
+
+## Project Goals
+
+- Convert quantum circuits into HDH format  
+  - Support for popular SDKs (e.g., Qiskit)  
+  - Direct encoding from algorithmic structures
+- Print HDHs in a readable, canonical format  
+- Apply graph partitioning (e.g., METIS, KaHyPar) for distribution-aware analysis
+

hdh-0.0.1/README.md

@@ -0,0 +1,14 @@
+# hdh
+
+**Hybrid Dependency Hypergraphs for Quantum Computation**
+
+🚧 **Work in Progress**  
+This library translates quantum computations into Hybrid Dependency Hypergraph (HDH) representations for analysis, visualization, and partitioning.
+
+## Project Goals
+
+- Convert quantum circuits into HDH format  
+  - Support for popular SDKs (e.g., Qiskit)  
+  - Direct encoding from algorithmic structures
+- Print HDHs in a readable, canonical format  
+- Apply graph partitioning (e.g., METIS, KaHyPar) for distribution-aware analysis

hdh-0.0.1/hdh/converters/convert_from_qasm.py

@@ -0,0 +1,12 @@
+from qiskit import QuantumCircuit
+from hdh.converters.convert_from_qiskit import from_qiskit  # your existing converter
+
+def from_qasm(input_type: str, qasm: str):
+    if input_type == 'file':
+        circuit = QuantumCircuit.from_qasm_file(qasm)
+    elif input_type == 'string':
+        circuit = QuantumCircuit.from_qasm_str(qasm)
+    else:
+        raise ValueError("Unsupported type. Use 'file' or 'string'.")
+    
+    return from_qiskit(circuit)

hdh-0.0.1/hdh/converters/convert_from_qiskit.py

@@ -0,0 +1,39 @@
+from qiskit import QuantumCircuit
+from typing import Set
+import sys
+import os
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+from hdh.hdh import HDH
+from models.circuit import Circuit
+
+def from_qiskit(circuit: QuantumCircuit) -> HDH:
+    CONTROL_GATES = {
+        "cx": [0],
+        "ccx": [0, 1],
+    }
+
+    qc_adapter = Circuit()
+
+    for instruction in circuit.data:
+        gate = instruction.operation
+        qargs = instruction.qubits
+        cargs = instruction.clbits
+        name = gate.name.lower()
+
+        if name in {"barrier", "snapshot", "delay", "label"}:
+            continue
+
+        q_indices = [circuit.find_bit(q).index for q in qargs]
+        c_indices = [circuit.find_bit(c).index for c in cargs]
+
+        if name == "measure":
+            modifies_flags = [False] * len(q_indices)
+        elif name == "reset":
+            modifies_flags = [True] * len(q_indices)
+        else:
+            ctrl = CONTROL_GATES.get(name, list(range(len(q_indices) - 1)))
+            modifies_flags = [i not in ctrl for i in range(len(q_indices))]
+
+        qc_adapter.add_instruction(name, q_indices, c_indices, modifies_flags)
+
+    return qc_adapter.build_hdh()

hdh-0.0.1/hdh/graph.py

@@ -0,0 +1,33 @@
+
+class HDHNode:
+    def __init__(self, id, type, time):
+        self.id = id
+        self.type = type  # e.g., 'qubit', 'classical', 'measurement'
+        self.time = time
+
+    def __repr__(self):
+        return f"HDHNode(id={self.id}, type={self.type}, time={self.time})"
+
+class HDHEdge:
+    def __init__(self, id, operation, inputs, outputs):
+        self.id = id
+        self.operation = operation  # e.g., 'H', 'CX', 'M', etc.
+        self.inputs = inputs
+        self.outputs = outputs
+
+    def __repr__(self):
+        return f"HDHEdge(id={self.id}, op={self.operation}, in={self.inputs}, out={self.outputs})"
+
+class HDHGraph:
+    def __init__(self):
+        self.nodes = {}
+        self.edges = []
+
+    def add_node(self, node):
+        self.nodes[node.id] = node
+
+    def add_edge(self, edge):
+        self.edges.append(edge)
+
+    def __repr__(self):
+        return f"HDHGraph(nodes={len(self.nodes)}, edges={len(self.edges)})"

hdh-0.0.1/hdh/hdh.py

@@ -0,0 +1,59 @@
+from collections import defaultdict
+from typing import Dict, Set, Tuple, List, Literal, Union
+
+NodeType = Literal["q", "c"]  # quantum or classical
+EdgeType = Literal["q", "c"]
+NodeID = str
+TimeStep = int
+
+class HDH:
+    def __init__(self):
+        self.S: Set[NodeID] = set()
+        self.C: Set[frozenset] = set()
+        self.T: Set[TimeStep] = set()
+        self.sigma: Dict[NodeID, NodeType] = {}  # node types
+        self.tau: Dict[frozenset, EdgeType] = {}  # hyperedge types
+        self.time_map: Dict[NodeID, TimeStep] = {}  # f: S -> T
+
+    def add_node(self, node_id: NodeID, node_type: NodeType, time: TimeStep):
+        self.S.add(node_id)
+        self.sigma[node_id] = node_type
+        self.time_map[node_id] = time
+        self.T.add(time)
+
+    def add_hyperedge(self, node_ids: Set[NodeID], edge_type: EdgeType):
+        edge = frozenset(node_ids)
+        self.C.add(edge)
+        self.tau[edge] = edge_type
+
+    def get_ancestry(self, node: NodeID) -> Set[NodeID]:
+        """Return nodes with paths ending at `node` and earlier time steps."""
+        return {
+            s for s in self.S
+            if self.time_map[s] <= self.time_map[node] and self._path_exists(s, node)
+        }
+
+    def get_lineage(self, node: NodeID) -> Set[NodeID]:
+        """Return nodes reachable from `node` with later time steps."""
+        return {
+            s for s in self.S
+            if self.time_map[s] >= self.time_map[node] and self._path_exists(node, s)
+        }
+
+    def _path_exists(self, start: NodeID, end: NodeID) -> bool:
+        """DFS to find a time-respecting path from `start` to `end`."""
+        visited = set()
+        stack = [start]
+        while stack:
+            current = stack.pop()
+            if current == end:
+                return True
+            visited.add(current)
+            neighbors = {
+                neighbor
+                for edge in self.C if current in edge
+                for neighbor in edge
+                if neighbor != current and self.time_map[neighbor] > self.time_map[current]
+            }
+            stack.extend(neighbors - visited)
+        return False

hdh-0.0.1/hdh/passes/cut.py

@@ -0,0 +1,39 @@
+import networkx as nx
+import networkx.algorithms.community as nx_comm
+import metis
+from typing import List, Set
+from hdh.hdh import HDH
+
+def compute_cut(hdh: HDH, num_parts: int) -> List[Set[str]]:
+    """
+    Use METIS to partition HDH nodes into disjoint blocks.
+    
+    Returns a list of disjoint sets of node IDs.
+    """
+    # 1. Build undirected graph from HDH
+    G = nx.Graph()
+    G.add_nodes_from(hdh.S)
+    
+    for edge in hdh.C:
+        edge_nodes = list(edge)
+        for i in range(len(edge_nodes)):
+            for j in range(i + 1, len(edge_nodes)):
+                G.add_edge(edge_nodes[i], edge_nodes[j])
+
+    # 2. Convert to METIS-compatible graph (requires contiguous integer node IDs)
+    node_list = list(G.nodes)
+    node_idx_map = {node: idx for idx, node in enumerate(node_list)}
+    idx_node_map = {idx: node for node, idx in node_idx_map.items()}
+
+    metis_graph = nx.relabel_nodes(G, node_idx_map, copy=True)
+    
+    # 3. Call METIS
+    _, parts = metis.part_graph(metis_graph, nparts=num_parts)
+    
+    # 4. Build partition sets
+    partition = [set() for _ in range(num_parts)]
+    for idx, part in enumerate(parts):
+        node_id = idx_node_map[idx]
+        partition[part].add(node_id)
+    
+    return partition

hdh-0.0.1/hdh/visualize.py

@@ -0,0 +1,175 @@
+import matplotlib.pyplot as plt
+import networkx as nx
+import numpy as np
+import re
+import sys
+import os
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+from hdh.hdh import HDH
+
+def plot_hdh(hdh, save_path=None):
+    nodes = list(hdh.S)
+    edges = [tuple(e) for e in hdh.C]
+
+    node_positions = {}
+    node_timesteps = {}
+    node_qubits = {}
+    qubit_labels = set()
+    timesteps = set()
+
+    for node in nodes:
+        if node.startswith("q") or node.startswith("c"):
+            match = re.match(r"[qc](\d+)_t(\d+)", node)
+            if match:
+                index, timestep = map(int, match.groups())
+                node_timesteps[node] = timestep
+                node_qubits[node] = index
+                qubit_labels.add(index)
+                timesteps.add(timestep)
+        else:
+            print(f"Skipping node due to unrecognized format: {node}")
+
+    if not qubit_labels:
+        print("No valid nodes found with q{{index}}_t{{step}} or c{{index}}_t{{step}} format.")
+        return
+
+    max_index = max(qubit_labels)
+
+    for node in nodes:
+        if node in node_timesteps and node in node_qubits:
+            timestep = node_timesteps[node]
+            flipped_index = max_index - node_qubits[node]
+            node_positions[node] = (timestep, flipped_index)
+
+    qubit_ticks = sorted(qubit_labels)
+    flipped_ticks = [max_index - i for i in qubit_ticks]
+    timestep_ticks = sorted(timesteps)
+
+    fig, ax = plt.subplots(figsize=(10, 4))
+    ax.set_xlabel("Timestep")
+    ax.set_ylabel("Qubit/Clbit Index")
+    ax.set_xticks(timestep_ticks)
+    ax.set_yticks(flipped_ticks)
+    ax.set_yticklabels(qubit_ticks)
+    ax.set_ylim(min(flipped_ticks) - 1, max(flipped_ticks) + 1)
+
+    involved_nodes = set()
+    for edge in edges:
+        involved_nodes.update(edge)
+
+    for node in involved_nodes:
+        if node in node_positions:
+            x, y = node_positions[node]
+            node_type = hdh.sigma.get(node, "q")
+            color = {
+                "q": "black",
+                "ctrl": "black",
+                "c": "orange"
+            }.get(node_type, "black")
+            ax.plot(x, y, 'o', markersize=10, color=color)
+            ax.text(x, y + 0.15, node, ha='center')
+
+    seen_pairs = set()
+    for edge in edges:
+        edge_nodes = [n for n in edge if n in node_positions]
+
+        edge_type = hdh.tau.get(frozenset(edge))
+        if edge_type is None:
+            node_types = [hdh.sigma.get(n, "q") for n in edge]
+            edge_type = "c" if all(t == "c" for t in node_types) else "q"
+
+        color = "orange" if edge_type == "c" else "black"
+
+        for i in range(len(edge_nodes)):
+            for j in range(i + 1, len(edge_nodes)):
+                n1, n2 = edge_nodes[i], edge_nodes[j]
+                t1, t2 = node_timesteps[n1], node_timesteps[n2]
+
+                if t1 == t2:
+                    continue
+
+                type1 = hdh.sigma.get(n1, "q")
+                type2 = hdh.sigma.get(n2, "q")
+                if type1 == "ctrl" and type2 == "ctrl":
+                    continue
+
+                if t1 > t2:
+                    n1, n2 = n2, n1
+                    t1, t2 = t2, t1
+
+                pair = (n1, n2)
+                if pair in seen_pairs:
+                    continue
+                seen_pairs.add(pair)
+
+                x0, y0 = node_positions[n1]
+                x1, y1 = node_positions[n2]
+
+                print(f"Edge {edge} has type {edge_type}")
+
+                if edge_type == "c":
+                    dx = x1 - x0
+                    dy = y1 - y0
+                    dist = np.hypot(dx, dy)
+                    if dist == 0:
+                        continue
+                    t = np.linspace(0, 1, 200)
+                    x_line = x0 + dx * t
+                    y_line = y0 + dy * t
+                    nx_vec = -dy / dist
+                    ny_vec = dx / dist
+                    displacement = 0.08 * np.sin(6 * 2 * np.pi * t)
+                    x_vals = x_line + displacement * nx_vec
+                    y_vals = y_line + displacement * ny_vec
+                    ax.plot(x_vals, y_vals, color=color, linewidth=2)
+                else:
+                    ax.plot([x0, x1], [y0, y1], color=color, linewidth=1.5)
+
+    if save_path:
+        plt.savefig(save_path)
+    else:
+        plt.show()
+
+
+def plot_hdh_networkx(hdh: HDH):
+    G = nx.DiGraph()
+
+    for node in hdh.S:
+        node_type = hdh.sigma[node]
+        color = {
+            "q": "skyblue",
+            "ctrl": "orange",
+            "c": "lightgreen"
+        }.get(node_type, "orange")
+        G.add_node(node, color=color)
+
+    for edge in hdh.C:
+        edge_type = hdh.tau.get(edge)
+        if edge_type is None:
+            node_types = [hdh.sigma.get(n, "q") for n in edge]
+            edge_type = "c" if all(t == "c" for t in node_types) else "q"
+        edge_nodes = list(edge)
+        for i in range(len(edge_nodes)):
+            for j in range(i + 1, len(edge_nodes)):
+                G.add_edge(edge_nodes[i], edge_nodes[j], type=edge_type)
+
+    pos = nx.spring_layout(G, seed=42)
+    node_colors = [G.nodes[n]["color"] for n in G.nodes()]
+
+    edge_colors = []
+    edge_styles = []
+
+    for u, v, d in G.edges(data=True):
+        if d.get("type") == "c":
+            edge_colors.append("orange")
+            edge_styles.append("dashed")
+        else:
+            edge_colors.append("orange")
+            edge_styles.append("solid")
+
+    for (u, v), color, style in zip(G.edges(), edge_colors, edge_styles):
+        nx.draw_networkx_edges(G, pos, edgelist=[(u, v)], edge_color=color, style=style)
+
+    nx.draw_networkx_nodes(G, pos, node_color=node_colors)
+    nx.draw_networkx_labels(G, pos)
+    plt.show()

hdh-0.0.1/pyproject.toml

@@ -0,0 +1,24 @@
+[tool.poetry]
+name = "hdh"
+version = "0.0.1"
+description = "Hybrid Dependency Hypergraphs for quantum computation: translation, visualization, and partitioning."
+authors = ["Maria Gragera Garces <m.gragera.gaces@gmail.com>"]
+license = "MIT"
+readme = "README.md"
+packages = [{ include = "hdh" }]
+homepage = "https://pypi.org/project/hdh/"
+repository = "https://github.com/grageragarces/hdh"
+keywords = ["quantum", "compiler", "partitioning", "hdh", "hypergraph"]
+
+[tool.poetry.dependencies]
+python = "^3.10"
+qiskit = "^1.0"
+networkx = "^3.0"
+matplotlib = "^3.0"
+
+[tool.poetry.dev-dependencies]
+pytest = "^8.0"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"