surface-sim 0.1.0__py3-none-any.whl

surface_sim/__init__.py

@@ -0,0 +1,16 @@
+"""Main surface-sim module."""
+
+__version__ = "0.1.0"
+
+from . import experiments, models, util, circuit_blocks
+from .setup import Setup
+from .models import Model
+
+__all__ = [
+    "models",
+    "experiments",
+    "util",
+    "circuit_blocks",
+    "Setup",
+    "Model",
+]

surface_sim/circuit_blocks/__init__.py

@@ -0,0 +1,13 @@
+from . import (
+    surface_code_css,
+    surface_code_css_pipelined,
+    surface_code_xzzx,
+    surface_code_xzzx_google,
+)
+
+__all__ = [
+    "surface_code_css",
+    "surface_code_css_pipelined",
+    "surface_code_xzzx",
+    "surface_code_xzzx_google",
+]

surface_sim/circuit_blocks/surface_code_css.py

@@ -0,0 +1,185 @@
+from itertools import chain
+
+from stim import Circuit, target_rec
+from qec_util import Layout
+
+from ..models import Model
+
+# methods to have in this script
+from .util import qubit_coords, log_meas, log_x, log_z, init_qubits
+
+__all__ = ["qubit_coords", "log_meas", "log_x", "log_z", "qec_round", "init_qubits"]
+
+
+def qec_round(
+    model: Model,
+    layout: Layout,
+    meas_reset: bool = False,
+    meas_comparison: bool = True,
+) -> Circuit:
+    """
+    Returns stim circuit corresponding to a QEC cycle
+    of the given model.
+
+    This implementation follows:
+
+    https://doi.org/10.1103/PhysRevApplied.8.034021
+
+    Params
+    -------
+    meas_comparison
+        If True, the detector is set to the measurement of the ancilla
+        instead of to the comparison of consecutive syndromes.
+    """
+    data_qubits = layout.get_qubits(role="data")
+    anc_qubits = layout.get_qubits(role="anc")
+    qubits = set(data_qubits + anc_qubits)
+
+    int_order = layout.interaction_order
+    stab_types = list(int_order.keys())
+    x_stabs = layout.get_qubits(role="anc", stab_type="x_type")
+
+    # With reset defect[n] = m[n] XOR m[n-1]
+    # Wihtout reset defect[n] = m[n] XOR m[n-2]
+    comp_round = 1 if meas_reset else 2
+
+    circuit = Circuit()
+
+    # a
+    directions = [int_order["x_type"][0], int_order["x_type"][3]]
+    rot_qubits = set(anc_qubits)
+    rot_qubits.update(layout.get_neighbors(x_stabs, direction=directions[0]))
+    rot_qubits.update(layout.get_neighbors(x_stabs, direction=directions[1]))
+    for instruction in model.hadamard(rot_qubits):
+        circuit.append(instruction)
+    idle_qubits = qubits - rot_qubits
+    for instruction in model.idle(idle_qubits):
+        circuit.append(instruction)
+    circuit.append("TICK")
+
+    # b
+    interacted_qubits = set()
+    for stab_type in stab_types:
+        stab_qubits = layout.get_qubits(role="anc", stab_type=stab_type)
+        ord_dir = int_order[stab_type][0]
+        int_pairs = layout.get_neighbors(stab_qubits, direction=ord_dir, as_pairs=True)
+        int_qubits = list(chain.from_iterable(int_pairs))
+        interacted_qubits.update(int_qubits)
+
+        for instruction in model.cphase(int_qubits):
+            circuit.append(instruction)
+
+    idle_qubits = qubits - set(interacted_qubits)
+    for instruction in model.idle(idle_qubits):
+        circuit.append(instruction)
+    circuit.append("TICK")
+
+    # c
+    for instruction in model.hadamard(data_qubits):
+        circuit.append(instruction)
+    for instruction in model.idle(anc_qubits):
+        circuit.append(instruction)
+    circuit.append("TICK")
+
+    # d
+    interacted_qubits = set()
+    for stab_type in stab_types:
+        stab_qubits = layout.get_qubits(role="anc", stab_type=stab_type)
+        ord_dir = int_order[stab_type][1]
+        int_pairs = layout.get_neighbors(stab_qubits, direction=ord_dir, as_pairs=True)
+        int_qubits = list(chain.from_iterable(int_pairs))
+        interacted_qubits.update(int_qubits)
+
+        for instruction in model.cphase(int_qubits):
+            circuit.append(instruction)
+
+    idle_qubits = qubits - set(interacted_qubits)
+    for instruction in model.idle(idle_qubits):
+        circuit.append(instruction)
+    circuit.append("TICK")
+
+    # e
+    interacted_qubits = set()
+    for stab_type in stab_types:
+        stab_qubits = layout.get_qubits(role="anc", stab_type=stab_type)
+        ord_dir = int_order[stab_type][2]
+        int_pairs = layout.get_neighbors(stab_qubits, direction=ord_dir, as_pairs=True)
+        int_qubits = list(chain.from_iterable(int_pairs))
+        interacted_qubits.update(int_qubits)
+
+        for instruction in model.cphase(int_qubits):
+            circuit.append(instruction)
+
+    idle_qubits = qubits - set(interacted_qubits)
+    for instruction in model.idle(idle_qubits):
+        circuit.append(instruction)
+    circuit.append("TICK")
+
+    # f
+    for instruction in model.hadamard(data_qubits):
+        circuit.append(instruction)
+    for instruction in model.idle(anc_qubits):
+        circuit.append(instruction)
+    circuit.append("TICK")
+
+    # g
+    interacted_qubits = set()
+    for stab_type in stab_types:
+        stab_qubits = layout.get_qubits(role="anc", stab_type=stab_type)
+        ord_dir = int_order[stab_type][3]
+        int_pairs = layout.get_neighbors(stab_qubits, direction=ord_dir, as_pairs=True)
+        int_qubits = list(chain.from_iterable(int_pairs))
+        interacted_qubits.update(int_qubits)
+
+        for instruction in model.cphase(int_qubits):
+            circuit.append(instruction)
+
+    idle_qubits = qubits - set(interacted_qubits)
+    for instruction in model.idle(idle_qubits):
+        circuit.append(instruction)
+    circuit.append("TICK")
+
+    # h
+    directions = [int_order["x_type"][0], int_order["x_type"][3]]
+    rot_qubits = set(anc_qubits)
+    rot_qubits.update(layout.get_neighbors(x_stabs, direction=directions[0]))
+    rot_qubits.update(layout.get_neighbors(x_stabs, direction=directions[1]))
+    for instruction in model.hadamard(rot_qubits):
+        circuit.append(instruction)
+    idle_qubits = qubits - rot_qubits
+    for instruction in model.idle(idle_qubits):
+        circuit.append(instruction)
+    circuit.append("TICK")
+
+    # i
+    for instruction in model.measure(anc_qubits):
+        circuit.append(instruction)
+
+    for instruction in model.idle(data_qubits):
+        circuit.append(instruction)
+    circuit.append("TICK")
+
+    if meas_reset:
+        for instruction in model.reset(anc_qubits):
+            circuit.append(instruction)
+
+        for instruction in model.idle(data_qubits):
+            circuit.append(instruction)
+
+        circuit.append("TICK")
+
+    # detectors ordered as in the measurements
+    num_anc = len(anc_qubits)
+    if meas_comparison:
+        det_targets = []
+        for ind in range(num_anc):
+            target_inds = [ind - (comp_round + 1) * num_anc, ind - num_anc]
+            targets = [target_rec(ind) for ind in target_inds]
+            det_targets.append(targets)
+    else:
+        det_targets = [[target_rec(ind - num_anc)] for ind in range(num_anc)]
+
+    for targets in det_targets:
+        circuit.append("DETECTOR", targets)
+
+    return circuit

