Implement Y basis initialization/measurement block

docs/conf.py

@@ -179,6 +179,7 @@ def setup(app):
     "gallery/move_rotation": "_static/media/gallery/move_rotation.png",
     "gallery/three_cnots": "_static/media/gallery/three_cnots.png",
     "gallery/steane_encoding": "_static/media/gallery/steane_encoding.png",
+    "gallery/s_gate": "_static/media/gallery/s_gate.png",
 }
 
 

docs/gallery/index.rst

@@ -12,3 +12,4 @@ This section contains a collection of constructed logical computations and their
    move_rotation.ipynb
    three_cnots.ipynb
    steane_encoding.ipynb
+   s_gate.ipynb

main.py

@@ -0,0 +1,107 @@
+from tqec import BlockGraph, NoiseModel, compile_block_graph
+from tqec.compile.convention import FIXED_BOUNDARY_CONVENTION
+from tqec.utils.position import Position3D
+
+g = BlockGraph()
+
+n0 = g.add_cube(Position3D(0, 0, 0), "ZZX")
+n1 = g.add_cube(Position3D(1, 0, 0), "XZX")
+n2 = g.add_cube(Position3D(-1, 0, 0), "XZX")
+n3 = g.add_cube(Position3D(0, 1, 0), "ZXX")
+n4 = g.add_cube(Position3D(0, -1, 0), "ZXX")
+
+n5 = g.add_cube(Position3D(1, 0, 1), "Y")
+n6 = g.add_cube(Position3D(-1, 0, 1), "Y")
+n7 = g.add_cube(Position3D(0, 1, 1), "Y")
+n8 = g.add_cube(Position3D(0, -1, 1), "Y")
+
+g.add_pipe(n0, n1)
+g.add_pipe(n0, n2)
+g.add_pipe(n0, n3)
+g.add_pipe(n0, n4)
+g.add_pipe(n1, n5)
+g.add_pipe(n2, n6)
+g.add_pipe(n3, n7)
+g.add_pipe(n4, n8)
+
+correlation_surface = g.find_correlation_surfaces()[0]
+g.view_as_html(
+    "test.html", show_correlation_surface=correlation_surface, pop_faces_at_directions=("+Z", "-Y")
+)
+
+cg = compile_block_graph(g, observables=[correlation_surface], convention=FIXED_BOUNDARY_CONVENTION)
+circuit = cg.generate_stim_circuit(k=3)
+
+# circuit.to_file("sliding_annotated.stim")
+noisy_circuit = NoiseModel.uniform_depolarizing(1e-3).noisy_circuit(circuit)
+# noisy_circuit.detector_error_model().to_file("sliding.dem")
+# explained = noisy_circuit.explain_detector_error_model_errors(
+#     dem_filter=stim.DetectorErrorModel("error(0.001931182734310662227) D1 D3 D20 D22")
+# )
+
+# noisy_circuit.to_file("test2.stim")
+# noisy_circuit.detector_error_model().to_file("test.dem")
+# noisy_circuit.detector_error_model(
+#     decompose_errors=True, block_decomposition_from_introducing_remnant_edges=True
+# )
+# errors = noisy_circuit.explain_detector_error_model_errors(
+#     dem_filter=stim.DetectorErrorModel("error(6.669779853440971351e-05) D494 D604 D611 D640 D673")
+# )
+# print(errors[0])
+
+
+logical_error = noisy_circuit.shortest_graphlike_error(
+    ignore_ungraphlike_errors=False, canonicalize_circuit_errors=True
+)
+# html_str = gen.stim_circuit_html_viewer(noisy_circuit, known_error=explained)
+# html_str = gen.stim_circuit_html_viewer(noisy_circuit, known_error=logical_error)
+# with open("stim_circuit.html", "w") as f:
+#     print(html_str, file=f)
+print("Length of shortest graphlike error:", len(logical_error))
+
+
+# SAVE_DIR = Path("results")
+#
+#
+# def generate_graphs() -> None:
+#     zx_graph = g.to_zx_graph()
+#
+#     stats = start_simulation_using_sinter(
+#         g,
+#         range(1, 4),
+#         list(numpy.logspace(-4, -1, 10)),
+#         NoiseModel.uniform_depolarizing,
+#         manhattan_radius=2,
+#         observables=[correlation_surface],
+#         num_workers=cpu_count(),
+#         max_shots=1_000_000,
+#         max_errors=5_000,
+#         decoders=["pymatching"],
+#         print_progress=True,
+#     )
+#
+#     for i, stat in enumerate(stats):
+#         fig, ax = plt.subplots()
+#         sinter.plot_error_rate(
+#             ax=ax,
+#             stats=stat,
+#             x_func=lambda stat: stat.json_metadata["p"],
+#             group_func=lambda stat: stat.json_metadata["d"],
+#         )
+#         plot_observable_as_inset(ax, zx_graph, correlation_surface)
+#         ax.grid(axis="both")
+#         ax.legend()
+#         ax.loglog()
+#         ax.set_title("Logical CNOT Error Rate")
+#         ax.set_xlabel("Physical Error Rate")
+#         ax.set_ylabel("Logical Error Rate")
+#         fig.savefig(SAVE_DIR / f"ghz_result_observable_{i}.png")
+#
+#
+# def main():
+#     SAVE_DIR.mkdir(exist_ok=True)
+#     generate_graphs()
+#
+#
+# if __name__ == "__main__":
+#     main()

