Implement Pattern module

docs/source/pattern.rst

@@ -0,0 +1,21 @@
+Pattern
+=======
+
+:mod:`graphix_zx.pattern` module
+++++++++++++++++++++++++++++++++
+
+.. automodule:: graphix_zx.pattern
+
+Pattern Classes
+---------------
+
+.. autoclass:: graphix_zx.pattern.Pattern
+    :members:
+    :member-order: bysource
+
+Helper Functions
+----------------
+
+.. autofunction:: graphix_zx.pattern.is_runnable
+
+.. autofunction:: graphix_zx.pattern.print_pattern

docs/source/references.rst

@@ -13,3 +13,4 @@ Module reference
     focus_flow
     command
     decoder_backend
+    pattern

graphix_zx/command.py

@@ -36,6 +36,9 @@ class N:
 
     node: int
 
+    def __str__(self) -> str:
+        return f"N: node={self.node}"
+
 
 @dataclasses.dataclass
 class E:
@@ -49,6 +52,9 @@ class E:
 
     nodes: tuple[int, int]
 
+    def __str__(self) -> str:
+        return f"E: nodes={self.nodes}"
+
 
 @dataclasses.dataclass
 class M:
@@ -60,22 +66,30 @@ class M:
         The node index to be measured.
     meas_basis : MeasBasis
         The measurement basis.
-    s_cbit : `int`
+    s_cbit : `int` | `None`
         The index of s_domain control classical bit.
-    t_cbit : `int`
+        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
-    t_cbit: int
+    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}"
+        )
 
 
 @dataclasses.dataclass
 class _Correction:
     node: int
-    cbit: int
+    cbit: int | None = None
 
 
 @dataclasses.dataclass
@@ -86,10 +100,14 @@ class X(_Correction):
     ----------
     node : `int`
         The node index to apply the correction.
-    cbit : `int`
+    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}"
+
 
 @dataclasses.dataclass
 class Z(_Correction):
@@ -99,10 +117,14 @@ class Z(_Correction):
     ----------
     node : `int`
         The node index to apply the correction.
-    cbit : `int`
+    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:
@@ -119,25 +141,34 @@ class Clifford:
     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 : `dict`\[`int`, `bool`\]
-        A dictionary mapping classical bit indices to their boolean values.
+    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: dict[int, bool]
+    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}"
+
 
 if sys.version_info >= (3, 10):
     Command = N | E | M | X | Z | Clifford | D