surface_sim/circuit_blocks/surface_code_css_pipelined.py

@@ -0,0 +1,117 @@
+from itertools import chain
+
+from stim import Circuit, target_rec
+
+from qec_util import Layout
+
+from ..models import Model
+
+# methods to have in this script
+from .util import qubit_coords, log_meas, log_x, log_z, init_qubits
+
+__all__ = ["qubit_coords", "log_meas", "log_x", "log_z", "qec_round", "init_qubits"]
+
+
+def qec_round(
+    model: Model,
+    layout: Layout,
+    meas_reset: bool = False,
+    meas_comparison: bool = True,
+) -> Circuit:
+    """
+    Returns stim circuit corresponding to a QEC cycle
+    of the given model.
+
+    Params
+    -------
+    meas_comparison
+        If True, the detector is set to the measurement of the ancilla
+        instead of to the comparison of consecutive syndromes.
+    stab_type_det
+        If specified, only adds detectors to the ancillas for the
+        specific stabilizator type.
+    """
+    data_qubits = layout.get_qubits(role="data")
+    anc_qubits = layout.get_qubits(role="anc")
+
+    qubits = set(data_qubits + anc_qubits)
+    # With reset defect[n] = m[n] XOR m[n-1]
+    # Wihtout reset defect[n] = m[n] XOR m[n-2]
+    comp_round = 1 if meas_reset else 2
+
+    circuit = Circuit()
+    int_order = layout.interaction_order
+    stab_types = list(int_order.keys())
+
+    for ind, stab_type in enumerate(stab_types):
+        stab_qubits = layout.get_qubits(role="anc", stab_type=stab_type)
+        rot_qubits = set(stab_qubits)
+        if stab_type == "x_type":
+            rot_qubits.update(data_qubits)
+
+        if not ind:
+            for instruction in model.hadamard(rot_qubits):
+                circuit.append(instruction)
+
+            idle_qubits = qubits - rot_qubits
+            for instruction in model.idle(idle_qubits):
+                circuit.append(instruction)
+            circuit.append("TICK")
+
+        for ord_dir in int_order[stab_type]:
+            int_pairs = layout.get_neighbors(
+                stab_qubits, direction=ord_dir, as_pairs=True
+            )
+            int_qubits = list(chain.from_iterable(int_pairs))
+
+            for instruction in model.cphase(int_qubits):
+                circuit.append(instruction)
+
+            idle_qubits = qubits - set(int_qubits)
+            for instruction in model.idle(idle_qubits):
+                circuit.append(instruction)
+            circuit.append("TICK")
+
+        if not ind:
+            for instruction in model.hadamard(qubits):
+                circuit.append(instruction)
+        else:
+            for instruction in model.hadamard(rot_qubits):
+                circuit.append(instruction)
+
+            idle_qubits = qubits - rot_qubits
+            for instruction in model.idle(idle_qubits):
+                circuit.append(instruction)
+
+        circuit.append("TICK")
+
+    for instruction in model.measure(anc_qubits):
+        circuit.append(instruction)
+
+    for instruction in model.idle(data_qubits):
+        circuit.append(instruction)
+    circuit.append("TICK")
+
+    if meas_reset:
+        for instruction in model.reset(anc_qubits):
+            circuit.append(instruction)
+        for instruction in model.idle(data_qubits):
+            circuit.append(instruction)
+
+        circuit.append("TICK")
+
+    # detectors ordered as in the measurements
+    num_anc = len(anc_qubits)
+    if meas_comparison:
+        det_targets = []
+        for ind in range(num_anc):
+            target_inds = [ind - (comp_round + 1) * num_anc, ind - num_anc]
+            targets = [target_rec(ind) for ind in target_inds]
+            det_targets.append(targets)
+    else:
+        det_targets = [[target_rec(ind - num_anc)] for ind in range(num_anc)]
+
+    for targets in det_targets:
+        circuit.append("DETECTOR", targets)
+
+    return circuit

