Lightsout updates

.github/codecov.yml

@@ -1,7 +1,6 @@
 ignore:
   - "**/python"
   - "test/**/*"
-  - "src/mqt/qecc/cc_decoder/plots.py"
   - "src/mqt/qecc/analog_information_decoding/utils/data_utils.py"
   - "src/mqt/qecc/analog_information_decoding/code_construction/*"
 

pyproject.toml

@@ -56,6 +56,7 @@ dependencies = [
     "numba>=0.59; python_version > '3.11'",
     "numba>=0.57; python_version <= '3.11'",
     "pymatching>=2.2.1",
+    "stimbposd"
 ]
 dynamic = ["version"]
 
@@ -180,13 +181,17 @@ disallow_untyped_defs = false
 explicit_package_bases = true
 warn_unreachable = true
 exclude = [
+    "^plot\\_convergence\\_rate\\.ipynb$",
+    "^plot\\_pseudothresholds.\\ipnyb$",
+    "^plots\\.py$",
     "code_construction*",
-    "^data_utils\\.py$"
+    "^data_utils\\.py$",
+    "^run\\_color\\_code\\_phenomenological\\_noise\\.py$",
 ]
 
 [[tool.mypy.overrides]]
 module = ["qiskit.*", "qecsim.*", "qiskit_aer.*", "matplotlib.*", "scipy.*", "ldpc.*", "pytest_console_scripts.*",
-    "z3.*", "bposd.*", "numba.*", "pymatching.*", "stim.*", "multiprocess.*"]
+    "z3.*", "bposd.*", "numba.*", "pymatching.*", "stim.*", "multiprocess.*", "stimbposd.*", "sinter.*"]
 ignore_missing_imports = true
 
 
@@ -271,7 +276,8 @@ isort.required-imports = ["from __future__ import annotations"]
     "E402", # Allow imports to appear anywhere in Jupyter notebooks
     "I002", # Allow missing `from __future__ import annotations` import
 ]
-"*/cc_decoder/plots.py" = ["T201"]
+"*/cc_decoder/plotting/**" = ["T20"]
+"*/cc_decoder/plotting/*.ipynb" = ["T", "PTH", "FURB", "PERF", "D"]
 "scripts/*" = ["T201"]
 
 [tool.ruff.lint.pydocstyle]

scripts/cc_decoder/plotting/plot_convergence_rate.ipynb

@@ -0,0 +1,74 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import locale\n",
+    "import os\n",
+    "from collections import defaultdict\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "from matplotlib import ticker\n",
+    "\n",
+    "with open(f\"{os.getcwd()}/convergence_rate.txt\", encoding=locale.getpreferredencoding(False)) as file:\n",
+    "    content = file.read()\n",
+    "\n",
+    "convergence_rate_dict = defaultdict(lambda: defaultdict(int))\n",
+    "for line in content.split(\"\\n\"):\n",
+    "    d, per, n_converged, n_not_converged = line.split(\" \")[:]\n",
+    "    convergence_rate_dict[d][round(float(per), 5)] = (int(n_converged), int(n_not_converged))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for d in convergence_rate_dict:\n",
+    "    pers = []\n",
+    "    convergence_rates = []\n",
+    "    for per in convergence_rate_dict[d]:\n",
+    "        pers.append(per)\n",
+    "    pers.sort()\n",
+    "\n",
+    "    for per in pers:\n",
+    "        n_converged, n_not_converged = convergence_rate_dict[d][per]\n",
+    "        convergence_rates.append(n_converged / (n_converged + n_not_converged))\n",
+    "    plt.plot(pers, convergence_rates, label=f\"d={d}\")\n",
+    "\n",
+    "ax = plt.gca()\n",
+    "ax.xaxis.set_major_locator(ticker.MaxNLocator(nbins=10))\n",
+    "ax.grid()\n",
+    "\n",
+    "plt.legend()\n",
+    "plt.ylabel(\"Convergence rate\")\n",
+    "plt.xlabel(\"Physical error rate\")\n",
+    "plt.savefig(\"convergence.svg\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

scripts/cc_decoder/plotting/plot_pseudothresholds.ipynb

