Non-Clifford Removal

examples/zxgraph_simplification.py

@@ -0,0 +1,43 @@
+"""Basic example of simplifying a ZX-diagram.
+
+By using the `full_reduce` method,
+we can remove all the internal Clifford nodes and some non-Clifford nodes from the graph state,
+which generates a simpler ZX-diagram.
+This example is a simple demonstration of the simplification process.
+"""
+
+# %%
+from copy import deepcopy
+
+import numpy as np
+
+from graphix_zx.circuit import circuit2graph
+from graphix_zx.random_objects import random_circ
+from graphix_zx.visualizer import visualize
+from graphix_zx.zxgraphstate import ZXGraphState
+
+# %%
+circ = random_circ(4, 4)
+graph, flow = circuit2graph(circ)
+zx_graph = ZXGraphState()
+zx_graph.append(graph)
+
+visualize(zx_graph)
+print("node | plane | angle (/pi)")
+for node in zx_graph.input_nodes:
+    print(f"{node} (input)", zx_graph.meas_bases[node].plane, zx_graph.meas_bases[node].angle / np.pi)
+for node in zx_graph.physical_nodes - zx_graph.input_nodes - zx_graph.output_nodes:
+    print(node, zx_graph.meas_bases[node].plane, zx_graph.meas_bases[node].angle / np.pi)
+
+# %%
+zx_graph_smp = deepcopy(zx_graph)
+zx_graph_smp.full_reduce()
+
+visualize(zx_graph_smp)
+print("node | plane | angle (/pi)")
+for node in zx_graph.input_nodes:
+    print(f"{node} (input)", zx_graph.meas_bases[node].plane, zx_graph.meas_bases[node].angle / np.pi)
+for node in zx_graph_smp.physical_nodes - zx_graph.input_nodes - zx_graph_smp.output_nodes:
+    print(node, zx_graph_smp.meas_bases[node].plane, zx_graph_smp.meas_bases[node].angle / np.pi)
+
+# %%

graphix_zx/graphstate.py

@@ -400,6 +400,28 @@ def local_cliffords(self) -> dict[int, LocalClifford]:
         """
         return self.__local_cliffords
 
+    @property
+    def inner2nodes(self) -> dict[int, int]:
+        """Return inner index to node index mapping.
+
+        Returns
+        -------
+        dict[int, int]
+            inner index to node index mapping.
+        """
+        return self.__inner2nodes
+
+    @property
+    def nodes2inner(self) -> dict[int, int]:
+        """Return node index to inner index mapping.
+
+        Returns
+        -------
+        dict[int, int]
+            node index to inner index mapping.
+        """
+        return self.__nodes2inner
+
     def check_meas_basis(self) -> None:
         """Check if the measurement basis is set for all physical nodes except output nodes.
 

graphix_zx/random_objects.py

@@ -2,6 +2,7 @@
 
 This module provides:
 - get_random_flow_graph: Generate a random flow graph.
+- random_circ: Generate a random MBQC circuit.
 """
 
 from __future__ import annotations
@@ -10,10 +11,13 @@
 
 import numpy as np
 
+from graphix_zx.circuit import MBQCCircuit
 from graphix_zx.common import default_meas_basis
 from graphix_zx.graphstate import GraphState
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
+
     from numpy.random import Generator
 
 
@@ -82,3 +86,48 @@ def get_random_flow_graph(
         num_nodes += 1
 
     return graph, flow
+
+
+def random_circ(
+    width: int,
+    depth: int,
+    rng: np.random.Generator | None = None,
+    edge_p: float = 0.5,
+    angle_candidates: Sequence[float] = (0.0, np.pi / 3, 2 * np.pi / 3, np.pi),
+) -> MBQCCircuit:
+    """Generate a random MBQC circuit.
+
+    Parameters
+    ----------
+    width : int
+        circuit width
+    depth : int
+        circuit depth
+    rng : numpy.random.Generator, optional
+        random number generator, by default numpy.random.default_rng()
+    edge_p : float, optional
+        probability of adding CZ gate, by default 0.5
+    angle_candidates : collections.abc.Sequence[float], optional
+        list of angles, by default (0, np.pi / 3, 2 * np.pi / 3, np.pi)
+
+    Returns
+    -------
+    MBQCCircuit
+        generated MBQC circuit
+    """
+    if rng is None:
+        rng = np.random.default_rng()
+    circ = MBQCCircuit(width)
+    for d in range(depth):
+        for j in range(width):
+            circ.j(j, rng.choice(angle_candidates))
+        if d < depth - 1:
+            for j in range(width):
+                if rng.random() < edge_p:
+                    circ.cz(j, (j + 1) % width)
+            num = rng.integers(0, width)
+            if num > 0:
+                target = set(rng.choice(range(width), num))
+                circ.phase_gadget(target, rng.choice(angle_candidates))
+
+    return circ