surface_sim/circuit_blocks/surface_code_xzzx.py

@@ -0,0 +1,122 @@
+from itertools import chain
+
+from stim import Circuit, target_rec
+from qec_util import Layout
+
+from ..models import Model
+
+
+# methods to have in this script
+from .util import qubit_coords, log_x, log_z
+from .util import log_meas_xzzx as log_meas, init_qubits_xzzx as init_qubits
+
+__all__ = ["qubit_coords", "log_meas", "log_x", "log_z", "qec_round", "init_qubits"]
+
+
+def qec_round(
+    model: Model,
+    layout: Layout,
+    meas_reset: bool = False,
+    meas_comparison: bool = True,
+) -> Circuit:
+    """
+    Returns stim circuit corresponding to a QEC cycle
+    of the given model.
+
+    Params
+    -------
+    meas_comparison
+        If True, the detector is set to the measurement of the ancilla
+        instead of to the comparison of consecutive syndromes.
+    stab_type_det
+        If specified, only adds detectors to the ancillas for the
+        specific stabilizator type.
+    """
+    data_qubits = layout.get_qubits(role="data")
+    anc_qubits = layout.get_qubits(role="anc")
+
+    qubits = set(data_qubits + anc_qubits)
+
+    # With reset defect[n] = m[n] XOR m[n-1]
+    # Wihtout reset defect[n] = m[n] XOR m[n-2]
+    comp_round = 1 if meas_reset else 2
+
+    circuit = Circuit()
+    int_order = layout.interaction_order
+    stab_types = list(int_order.keys())
+
+    for ind, stab_type in enumerate(stab_types):
+        stab_qubits = layout.get_qubits(role="anc", stab_type=stab_type)
+
+        rot_qubits = set(stab_qubits)
+        for direction in ("north_west", "south_east"):
+            neighbors = layout.get_neighbors(stab_qubits, direction=direction)
+            rot_qubits.update(neighbors)
+
+        if not ind:
+            for instruction in model.hadamard(rot_qubits):
+                circuit.append(instruction)
+
+            idle_qubits = qubits - rot_qubits
+            for instruction in model.idle(idle_qubits):
+                circuit.append(instruction)
+            circuit.append("TICK")
+
+        for ord_dir in int_order[stab_type]:
+            int_pairs = layout.get_neighbors(
+                stab_qubits, direction=ord_dir, as_pairs=True
+            )
+            int_qubits = list(chain.from_iterable(int_pairs))
+
+            for instruction in model.cphase(int_qubits):
+                circuit.append(instruction)
+
+            idle_qubits = qubits - set(int_qubits)
+            for instruction in model.idle(idle_qubits):
+                circuit.append(instruction)
+            circuit.append("TICK")
+
+        if not ind:
+            for instruction in model.hadamard(qubits):
+                circuit.append(instruction)
+        else:
+            for instruction in model.hadamard(rot_qubits):
+                circuit.append(instruction)
+
+            idle_qubits = qubits - rot_qubits
+            for instruction in model.idle(idle_qubits):
+                circuit.append(instruction)
+
+        circuit.append("TICK")
+
+    for instruction in model.measure(anc_qubits):
+        circuit.append(instruction)
+
+    for instruction in model.idle(data_qubits):
+        circuit.append(instruction)
+    circuit.append("TICK")
+
+    if meas_reset:
+        for instruction in model.reset(anc_qubits):
+            circuit.append(instruction)
+
+        for instruction in model.idle(data_qubits):
+            circuit.append(instruction)
+
+        circuit.append("TICK")
+
+    # detectors ordered as in the measurements
+    num_anc = len(anc_qubits)
+    if meas_comparison:
+        det_targets = []
+        for ind in range(num_anc):
+            target_inds = [ind - (comp_round + 1) * num_anc, ind - num_anc]
+            targets = [target_rec(ind) for ind in target_inds]
+            det_targets.append(targets)
+    else:
+        det_targets = [[target_rec(ind - num_anc)] for ind in range(num_anc)]
+
+    for targets in det_targets:
+        circuit.append("DETECTOR", targets)
+
+    return circuit