Implement qompiler

.gitignore

@@ -163,3 +163,4 @@ cython_debug/
 
 # Custom stuff
 docs/source/gallery
+docs/source/sg_execution_times.rst

docs/requirements.txt

@@ -1,3 +1,5 @@
-sphinx==8.2.3
-sphinx_gallery==0.19.0
-furo==2024.8.6
+sphinx>=7.4.0
+sphinx_gallery>=0.17.0
+furo>=2024.01.29
+
+matplotlib>=3.7.0

docs/source/command.rst

@@ -24,12 +24,6 @@ Command Classes
 .. autoclass:: graphix_zx.command.Z
     :members:
 
-.. autoclass:: graphix_zx.command.Clifford
-    :members:
-
-.. autoclass:: graphix_zx.command.D
-    :members:
-
 Type Alias
 ----------
 

docs/source/feedforward.rst

@@ -11,4 +11,6 @@ Functions
 
 .. autofunction:: graphix_zx.feedforward.dag_from_flow
 
-.. autofunction:: graphix_zx.feedforward.check_causality
+.. autofunction:: graphix_zx.feedforward.check_dag
+
+.. autofunction:: graphix_zx.feedforward.check_flow

docs/source/pauli_frame.rst

@@ -0,0 +1,14 @@
+Pauli Frame
+===========
+
+:mod:`graphix_zx.pauli_frame` module
+++++++++++++++++++++++++++++++++++++
+
+.. automodule:: graphix_zx.pauli_frame
+
+Pauli Frame Class
+-----------------
+
+.. autoclass:: graphix_zx.pauli_frame.PauliFrame
+    :members:
+    :member-order: bysource

docs/source/qompiler.rst

@@ -0,0 +1,12 @@
+Qompiler
+========
+
+:mod:`graphix_zx.qompiler` module
++++++++++++++++++++++++++++++++++
+
+.. automodule:: graphix_zx.qompiler
+
+Qompile Functions
+-----------------
+
+.. autofunction:: graphix_zx.qompiler.qompile

docs/source/references.rst

@@ -12,5 +12,6 @@ Module reference
     feedforward
     focus_flow
     command
-    decoder_backend
     pattern
+    pauli_frame
+    qompiler

examples/pattern_generation.py

@@ -0,0 +1,20 @@
+"""
+Basic Pattern Generation Example
+================================
+
+This example demonstrates how to generate a pattern from a graph state
+using the graphix-zx library.
+"""
+
+# %%
+from graphix_zx.pattern import print_pattern
+from graphix_zx.qompiler import qompile
+from graphix_zx.random_objects import generate_random_flow_graph
+
+# %%
+# convert circuit to graph and flow
+graphstate, gflow = generate_random_flow_graph(width=3, depth=5)
+# first, qompile it to standardized pattern
+pattern = qompile(graphstate, gflow)
+print("get max space of pattern:", pattern.max_space)
+print_pattern(pattern)

graphix_zx/command.py

@@ -7,8 +7,6 @@
 - `M`: Measurement command.
 - `X`: X correction command.
 - `Z`: Z correction command.
-- `Clifford`: Clifford command.
-- `D`: Decode command.
 - `Command`: Type alias of all commands.
 """
 
@@ -20,8 +18,6 @@
 
 if TYPE_CHECKING:
     from graphix_zx.common import MeasBasis
-    from graphix_zx.decoder_backend import BaseDecoder
-    from graphix_zx.euler import LocalClifford
 
 
 @dataclasses.dataclass
@@ -66,30 +62,18 @@ class M:
         The node index to be measured.
     meas_basis : MeasBasis
         The measurement basis.
-    s_cbit : `int` | `None`
-        The index of s_domain control classical bit.
-        Default is None, meaning the flag is always False.
-    t_cbit : `int` | `None`
-        The index of t_domain control classical bit.
-        Default is None, meaning the flag is always False.
     """
 
     node: int
     meas_basis: MeasBasis
-    s_cbit: int | None = None
-    t_cbit: int | None = None
 
     def __str__(self) -> str:
-        return (
-            f"M: node={self.node}, plane={self.meas_basis.plane}, "
-            f"angle={self.meas_basis.angle}, s_cbit={self.s_cbit}, t_cbit={self.t_cbit}"
-        )
+        return f"M: node={self.node}, plane={self.meas_basis.plane}, angle={self.meas_basis.angle}"
 
 
 @dataclasses.dataclass
 class _Correction:
     node: int
-    cbit: int | None = None
 
 
 @dataclasses.dataclass
@@ -100,13 +84,10 @@ class X(_Correction):
     ----------
     node : `int`
         The node index to apply the correction.
-    cbit : `int` | `None`
-        The index of the classical bit to control the correction.
-        If cbit is None, the flag is always False, meaning the correction will not be applied.
     """
 
     def __str__(self) -> str:
-        return f"X: node={self.node}, cbit={self.cbit}"
+        return f"X: node={self.node}"
 
 
 @dataclasses.dataclass
@@ -117,60 +98,13 @@ class Z(_Correction):
     ----------
     node : `int`
         The node index to apply the correction.
-    cbit : `int` | `None`
-        The index of the classical bit to control the correction.
-        If cbit is None, the flag is always False, meaning the correction will not be applied.
     """
 
     def __str__(self) -> str:
-        return f"Z: node={self.node}, cbit={self.cbit}"
-
-
-@dataclasses.dataclass
-class Clifford:
-    """Clifford command.
-
-    Attributes
-    ----------
-    node : `int`
-        The node index to apply the local Clifford.
-    local_clifford : `LocalClifford`
-        The local Clifford to apply
-    """
-
-    node: int
-    local_clifford: LocalClifford
-
-    def __str__(self) -> str:
-        return (
-            f"Clifford: node={self.node}, alpha={self.local_clifford.alpha}, "
-            f"beta={self.local_clifford.beta}, gamma={self.local_clifford.gamma}"
-        )
-
-
-@dataclasses.dataclass
-class D:
-    r"""Decode command.
-
-    Attributes
-    ----------
-    input_cbits : `list`\[`int`\]
-        A list of classical bit indices that will serve as input to the decoder.
-    output_cbits : `list`\[`int`\]
-        A list of classical bit indices that will store the decoding results.
-    decoder : `BaseDecoder`
-        The decoder instance used to process the input classical bits and produce the output.
-    """
-
-    input_cbits: list[int]
-    output_cbits: list[int]
-    decoder: BaseDecoder
-
-    def __str__(self) -> str:
-        return f"D: input_cbits={self.input_cbits}, output_cbits={self.output_cbits}, decoder={self.decoder}"
+        return f"Z: node={self.node}"
 
 
 if sys.version_info >= (3, 10):
-    Command = N | E | M | X | Z | Clifford | D
+    Command = N | E | M | X | Z
 else:
-    Command = Union[N, E, M, X, Z, Clifford, D]
+    Command = Union[N, E, M, X, Z]