Rotated Surface Codes (Union-Find tested) (#55)

* Update requirements

* Fix for benchmarker

* requirements fix for compatibility

* rotated codes implementation

* fixed rotated logical operators

* removing mwpm plotting for rotated codes

---------

Co-authored-by: Mark Shui Hu <watermarkhu@gmail.com>

Author: HeineCantor

README.md

@@ -44,7 +44,7 @@ pip install qsurface
 
 * Python 3.7+
 * [Tkinter](https://docs.python.org/3/library/tkinter.html) or [PyQt5](https://riverbankcomputing.com/software/pyqt/intro) for interactive plotting.
-* Matplotlib 3.4+ for plotting on a 3D lattice (Refers to a future release of matplotlib, see [pull request](https://github.com/matplotlib/matplotlib/pull/18816))
+* Matplotlib 3.4+ for plotting on a 3D lattice
 
 ### MWPM decoder
 

examples.ipynb

@@ -1,6 +1,8 @@
 {
  "cells": [
   {
+   "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "# Qsurface\n",
     "\n",
@@ -15,9 +17,7 @@
     "The included examples in this section uses `qsurface.main.initialize` to setup the surface code and decoder, and `qsurface.main.run` to perform simulations. We'll expand these examples with more in-depth descriptions and  how to perform a threshold simulation with `qsurface.main.threshold`. \n",
     "\n",
     "To simulate the toric code and simulate with bit-flip error for 10 iterations and decode with the MWPM decoder:"
-   ],
-   "cell_type": "markdown",
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "code",
@@ -33,11 +33,11 @@
    ]
   },
   {
+   "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "Benchmarking of decoders can be enabled by attaching a *benchmarker* object to the decoder. See the docs for the syntax and information to setup benchmarking."
-   ],
-   "cell_type": "markdown",
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "code",
@@ -51,14 +51,14 @@
    ]
   },
   {
+   "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "\n",
     "The figures in Qsurface allows for step-by-step visualization of the surface code simulation (and if supported the decoding process). Each figure logs its history such that the user can move backwards in time to view past states of the surface (and decoder). Press `h` when the figure is open for more information.\n",
     "\n",
     "The GUI of the figure is made possible by the PyQt5 or Tkinter backend. However, for Jupyter notebooks such as this one, the GUI is not available. Qsurface automatically detects this and plots each iteration inline instead. If you're running the notebook locally, or have proper X11 forwarding setup, you can still force the PyQt5 or Tkinter with the magic `%matplotlib qt` or `%matplotlib tk` prior to importing qsurface. "
-   ],
-   "cell_type": "markdown",
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "code",
@@ -94,24 +94,17 @@
     "code, decoder = initialize((3,3), \"toric\", \"mwpm\", enabled_errors=[\"pauli\"], faulty_measurements=True, plotting=True, initial_states=(0,0))\n",
     "run(code, decoder, error_rates = {\"p_bitflip\": 0.05, \"pm_bitflip\": 0.05}, decode_initial=False)"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
   "kernelspec": {
-   "name": "python3",
    "display_name": "Python 3.9.0 64-bit ('matplotlib34')",
    "metadata": {
     "interpreter": {
      "hash": "e34dec7d75d7c83c55b9c6f024af2f7a8fb83b2b2afb6029879e4fbdbc47e352"
     }
-   }
+   },
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
@@ -128,4 +121,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 2
-}
+}

qsurface/codes/__init__.py

@@ -7,4 +7,5 @@
 CODES = [
     "toric",
     "planar",
+    "rotated"
 ]

qsurface/codes/rotated/__init__.py

@@ -0,0 +1,2 @@
+from . import sim
+from . import plot

qsurface/codes/rotated/plot.py

