QRE Update

.github/CODEOWNERS

@@ -10,7 +10,7 @@
 /source/compiler/qsc_partial_eval @idavis @swernli
 /source/compiler/qsc_rca @idavis @swernli
 /source/compiler/qsc_rir @idavis @swernli
-/source/fuzz  @billti @idavis @swernli
+/source/fuzz @billti @idavis @swernli
 /katas @billti @swernli
 /source/jupyterlab @billti @idavis @minestarks
 /source/language_service @billti @idavis @minestarks @ScottCarda-MS
@@ -19,7 +19,9 @@
 /library @swernli @orpuente-MS
 /source/npm @billti @minestarks @ScottCarda-MS
 /source/pip @billti @idavis @minestarks
+/source/pip/qsharp/qre @msoeken @brad-lackey @jwhogabo
 /source/playground @billti @minestarks
+/source/qre @msoeken @brad-lackey @jwhogabo
 /source/resource_estimator @billti @swernli
 /samples @minestarks @swernli
 /source/vscode @billti @idavis @minestarks

Cargo.toml

@@ -27,6 +27,7 @@ members = [
     "source/language_service",
     "source/simulators",
     "source/pip",
+    "source/qre",
     "source/resource_estimator",
     "source/samples_test",
     "source/wasm",

source/pip/Cargo.toml

@@ -18,6 +18,7 @@ num-traits = { workspace = true }
 qsc = { path = "../compiler/qsc" }
 qdk_simulators = { path = "../simulators" }
 resource_estimator = { path = "../resource_estimator" }
+qre = { path = "../qre" }
 miette = { workspace = true, features = ["fancy"] }
 rustc-hash = { workspace = true }
 serde = { workspace = true, features = ["derive"] }

source/pip/benchmarks/bench_qre.py

@@ -0,0 +1,105 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+import timeit
+from dataclasses import dataclass, KW_ONLY, field
+from qsharp.qre import linear_function, generic_function
+from qsharp.qre._architecture import _make_instruction
+from qsharp.qre.models import (
+    GateBased,
+    SurfaceCode,
+    TwoDimensionalYokedSurfaceCode,
+    Litinski19Factory,
+)
+from qsharp.qre._enumeration import _enumerate_instances
+
+
+def bench_enumerate_instances():
+    # Measure performance of enumerating instances with a large domain
+    @dataclass
+    class LargeDomain:
+        _: KW_ONLY
+        param1: int = field(default=0, metadata={"domain": range(1000)})
+        param2: bool
+
+    number = 100
+
+    duration = timeit.timeit(
+        "list(_enumerate_instances(LargeDomain))",
+        globals={
+            "_enumerate_instances": _enumerate_instances,
+            "LargeDomain": LargeDomain,
+        },
+        number=number,
+    )
+
+    print(f"Enumerating instances took {duration / number:.6f} seconds on average.")
+
+
+def bench_enumerate_isas():
+    ctx = GateBased(gate_time=50, measurement_time=100).context()
+
+    # Hierarchical factory using from_components
+    query = (
+        SurfaceCode.q()
+        * TwoDimensionalYokedSurfaceCode.q(source=SurfaceCode.q())
+        * Litinski19Factory.q()
+    )
+
+    number = 100
+    duration = timeit.timeit(
+        "list(query.enumerate(ctx))",
+        globals={
+            "query": query,
+            "ctx": ctx,
+        },
+        number=number,
+    )
+
+    print(f"Enumerating ISAs took {duration / number:.6f} seconds on average.")
+
+
+def bench_function_evaluation_linear():
+    fl = linear_function(12)
+
+    inst = _make_instruction(42, 0, None, 1, fl, None, 1.0, {})
+    number = 1000
+    duration = timeit.timeit(
+        "inst.space(5)",
+        globals={
+            "inst": inst,
+        },
+        number=number,
+    )
+
+    print(
+        f"Evaluating linear function took {duration / number:.6f} seconds on average."
+    )
+
+
+def bench_function_evaluation_generic():
+    def func(arity: int) -> int:
+        return 12 * arity
+
+    fg = generic_function(func)
+
+    inst = _make_instruction(42, 0, None, 1, fg, None, 1.0, {})
+    number = 1000
+    duration = timeit.timeit(
+        "inst.space(5)",
+        globals={
+            "inst": inst,
+        },
+        number=number,
+    )
+
+    print(
+        f"Evaluating linear function took {duration / number:.6f} seconds on average."
+    )
+
+
+if __name__ == "__main__":
+    bench_enumerate_instances()
+    bench_enumerate_isas()
+    bench_function_evaluation_linear()
+    bench_function_evaluation_generic()

source/pip/pyproject.toml

@@ -23,6 +23,7 @@ jupyterlab = ["qsharp-jupyterlab"]
 widgets = ["qsharp-widgets"]
 qiskit = ["qiskit>=1.2.2,<3.0.0"]
 cirq = ["cirq-core>=1.6.1,<1.7"]
+qre = ["cirq-core==1.6.1,<1.7", "pandas>=2.1", "ply>=3.11", "pyqir<0.12"]
 
 [build-system]
 requires = ["maturin ~= 1.10.2"]

source/pip/qsharp/applications/__init__.py

@@ -0,0 +1,2 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.

source/pip/qsharp/applications/magnets/__init__.py

@@ -0,0 +1,14 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+# flake8: noqa F403
+# pyright: ignore[reportWildcardImportFromLibrary]
+
+"""Magnets application module.
+
+Re-exports from the submodules."""
+
+from .geometry import *
+from .models import *
+from .trotter import *
+from .utilities import *

source/pip/qsharp/applications/magnets/geometry/__init__.py

@@ -0,0 +1,22 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+"""Geometry module for representing quantum system topologies.
+
+This module provides hypergraph data structures for representing the
+geometric structure of quantum systems, including lattice topologies
+and interaction graphs.
+"""
+
+from .complete import CompleteBipartiteGraph, CompleteGraph
+from .lattice1d import Chain1D, Ring1D
+from .lattice2d import Patch2D, Torus2D
+
+__all__ = [
+    "CompleteBipartiteGraph",
+    "CompleteGraph",
+    "Chain1D",
+    "Ring1D",
+    "Patch2D",
+    "Torus2D",
+]

source/pip/qsharp/applications/magnets/geometry/complete.py

@@ -0,0 +1,150 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+"""Complete graph geometries for quantum simulations.
+
+This module provides classes for representing complete graphs and complete
+bipartite graphs as hypergraphs. These structures are useful for quantum
+systems with all-to-all or bipartite all-to-all interactions.
+"""
+
+from ..utilities import (
+    Hyperedge,
+    Hypergraph,
+    HypergraphEdgeColoring,
+)
+
+
+class CompleteGraph(Hypergraph):
+    """A complete graph where every vertex is connected to every other vertex.
+
+    In a complete graph K_n, there are n vertices and n(n-1)/2 edges,
+    with each pair of distinct vertices connected by exactly one edge.
+
+    Attributes:
+        n: Number of vertices in the graph.
+
+    Example:
+
+    .. code-block:: python
+        >>> graph = CompleteGraph(4)
+        >>> graph.nvertices
+        4
+        >>> graph.nedges
+        6
+    """
+
+    def __init__(self, n: int, self_loops: bool = False) -> None:
+        """Initialize a complete graph.
+
+        Args:
+            n: Number of vertices in the graph.
+            self_loops: If True, include self-loop edges on each vertex
+                for single-site terms.
+        """
+        if self_loops:
+            _edges = [Hyperedge([i]) for i in range(n)]
+        else:
+            _edges = []
+
+        # Add all pairs of vertices
+        for i in range(n):
+            for j in range(i + 1, n):
+                _edges.append(Hyperedge([i, j]))
+        super().__init__(_edges)
+
+        self.n = n
+
+    def edge_coloring(self) -> HypergraphEdgeColoring:
+        """Compute edge coloring for this complete graph."""
+        coloring = HypergraphEdgeColoring(self)
+        for edge in self.edges():
+            if len(edge.vertices) == 1:
+                coloring.add_edge(edge, -1)
+            else:
+                if self.n % 2 == 0:
+                    i, j = edge.vertices
+                    m = self.n - 1
+                    if j == m:
+                        coloring.add_edge(edge, i)
+                    elif (j - i) % 2 == 0:
+                        coloring.add_edge(edge, (j - i) // 2)
+                    else:
+                        coloring.add_edge(edge, (j - i + m) // 2)
+                else:
+                    m = self.n
+                    i, j = edge.vertices
+                    if (j - i) % 2 == 0:
+                        coloring.add_edge(edge, (j - i) // 2)
+                    else:
+                        coloring.add_edge(edge, (j - i + m) // 2)
+        return coloring
+
+
+class CompleteBipartiteGraph(Hypergraph):
+    """A complete bipartite graph with two vertex sets.
+
+    In a complete bipartite graph K_{m,n} (m <= n), there are m + n
+    vertices partitioned into two sets of sizes m and n. Every vertex
+    in the first set is connected to every vertex in the second set,
+    giving m * n edges total.
+
+    Vertices 0 to m-1 form the first set, and vertices m to m+n-1
+    form the second set.
+
+    Attributes:
+        m: Number of vertices in the first set.
+        n: Number of vertices in the second set.
+
+    Requires:
+        m <= n
+
+    Example:
+
+    .. code-block:: python
+        >>> graph = CompleteBipartiteGraph(2, 3)
+        >>> graph.nvertices
+        5
+        >>> graph.nedges
+        6
+    """
+
+    def __init__(self, m: int, n: int, self_loops: bool = False) -> None:
+        """Initialize a complete bipartite graph.
+
+        Args:
+            m: Number of vertices in the first set (vertices 0 to m-1).
+            n: Number of vertices in the second set (vertices m to m+n-1).
+            self_loops: If True, include self-loop edges on each vertex
+                for single-site terms.
+        """
+        assert m <= n, "Require m <= n for CompleteBipartiteGraph."
+        total_vertices = m + n
+
+        if self_loops:
+            _edges = [Hyperedge([i]) for i in range(total_vertices)]
+
+        else:
+            _edges = []
+
+        # Connect every vertex in first set to every vertex in second set
+        for i in range(m):
+            for j in range(m, m + n):
+                _edges.append(Hyperedge([i, j]))
+        super().__init__(_edges)
+
+        self.m = m
+        self.n = n
+
+    def edge_coloring(self) -> HypergraphEdgeColoring:
+        """Compute edge coloring for this complete bipartite graph."""
+        coloring = HypergraphEdgeColoring(self)
+        m = self.m
+        n = self.n
+        for edge in self.edges():
+            if len(edge.vertices) == 1:
+                coloring.add_edge(edge, -1)
+            else:
+                i, j = edge.vertices
+                coloring.add_edge(edge, (i + j - m) % n)
+        return coloring