@@ -0,0 +1,143 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import sinter\n",
+    "\n",
+    "samples = sinter.read_stats_from_csv_files(f\"{os.getcwd()}/pseudothreshold_plot.csv\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Render a matplotlib plot of the data.\n",
+    "fig, ax = plt.subplots(1, 1)\n",
+    "sinter.plot_error_rate(\n",
+    "    ax=ax,\n",
+    "    stats=samples,\n",
+    "    group_func=lambda stat: f\"d={stat.json_metadata['d']}, {stat.decoder}\",\n",
+    "    x_func=lambda stat: stat.json_metadata[\"p\"],\n",
+    "    failure_units_per_shot_func=lambda stats: stats.json_metadata[\"rounds\"],\n",
+    "    filter_func=lambda stat: stat.json_metadata[\"d\"] < 5,\n",
+    ")\n",
+    "x_s = np.linspace(0.001, 0.029, 1000000)\n",
+    "y_s = np.linspace(0.001, 0.029, 1000000)\n",
+    "ax.set_yscale(\"log\")\n",
+    "ax.plot(x_s, y_s, \"k-\", alpha=0.75, zorder=0, label=\"x=y\")\n",
+    "ax.grid()\n",
+    "ax.set_title(\"Phenomenological Noise\")\n",
+    "ax.set_ylabel(\"Logical Error Probability (per shot)\")\n",
+    "ax.set_xlabel(\"Physical Error Rate\")\n",
+    "ax.legend(loc=\"lower right\")\n",
+    "fig.savefig(\"pseudoth.svg\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Render a matplotlib plot of the data.\n",
+    "fig, ax = plt.subplots(1, 1)\n",
+    "sinter.plot_error_rate(\n",
+    "    ax=ax,\n",
+    "    stats=samples,\n",
+    "    group_func=lambda stat: f\"d={stat.json_metadata['d']}, {stat.decoder}\",\n",
+    "    x_func=lambda stat: stat.json_metadata[\"p\"],\n",
+    "    failure_units_per_shot_func=lambda stats: stats.json_metadata[\"rounds\"],\n",
+    "    filter_func=lambda stat: stat.json_metadata[\"d\"] > 4,\n",
+    ")\n",
+    "x_s = np.linspace(0.001, 0.029, 1000000)\n",
+    "y_s = np.linspace(0.001, 0.029, 1000000)\n",
+    "ax.set_yscale(\"log\")\n",
+    "ax.plot(x_s, y_s, \"k-\", alpha=0.75, zorder=0, label=\"x=y\")\n",
+    "ax.grid()\n",
+    "ax.set_title(\"Phenomenological Noise\")\n",
+    "ax.set_ylabel(\"Logical Error Probability (per shot)\")\n",
+    "ax.set_xlabel(\"Physical Error Rate\")\n",
+    "ax.set_ylim(0.00001, 1)\n",
+    "ax.legend(loc=\"lower right\")\n",
+    "fig.savefig(\"no-pseudoth.svg\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Render a matplotlib plot of the data.\n",
+    "fig, ax = plt.subplots(1, 2, sharey=True, figsize=(12, 5))\n",
+    "sinter.plot_error_rate(\n",
+    "    ax=ax[0],\n",
+    "    stats=samples,\n",
+    "    group_func=lambda stat: f\"d={stat.json_metadata['d']}, {stat.decoder}\",\n",
+    "    x_func=lambda stat: stat.json_metadata[\"p\"],\n",
+    "    failure_units_per_shot_func=lambda stats: stats.json_metadata[\"rounds\"],\n",
+    "    filter_func=lambda stat: stat.json_metadata[\"d\"] < 5,\n",
+    ")\n",
+    "x_s = np.linspace(0.001, 0.029, 1000000)\n",
+    "y_s = np.linspace(0.001, 0.029, 1000000)\n",
+    "ax[0].set_yscale(\"log\")\n",
+    "ax[0].plot(x_s, y_s, \"k-\", alpha=0.75, zorder=0, label=\"x=y\")\n",
+    "ax[0].grid()\n",
+    "ax[0].set_ylabel(\"Logical Error Probability (per shot)\")\n",
+    "ax[0].set_xlabel(\"Physical Error Rate\")\n",
+    "ax[0].legend(loc=\"lower right\")\n",
+    "\n",
+    "# Render a matplotlib plot of the data.\n",
+    "sinter.plot_error_rate(\n",
+    "    ax=ax[1],\n",
+    "    stats=samples,\n",
+    "    group_func=lambda stat: f\"d={stat.json_metadata['d']}, {stat.decoder}\",\n",
+    "    x_func=lambda stat: stat.json_metadata[\"p\"],\n",
+    "    failure_units_per_shot_func=lambda stats: stats.json_metadata[\"rounds\"],\n",
+    "    filter_func=lambda stat: stat.json_metadata[\"d\"] > 4,\n",
+    ")\n",
+    "x_s = np.linspace(0.001, 0.029, 1000000)\n",
+    "y_s = np.linspace(0.001, 0.029, 1000000)\n",
+    "ax[1].set_yscale(\"log\")\n",
+    "ax[1].plot(x_s, y_s, \"k-\", alpha=0.75, zorder=0, label=\"x=y\")\n",
+    "ax[1].grid()\n",
+    "# ax[1].set_ylabel('Logical Error Probability (per shot)')\n",
+    "ax[1].set_xlabel(\"Physical Error Rate\")\n",
+    "ax[1].set_ylim(0.00001, 1)\n",
+    "ax[1].legend(loc=\"lower right\")\n",
+    "\n",
+    "fig.savefig(\"pseudoth.svg\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