pyproject.toml

@@ -39,6 +39,7 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
+  "gen @ git+https://github.com/inmzhang/gen.git",
   "matplotlib>=3.9",
   "networkx>=3.0",
   "numpy>=1.22,<2.3",                                  # Upper bound: https://github.com/tqec/tqec/pull/659

src/tqec/__init__.py

@@ -3,3 +3,4 @@
 from .computation.block_graph import BlockGraph as BlockGraph
 from .utils import Basis as Basis
 from .utils import NoiseModel as NoiseModel
+from .utils import PauliBasis as PauliBasis

src/tqec/compile/blocks/__init__.py

@@ -11,24 +11,57 @@
 operations happening in parallel should be encoded in the same moment (i.e.,
 between the same two ``TICK`` instructions) in the resulting ``.stim`` file.
 
-Moreover, blocks might have different "schedules". For example, the regular
-memory block follow the schedule:
+This module provides two implementations of the :class:`~tqec.compile.blocks.block.Block`
+abstract base class:
 
-1. initialisation layer,
-2. repeat [memory layer],
-3. measurement layer,
+1. **LayeredBlock** - Represents blocks as a sequence of layers that can be instances
+   of :class:`~tqec.compile.blocks.layers.atomic.base.BaseLayer` or
+   :class:`~tqec.compile.blocks.layers.composed.base.BaseComposedLayer`. This is the
+   standard representation for blocks that follow a layer-synchronous schedule.
+
+   Note that different blocks may have different schedules. For example, the
+   regular memory block follows the schedule:
+
+    1. initialisation layer,
+    2. repeat [memory layer],
+    3. measurement layer,
 
 whereas a spatial pipe in the ``Y`` axis needs to alternate plaquettes in its
-repeated layer, leading to a schedule that is:
+   repeated layer, leading to a schedule that is::
+
+    1. initialisation layer,
+    2. repeat [memory layer 1 alternated with memory layer 2],
+    3. measurement layer.
+
+Both of these can be represented as LayeredBlock instances.
+
+2. **InjectedBlock** - Represents blocks via direct circuit representation using
+   :class:`~tqec.compile.blocks.block.CircuitWithInterface`.
 
-1. initialisation layer,
-2. repeat [memory layer 1 alternated with memory layer 2],
-3. measurement layer.
+Block Compilation
+==================
+
+In a topological computation, :class:`~tqec.compile.blocks.block.Block` instances
+execute in parallel, and ``tqec`` must ensure that operations happening in parallel
+are encoded in the same moment (i.e., between the same two ``TICK`` instructions)
+in the resulting ``.stim`` file.
+
+For LayeredBlock instances, this is handled by the layer merging system. For
+InjectedBlock instances, this is handled by the
+:class:`~tqec.compile.tree.injection.InjectionBuilder` which weaves injected
+circuits into layer-generated circuits while maintaining correct detector
+annotations via flow interfaces from Gidney's gen library.
+
+See Also
+========
 
 All these restrictions are handled by representing
 :class:`~tqec.compile.blocks.block.Block` instances with
 :class:`~tqec.compile.blocks.layers.atomic.base.BaseLayer` and
 :class:`~tqec.compile.blocks.layers.composed.base.BaseComposedLayer` instances.
-See :mod:`tqec.compile.blocks.layers` for more details.
+
+- See :mod:`tqec.compile.blocks.layers` for more layered block details.
+- :mod:`tqec.compile.tree.injection` for injection mechanics
+- :mod:`tqec.compile.blocks.enums` for alignment and border enumerations
 
 """