@@ -0,0 +1,39 @@
+from .sim import PerfectMeasurements as SimPM, FaultyMeasurements as SimFM
+from .._template.plot import PerfectMeasurements as TemplatePM, FaultyMeasurements as TemplateFM
+
+
+class PerfectMeasurements(SimPM, TemplatePM):
+    # Inherited docstring
+
+    class Figure(TemplatePM.Figure):
+        # Inherited docstring
+
+        def __init__(self, code, *args, **kwargs) -> None:
+            self.main_boundary = [-1, -1, code.size[0] + 1, code.size[1] + 1]
+            super().__init__(code, *args, **kwargs)
+
+
+class FaultyMeasurements(SimFM, TemplateFM):
+    """Plotting code class for faulty measurements.
+
+    Inherits from `.codes.planar.sim.FaultyMeasurements` and `.codes.planar.plot.PerfectMeasurements`. See documentation for these classes for more.
+
+    Dependent on the ``figure3d`` argument, either a 3D figure object is created that inherits from `~.plot.Template3D` and `.codes.planar.plot.PerfectMeasurements.Figure`, or the 2D `.codes.planar.plot.PerfectMeasurements.Figure` is used.
+
+    Parameters
+    ----------
+    args
+        Positional arguments are passed on to `.codes.planar.sim.FaultyMeasurements`.
+    figure3d
+        Enables plotting on a 3D lattice. Disable to plot layer-by-layer on a 2D lattice, which increases responsiveness.
+    kwargs
+        Keyword arguments are passed on to `.codes.planar.sim.FaultyMeasurements` and the figure object.
+    """
+
+    class Figure2D(PerfectMeasurements.Figure, TemplateFM.Figure2D):
+        # Inherited docstring
+        pass
+
+    class Figure3D(PerfectMeasurements.Figure, TemplateFM.Figure3D):
+        # Inherited docstring
+        pass

qsurface/codes/rotated/sim.py

@@ -0,0 +1,97 @@
+from qsurface.codes.elements import AncillaQubit
+from ..toric.sim import PerfectMeasurements as ToricPM, FaultyMeasurements as ToricFM
+
+
+class PerfectMeasurements(ToricPM):
+    # Inherited docstring
+
+    name = "rotated"
+
+    _syndrome_dict = { 0: "x", 1: "z" }
+
+    def init_surface(self, z: float = 0, **kwargs):
+        """Initializes the rotated surface code on layer ``z``.
+
+        Parameters
+        ----------
+        z : int or float, optional
+            Layer of qubits, ``z=0`` for perfect measurements.
+        """
+        self.ancilla_qubits[z], self.data_qubits[z], self.pseudo_qubits[z] = {}, {}, {}
+        parity = self.init_parity_check
+
+        # Add data qubits to surface
+        for y in range(self.size[1]):
+            for x in range(self.size[0]):
+                self.add_data_qubit((x, y), z=z, **kwargs)
+
+        # Add ancilla qubits to surface
+        if self.size[1] % 2 == 1:
+            for y in range(self.size[1] - 1):
+                for x in range(self.size[0]):
+                    parity(self.add_ancilla_qubit((0.5 - 1 * (y%2) + x, y + 0.5), z=z, state_type=self._syndrome_dict[x%2], **kwargs))
+        else:
+            commute = -1
+            for y in range(self.size[1] - 1):
+                for x in range(self.size[0] + commute):
+                    commute *= -1
+                    parity(self.add_ancilla_qubit((0.5 - 1 * (y%2) + x, y + 0.5), z=z, state_type=self._syndrome_dict[x%2], **kwargs))
+
+        outer_qubits = self.size[0] // 2
+
+        for x in range(outer_qubits): # for first and last row
+            parity(self.add_ancilla_qubit((0.5 + 2*x, -0.5), z=z, state_type=self._syndrome_dict[1], **kwargs))
+            parity(self.add_ancilla_qubit((self.size[0] - 1.5 - 2*x, self.size[1] - 0.5), z=z, state_type=self._syndrome_dict[1], **kwargs))
+
+        # Add pseudo qubits to surface (boundaries)
+        if self.size[1] % 2 == 1:
+            for y in range(self.size[1] - 1):
+                if y % 2 == 0:
+                    parity(self.add_pseudo_qubit((-0.5, y + 0.5), z=z, state_type=self._syndrome_dict[1], **kwargs))
+                else:
+                    parity(self.add_pseudo_qubit((self.size[0] - 0.5, y + 0.5), z=z, state_type=self._syndrome_dict[1], **kwargs))
+        else:
+            for y in range(self.size[1] - 1):
+                if y % 2 == 0:
+                    parity(self.add_pseudo_qubit((-0.5, y + 0.5), z=z, state_type=self._syndrome_dict[1], **kwargs))
+                    parity(self.add_pseudo_qubit((self.size[0] - 0.5, y + 0.5), z=z, state_type=self._syndrome_dict[1], **kwargs))
+
+        for x in range(self.size[0]+1):
+            if x % 2 == 0 or x >= (outer_qubits)*2:
+                parity(self.add_pseudo_qubit((x - 0.5, - 0.5), z=z, state_type=self._syndrome_dict[x % 2], **kwargs))
+                parity(self.add_pseudo_qubit((self.size[0] - 0.5 - x, self.size[1] - 0.5), z=z, state_type=self._syndrome_dict[x % 2], **kwargs))
+
+    def init_parity_check(self, ancilla_qubit: AncillaQubit, **kwargs):
+        """Initiates a parity check measurement.
+
+        For every ancilla qubit on ``(x,y)``, four neighboring data qubits are entangled for parity check measurements.
+
+        Parameters
+        ----------
+        ancilla_qubit : `~.codes.elements.AncillaQubit`
+            Ancilla qubit to initialize.
+        """
+        (x, y), z = ancilla_qubit.loc, ancilla_qubit.z
+        checks = {
+            (0.5, 0.5): ((x + 0.5), (y+0.5)),
+            (-0.5, 0.5): ((x - 0.5), (y+0.5)),
+            (0.5, -0.5): ((x + 0.5), (y - 0.5)),
+            (-0.5, -0.5): ((x - 0.5), (y - 0.5)),
+        }
+        for key, loc in checks.items():
+            if loc in self.data_qubits[z]:
+                self.entangle_pair(self.data_qubits[z][loc], ancilla_qubit, key)
+
+    def init_logical_operator(self, **kwargs):
+        """Initiates the logical operators [x,z] of the rotated code."""
+        operators = {
+            "x": [self.data_qubits[self.decode_layer][(i, 0)].edges["x"] for i in range(self.size[0])],
+            "z": [self.data_qubits[self.decode_layer][(0, i)].edges["z"] for i in range(self.size[1])],
+        }
+        self.logical_operators = operators
+
+
+class FaultyMeasurements(ToricFM, PerfectMeasurements):
+    # Inherited docstring
+
+    pass