src/mqt/qecc/cc_decoder/plots.py → scripts/cc_decoder/plotting/plots.py

@@ -82,7 +82,6 @@ def calculate_threshold(
     popt, _ = curve_fit(threshold_fit, (per_data, distance_data), ler_data, maxfev=10000)
     if ax is not None:
         ax.axvline(x=popt[-1], color="black", linestyle="dashed")
-        print("threshold: ", popt[-1])
 
     distance_array = [int(distance) for distance in code_dict]
     distance_array.sort()
@@ -198,23 +197,23 @@ def generate_plots(results_dir: Path, results_file: Path) -> None:
 
 
 def generate_plots_tn(results_dir: Path, results_file: Path) -> None:
-    """Generate the plots for the tensor network decoder."""
+    """Generate plots for TN decoder."""
     # read in all generated data
     data = []
     for file in results_dir.glob("*.json"):
         with file.open() as f:
             data.append(json.loads(f.read()))
 
     # prepare code to per,ler map and print
-    code_to_xys: dict[float, Any] = {}
+    code_to_xys = {}  # type: ignore[var-annotated]
     for run in data:
         xys = code_to_xys.setdefault(run["n_k_d"][-1], [])
         xys.append((run["physical_error_rate"], run["logical_failure_rate"]))
 
     for xys in code_to_xys.values():
         xys.sort(key=operator.itemgetter(0))
 
-    _, ax = plt.subplots(2, 2, figsize=(12, 10))
+    _fig, ax = plt.subplots(2, 2, figsize=(12, 10))
     # add data
     for code, xys in sorted(code_to_xys.items()):
         ax[0][0].plot(*zip(*xys), "x-", label=f"d={code}")
@@ -235,31 +234,55 @@ def generate_plots_tn(results_dir: Path, results_file: Path) -> None:
     for code, xys in sorted(code_to_xys.items()):
         ax[1][0].plot(*zip(*xys), "x-", label=f"d={code}")
     ax[1][0].set_xlabel("Physical error rate")
-    ax[1][0].set_ylabel("Average time per run (microseconds)")
+    ax[1][0].set_ylabel("Average time per run (µs)")  # noqa: RUF001
     ax[1][0].legend()
     ax[1][0].set_ylim(0, 300000)
 
     ds = []
-    p_data: dict[float, Any] = {}
-    pers = [0.001, 0.021, 0.051, 0.081, 0.111]
-    for d, cdata in sorted(code_to_xys.items()):
+    p_data = {}  # type: ignore[var-annotated]
+    pers = [0.051, 0.081, 0.111]  # 0.001, 0.021,
+    for d, data in sorted(code_to_xys.items()):
         ds.append(d)
-        for p, t in cdata:
+        for p, t in data:
             if p in pers:
                 if p not in p_data:
                     p_data[p] = {"d": [], "t": []}
                 p_data[p]["d"].append(d)
                 p_data[p]["t"].append(t)
-    for p, pdata in sorted(p_data.items()):
-        ax[1][1].plot(ds, pdata["t"], label="p=" + str(p))
+
+    for p, data in sorted(p_data.items()):
+        ax[1][1].plot(ds, data["t"], label="p=" + str(p))  # type: ignore[call-overload]
 
     ax[1][1].set_xlabel("Distance")
-    ax[1][1].set_ylabel("Average time per run (microseconds)")
+    ax[1][1].set_ylabel("Average time per run (µs)")  # noqa: RUF001
     ax[1][1].legend()
-    # ax[1][1].set_yscale("log")
+    ax[1][1].set_yscale("log")
     ax[1][1].set_xticks(ds)
     ax[1][1].set_ylim(0, 300000)
+
+    data = []
+    for file in results_dir.glob("*.json"):
+        with file.open() as f:
+            data.append(json.loads(f.read()))
+    metrics = {}  # type: ignore[var-annotated]
+    per_metrics = {}  # type: ignore[var-annotated]
+
     # save plot as vector graphic
+    for result in data:
+        d = result["n_k_d"][2]
+        p = result["physical_error_rate"]
+
+        if d not in metrics:
+            metrics[d] = {
+                "p": [],
+                "logical_error_rate": [],
+            }
+        if p not in per_metrics:
+            per_metrics[p] = {}
+
+        metrics[d]["p"].append(p)
+        metrics[d]["logical_error_rate"].append(result["logical_failure_rate"])
+    calculate_threshold(code_dict=metrics, ax=ax[0][1], title="Threshold")
     plt.savefig(results_file, bbox_inches="tight")