Steane Encoding

This notebook demonstrates the construction and simulation of a logical Steane encoder circuit. Steane code was introduced in [Steane[1]]. In surface code, this logical circuit can be used to prepare the magic state for logical S gate [Fowler et al.[2]].

Construction

tqec provides builtin functions tqec.gallery.steane_encoding to construct it.

from tqec.gallery.steane_encoding import steane_encoding

graph = steane_encoding()
graph.view_as_html()

We can use the find_correlation_surfaces() method to identify all correlation surfaces, and then visualize them using the view_as_html() method. In this case, there are a total of seven correlation surfaces. For simplicity, only two are shown here.

correlation_surfaces = graph.find_correlation_surfaces()
len(correlation_surfaces)

7

graph.view_as_html(
    pop_faces_at_direction="-Y",
    show_correlation_surface=correlation_surfaces[0],
)

graph.view_as_html(
    pop_faces_at_direction="-Y",
    show_correlation_surface=correlation_surfaces[1],
)

Circuit

Here we show an example circuit of Steane encoding circuit with \(d=3\) that is initialized and measured in X basis. The circuit can be downloaded here or viewed in Crumble.

from tqec import Basis, NoiseModel, compile_block_graph

graph = steane_encoding(Basis.X)
compiled_graph = compile_block_graph(graph)
circuit = compiled_graph.generate_stim_circuit(
    k=1, noise_model=NoiseModel.uniform_depolarizing(p=0.001)
)

Simulation

Here we show the simulation results for all the seven observables under uniform depolarizing noise model.

Click to show the full code used for simulation

from multiprocessing import cpu_count
from pathlib import Path

import matplotlib.pyplot as plt
import numpy
import sinter

from tqec.gallery import steane_encoding
from tqec import NoiseModel
from tqec.simulation.plotting.inset import plot_observable_as_inset
from tqec.simulation.simulation import start_simulation_using_sinter
from tqec.utils.enums import Basis

SAVE_DIR = Path("results")


def generate_graphs(support_observable_basis: Basis) -> None:
    block_graph = steane_encoding(support_observable_basis)
    zx_graph = block_graph.to_zx_graph()

    correlation_surfaces = block_graph.find_correlation_surfaces()

    # Start simulation using sinter, note that the `save_resume_filepath` is useful
    # when simulation takes a long time.
    # If the Python interpreter is stopped or killed, calling this method again with
    # the same file path will load the previous results and resume from where it left off.
    stats = start_simulation_using_sinter(
        block_graph,
        range(1, 4),
        list(numpy.logspace(-4, -1, 10)),
        NoiseModel.uniform_depolarizing,
        manhattan_radius=2,
        observables=correlation_surfaces,
        num_workers=cpu_count(),
        max_shots=1_000_000,
        max_errors=5_000,
        decoders=["pymatching"],
        print_progress=True,
        # note that save_resume_filepath and database_path can help reduce the time taken
        # by the simulation after the database and result statistics have been saved to
        # the chosen path
        save_resume_filepath=Path(
            f"../_examples_database/steane_stats_{support_observable_basis.value}.csv"
        ),
        database_path=Path("../_examples_database/database.pkl"),
    )

    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"],
            failure_units_per_shot_func=lambda stat: stat.json_metadata["d"],
            group_func=lambda stat: stat.json_metadata["d"],
        )
        plot_observable_as_inset(ax, zx_graph, correlation_surfaces[i])
        ax.grid(axis="both")
        ax.legend()
        ax.loglog()
        ax.set_title("Steane Encoding Error Rate")
        ax.set_xlabel("Physical Error Rate")
        ax.set_ylabel("Logical Error Rate(per round)")
        fig.savefig(
            SAVE_DIR
            / f"steane_encoding_result_{support_observable_basis}_observable_{i}.png"
        )


def main():
    SAVE_DIR.mkdir(exist_ok=True)
    generate_graphs(Basis.X)
    generate_graphs(Basis.Z)


if __name__ == "__main__":
    main()

Z Basis

generate_graphs(Basis.Z)

X Basis

generate_graphs(Basis.X)

References

[1]

Andrew Steane. Multiple particle interference and quantum error correction. Proceedings of the Royal Society of London. Series A: Mathematical, Physical and Engineering Sciences, 452(1954):2551–2577, November 1996. URL: http://dx.doi.org/10.1098/rspa.1996.0136, doi:10.1098/rspa.1996.0136.

[2]

Austin G. Fowler, Matteo Mariantoni, John M. Martinis, and Andrew N. Cleland. Surface codes: towards practical large-scale quantum computation. Physical Review A, September 2012. URL: http://dx.doi.org/10.1103/PhysRevA.86.032324, doi:10.1103/physreva.86.032324.