qsurface/decoders/mwpm/plot.py

@@ -23,4 +23,4 @@ class Planar(Toric, SimPlanar):
         Positional and keyword arguments are passed on to `~.decoders.mwpm.plot.Toric` and `.decoders.mwpm.sim.Planar`.
     """
 
-    pass
+    pass

qsurface/decoders/unionfind/plot.py

@@ -1,7 +1,7 @@
 from ...codes.elements import AncillaQubit, DataQubit, Edge
 from ...plot import Template2D, Template3D
 from .._template import Plot
-from .sim import Toric as SimToric, Planar as SimPlanar
+from .sim import Toric as SimToric, Planar as SimPlanar, Rotated as SimRotated
 from matplotlib.patches import Rectangle
 from matplotlib.lines import Line2D
 
@@ -362,3 +362,9 @@ class Figure2D(Toric.Figure2D):
         def _plot_ancilla(self, ancilla, **kwargs):
             if type(ancilla) == AncillaQubit:
                 super()._plot_ancilla(ancilla, **kwargs)
+
+class Rotated(Planar, SimRotated):
+    def init_plot(self, **kwargs):
+        # Inherited docstring
+        size = [xy - 0.5 for xy in self.code.size]
+        self._init_axis([-0.5, -0.5] + size, title=self.decoder, aspect="equal")

qsurface/decoders/unionfind/sim.py

@@ -661,3 +661,6 @@ def peel_clusters(self, **kwargs):
                         key, (new_ancilla, edge) = leaf
                         self._edge_peel(edge, variant="peel")
                         self.peel_leaf(cluster, new_ancilla)
+
+class Rotated(Planar):
+    pass

qsurface/main.py

@@ -185,6 +185,7 @@ def run(
     if benchmark:
         output["benchmark"] = {
             **benchmark.data,
+            **benchmark.values,
             **benchmark.lists_mean_var(),
         }
 
@@ -431,17 +432,26 @@ def wrapper(*args, **kwargs):
 
         # Decorate decoder methods
         decorator_names = ["value_to_list"] + self.list_decorators + self.value_decorators
-        for method_name, decorators in self.methods_to_benchmark.items():
+        for handle_name, decorators in self.methods_to_benchmark.items():
             if isinstance(decorators, str):
                 decorators = [decorators]
 
-            class_method = getattr(decoder, method_name)
+            attribute_names = handle_name.split('.')
+            handle = decoder
+            for i, attribute_name in enumerate(attribute_names):
+                owner = handle
+                if hasattr(owner, attribute_name):
+                    handle = getattr(owner, attribute_name)
+                else:
+                    raise NameError(f"{attribute_name} is not a method of {decoder}.{attribute_names[:i]}")
+
             for decorator in decorators:
                 if decorator not in decorator_names:
                     raise NameError(f"Decorator {decorator} not defined.")
                 wrapper = getattr(self, decorator)
-                class_method = wrapper(class_method)
-            setattr(decoder, method_name, class_method)
+                handle = wrapper(handle)
+
+            setattr(owner, attribute_name, handle)
 
     def lists_mean_var(self, reset: bool = True):
         """Get mean and stand deviation of values in ``self.lists``.