Repository: oscarhiggott/PyMatching (language: python)

Issue:
Reading b8 shot data wrong on windows (bump C++ stim dep version to 1.10)
One of the bugs fixed in stim 1.10 was that files were being opened in text mode, instead of binary mode, resulting in automatic conversion between \n and \r\n on windows. This of course completely mangles binary data, such as b8 format shot data.

Pymatching's C++ extension currently depends on stim 1.9, so it has this bug. For example, if you install the latest stim+sinter+pymatching and try to collect stats on windows, you pretty quickly run into "data has wrong size" errors.


Discussion / hints:

Fix patch:
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index e451341d..62909aa5 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -246,21 +246,21 @@ jobs:
         run: pytest tests --cov=./src/pymatching --cov-report=xml
       - name: Upload coverage reports to Codecov
         uses: codecov/codecov-action@v3
-  upload_all:
-    name: Upload to pypi
-    needs: [build_wheels, build_sdist]
-    runs-on: ubuntu-latest
-    if: github.event_name == 'push' && startsWith(github.event.ref, 'refs/tags/v')
-    steps:
-      - uses: actions/setup-python@v4
-        with:
-          python-version: "3.9"
-
-      - uses: actions/download-artifact@v3
-        with:
-          name: artifact
-          path: dist
-
-      - uses: pypa/gh-action-pypi-publish@v1.5.1
-        with:
-          password: ${{ secrets.pypi_password }}
+#  upload_all:
+#    name: Upload to pypi
+#    needs: [build_wheels, build_sdist]
+#    runs-on: ubuntu-latest
+#    if: github.event_name == 'push' && startsWith(github.event.ref, 'refs/tags/v')
+#    steps:
+#      - uses: actions/setup-python@v4
+#        with:
+#          python-version: "3.9"
+#
+#      - uses: actions/download-artifact@v3
+#        with:
+#          name: artifact
+#          path: dist
+#
+#      - uses: pypa/gh-action-pypi-publish@v1.5.1
+#        with:
+#          password: ${{ secrets.pypi_password }}
diff --git a/CMakeLists.txt b/CMakeLists.txt
index e7c80a22..3afa5051 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -24,7 +24,7 @@ FetchContent_MakeAvailable(googletest)
 
 FetchContent_Declare(stim
         GIT_REPOSITORY https://github.com/quantumlib/stim.git
-        GIT_TAG v1.9.0)
+        GIT_TAG v1.10.0)
 FetchContent_GetProperties(stim)
 if (NOT stim_POPULATED)
     FetchContent_Populate(stim)
diff --git a/README.md b/README.md
index 2dd46ffb..a58941e7 100644
--- a/README.md
+++ b/README.md
@@ -41,9 +41,8 @@ The new version is also exact - unlike previous versions of PyMatching, no appro
 
 Our new implementation is **over 100x faster** than previous versions of PyMatching, and is 
 **over 100,000x faster** than NetworkX (benchmarked with surface code circuits). At 0.1% circuit-noise, PyMatching can 
-decode both X and Z basis measurements of surface code circuits up to distance 13 in under 1 microsecond per round 
-of syndrome extraction on a single core (or up to distance 19 if only X-basis measurements are processed - however 
-both X and Z basis measurements must be decoded at scale). Furthermore, the runtime is roughly linear in the number 
+decode both X and Z basis measurements of surface code circuits up to distance 17 in under 1 microsecond per round 
+of syndrome extraction on a single core. Furthermore, the runtime is roughly linear in the number 
 of nodes in the graph.
 
 The plot below compares the performance of PyMatching v2 with the previous 
@@ -127,12 +126,10 @@ Now we can decode! We compare PyMatching's predictions of the logical observable
 with stim, in order to count the number of mistakes and estimate the logical error rate:
 
 ```python
-num_errors = 0
-for i in range(syndrome.shape[0]):
-    predicted_observables = matching.decode(syndrome[i, :])
-    num_errors += not np.array_equal(actual_observables[i, :], predicted_observables)
+predicted_observables = matching.decode_batch(syndrome)
+num_errors = np.sum(np.any(predicted_observables != actual_observables, axis=1))
 
-print(num_errors)  # prints 8
+print(num_errors)  # prints 5
 ```
 
 ### Loading from a parity check matrix
diff --git a/benchmarks/surface_codes/README.md b/benchmarks/surface_codes/README.md
index e73f351f..410a6e06 100644
--- a/benchmarks/surface_codes/README.md
+++ b/benchmarks/surface_codes/README.md
@@ -24,12 +24,38 @@ for a given error rate `p` and code distance `distance` in `{5, 7, 9, 13, 17, 23
 From a stim circuit `circuit`, the corresponding `stim.DetectorErrorModel` used to configure the decoder can be 
 generated using `circuit.detector_error_model(decompose_errors=True)`.
 
-Then, using stim to generate some samples in b8 format (in this case with appended observables), the time per shot 
-in microseconds for pymatching 2 was measured (on an M1 Max processor) using the pymatching command line tool, where here 
-`$samples_fn` is the filename of the b8 samples file and `$dem_fn` is the filename of the detector error model:
 
-```shell
-pymatching count_mistakes --in $samples_fn --in_format b8 --dem $dem_fn --in_includes_appended_observables --time 2>&1 >/dev/null | sed -n -E 's/Decoding time per shot: (.+)us/\1/p' 
+Then, using stim to generate some samples, the time per shot 
+in microseconds for pymatching 2 was measured (on an M1 Max processor) by running `pymatching.Matching.decode_batch` on 
+at least 10000 shots. For example, the number of microseconds per shot can be measured using the following function:
+```python
+import time
+import stim
+import pymatching
+
+
+def time_surface_code_circuit(distance: int, p: float, num_shots: int = 10000) -> float:
+    circuit = stim.Circuit.generated(
+        "surface_code:rotated_memory_x",
+        distance=distance,
+        rounds=distance,
+        after_clifford_depolarization=p,
+        before_round_data_depolarization=p,
+        before_measure_flip_probability=p,
+        after_reset_flip_probability=p
+    )
+    dem = circuit.detector_error_model(decompose_errors=True)
+    matching = pymatching.Matching.from_detector_error_model(dem)
+    sampler = circuit.compile_detector_sampler()
+    shots, actual_observables = sampler.sample(shots=num_shots, separate_observables=True)
+    # Decode one shot first to ensure internal C++ representation of the matching graph is fully cached
+    matching.decode_batch(shots[0:1, :])
+    # Now time decoding the batch
+    t0 = time.time()
+    matching.decode_batch(shots)
+    t1 = time.time()
+    microseconds_per_shot = 1e6*(t1-t0)/num_shots
+    return microseconds_per_shot
 ```
 
 In the figure in each subdirectory, 
@@ -46,3 +72,12 @@ must be done by the decoder within the wider context of a fault-tolerant quantum
 where the basis of the logical measurement is not always known apriori (both X and Z logical operators must be 
 preserved) and the X and Z matching graphs can become connected (such as when implementing a logical S gate in the 
 surface code by [braiding twist defects](https://arxiv.org/abs/1609.04673)).
+
+If you've looked at the benchmarks in this repository before, you may have noticed that there have been two previous 
+versions of the data. In the first version, 
+only the X basis was decoded, which did not fully represent the work required to decode a surface code at scale, 
+as described above. In the second version, both bases were decoded (and since the problems became 2x bigger, 
+the time per round also doubled). However, for both the first and second versions, the timing data was collected by 
+decoding shot data from file using the pymatching command line interface. At low p (e.g. around 0.1%), it turned out 
+that almost half the time was spent reading the shot data from file. So in the current version the shot data is 
+decoded in a batch from memory (see above), with both bases still decoded.
diff --git a/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.001_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v0.7_vs_pymatching_v2_vs_networkx_timing_p=0.001_per_round_both_bases_decoded.pdf b/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.001_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v0.7_vs_pymatching_v2_vs_networkx_timing_p=0.001_per_round_both_bases_decoded.pdf
index 1f189a3a..3b5f34a9 100644
Binary files a/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.001_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v0.7_vs_pymatching_v2_vs_networkx_timing_p=0.001_per_round_both_bases_decoded.pdf and b/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.001_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v0.7_vs_pymatching_v2_vs_networkx_timing_p=0.001_per_round_both_bases_decoded.pdf differ
diff --git a/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.001_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v0.7_vs_pymatching_v2_vs_networkx_timing_p=0.001_per_round_both_bases_decoded.png b/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.001_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v0.7_vs_pymatching_v2_vs_networkx_timing_p=0.001_per_round_both_bases_decoded.png
index d05fd1af..33b0f53d 100644
Binary files a/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.001_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v0.7_vs_pymatching_v2_vs_networkx_timing_p=0.001_per_round_both_bases_decoded.png and b/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.001_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v0.7_vs_pymatching_v2_vs_networkx_timing_p=0.001_per_round_both_bases_decoded.png differ
diff --git a/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.001_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v2.csv b/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.001_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v2.csv
index 9d81677b..3bfb1ed4 100644
--- a/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.001_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v2.csv
+++ b/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.001_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v2.csv
@@ -1,10 +1,10 @@
 d,p,microseconds
-5, 0.001,0.7137
-7, 0.001,1.8224
-9, 0.001,3.9624
-13, 0.001,11.7847
-17, 0.001,25.6879
-23, 0.001,68.0293
-29, 0.001,150.337
-39, 0.001,436.855
-50, 0.001,1060.09
+5, 0.001,0.388141
+7, 0.001,1.05477
+9, 0.001,2.31456
+13, 0.001,6.96616
+17, 0.001,16.0062
+23, 0.001,45.1341
+29, 0.001,102.495
+39, 0.001,310.649
+50, 0.001,778.247
diff --git a/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.005_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v0.7_vs_pymatching_v2_vs_networkx_timing_p=0.005_per_round_both_bases.pdf b/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.005_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v0.7_vs_pymatching_v2_vs_networkx_timing_p=0.005_per_round_both_bases.pdf
index 97fb9a3d..3361a0f3 100644
Binary files a/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.005_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v0.7_vs_pymatching_v2_vs_networkx_timing_p=0.005_per_round_both_bases.pdf and b/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.005_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v0.7_vs_pymatching_v2_vs_networkx_timing_p=0.005_per_round_both_bases.pdf differ
diff --git a/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.005_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v2.csv b/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.005_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v2.csv
index 31865557..0cf5cba2 100644
--- a/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.005_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v2.csv
+++ b/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.005_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v2.csv
@@ -1,10 +1,10 @@
 d,p,microseconds
-5, 0.005,3.1209
-7, 0.005,7.2927
-9, 0.005,16.3826
-13, 0.005,56.8005
-17, 0.005,146.022
-23, 0.005,391.382
-29, 0.005,878.586
-39, 0.005,2687.91
-50, 0.005,7183.41
+5, 0.005,1.83938
+7, 0.005,6.13618
+9, 0.005,14.5596
+13, 0.005,50.9597
+17, 0.005,125.17
+23, 0.005,338.516
+29, 0.005,718.097
+39, 0.005,2349.41
+50, 0.005,6834.5
diff --git a/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.008_1_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v0.7_vs_pymatching_v2_vs_networkx_timing_p=0.008_per_round_both_bases.pdf b/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.008_1_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v0.7_vs_pymatching_v2_vs_networkx_timing_p=0.008_per_round_both_bases.pdf
index 171715c6..9ac91949 100644
Binary files a/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.008_1_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v0.7_vs_pymatching_v2_vs_networkx_timing_p=0.008_per_round_both_bases.pdf and b/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.008_1_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v0.7_vs_pymatching_v2_vs_networkx_timing_p=0.008_per_round_both_bases.pdf differ
diff --git a/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.008_1_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v2.csv b/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.008_1_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v2.csv
index 75f9d066..6a6b12c6 100644
--- a/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.008_1_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v2.csv
+++ b/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.008_1_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v2.csv
@@ -1,10 +1,10 @@
 d,p,microseconds
-5, 0.008,4.8573
-7, 0.008,12.9679
-9, 0.008,33.1905
-13, 0.008,128.431
-17, 0.008,337.928
-23, 0.008,947.958
-29, 0.008,2268.38
-39, 0.008,7801.89
-50, 0.008,24642.2
+5, 0.008,6.84748
+7, 0.008,13.299
+9, 0.008,30.117
+13, 0.008,117.831
+17, 0.008,317.935
+23, 0.008,935.859
+29, 0.008,2185.42
+39, 0.008,7447.51
+50, 0.008,23116.7
diff --git a/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.01_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v0.7_vs_pymatching_v2_vs_networkx_timing_p=0.01_per_round_both_bases.pdf b/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.01_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v0.7_vs_pymatching_v2_vs_networkx_timing_p=0.01_per_round_both_bases.pdf
index 58687338..4124435e 100644
Binary files a/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.01_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v0.7_vs_pymatching_v2_vs_networkx_timing_p=0.01_per_round_both_bases.pdf and b/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.01_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v0.7_vs_pymatching_v2_vs_networkx_timing_p=0.01_per_round_both_bases.pdf differ
diff --git a/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.01_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v2.csv b/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.01_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v2.csv
index 0f217043..01f6e08a 100644
--- a/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.01_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v2.csv
+++ b/benchmarks/surface_codes/surface_code_rotated_memory_x_p_0.01_d_5_7_9_13_17_23_29_39_50_both_bases/pymatching_v2.csv
@@ -1,10 +1,6 @@
-d,p,microseconds
-5, 0.01,5.4227
-7, 0.01,17.2281
-9, 0.01,44.5062
-13, 0.01,185.097
-17, 0.01,504.902
-23, 0.01,1483.5
-29, 0.01,3549.17
-39, 0.01,12820.4
-50, 0.01,40346.1
+5, 0.01,9.1722
+7, 0.01,17.3477
+9, 0.01,42.1067
+13, 0.01,171.797
+17, 0.01,469.216
+23, 0.01,1460.07
diff --git a/data/three_errors.b8 b/data/three_errors.b8
new file mode 100644
index 00000000..eaf36c1d
Binary files /dev/null and b/data/three_errors.b8 differ
diff --git a/docs/toric-code-example.ipynb b/docs/toric-code-example.ipynb
index 84285c58..c9ccf51b 100644
--- a/docs/toric-code-example.ipynb
+++ b/docs/toric-code-example.ipynb
@@ -40,7 +40,7 @@
    "source": [
     "import numpy as np\n",
     "import matplotlib.pyplot as plt\n",
-    "from scipy.sparse import hstack, kron, eye, csr_matrix, block_diag\n",
+    "from scipy.sparse import hstack, kron, eye, csc_matrix, block_diag\n",
     "\n",
     "\n",
     "def repetition_code(n):\n",
@@ -49,7 +49,7 @@
     "    \"\"\"\n",
     "    row_ind, col_ind = zip(*((i, j) for i in range(n) for j in (i, (i+1)%n)))\n",
     "    data = np.ones(2*n, dtype=np.uint8)\n",
-    "    return csr_matrix((data, (row_ind, col_ind)))\n",
+    "    return csc_matrix((data, (row_ind, col_ind)))\n",
     "\n",
     "\n",
     "def toric_code_x_stabilisers(L):\n",
@@ -65,7 +65,7 @@
     "        )\n",
     "    H.data = H.data % 2\n",
     "    H.eliminate_zeros()\n",
-    "    return csr_matrix(H)"
+    "    return csc_matrix(H)"
    ]
   },
   {
@@ -96,12 +96,12 @@
     "    homology groups of the repetition codes using the Kunneth \n",
     "    theorem.\n",
     "    \"\"\"\n",
-    "    H1 = csr_matrix(([1], ([0],[0])), shape=(1,L), dtype=np.uint8)\n",
-    "    H0 = csr_matrix(np.ones((1, L), dtype=np.uint8))\n",
+    "    H1 = csc_matrix(([1], ([0],[0])), shape=(1,L), dtype=np.uint8)\n",
+    "    H0 = csc_matrix(np.ones((1, L), dtype=np.uint8))\n",
     "    x_logicals = block_diag([kron(H1, H0), kron(H0, H1)])\n",
     "    x_logicals.data = x_logicals.data % 2\n",
     "    x_logicals.eliminate_zeros()\n",
-    "    return csr_matrix(x_logicals)"
+    "    return csc_matrix(x_logicals)"
    ]
   },
   {
@@ -117,7 +117,7 @@
     "```\n",
     "Constructing the Matching object, while efficient, is often slower than the decoding step itself. As a result, it's best to construct the Matching object only at the beginning of the experiment, and not before every use of the decoder, in order to obtain the best performance.\n",
     "\n",
-    "We also choose a number of trials, `num_trials`.  For each trial, we simulate a $Z$ error under an independent noise model, in which each qubit independently suffers a $Z$ error with probability $p$:\n",
+    "We also choose a number of trials, `num_shots`.  For each trial, we simulate a $Z$ error under an independent noise model, in which each qubit independently suffers a $Z$ error with probability $p$:\n",
     "```\n",
     "noise = np.random.binomial(1, p, H.shape[1])\n",
     "```\n",
@@ -142,12 +142,12 @@
     "The actual logicals that were flipped are:\n",
     "\n",
     "```\n",
-    "actual_logicals_flipped = logicals@prediction % 2\n",
+    "actual_logicals_flipped = logicals@noise % 2\n",
     "```\n",
     "\n",
     "Our decoder was successful if `actual_logical_observables` equals `predicted_logical_observables`.\n",
     "\n",
-    "Taken together, we obtain the following function `num_decoding_failures` that returns the number of logical errors after `num_trials` Monte Carlo trials, simulating an independent error model with error probability `p`, with the $X$ stabiliser check matrix `H` and $X$ logical matrix `logicals`:"
+    "Taken together, we obtain the following function `num_decoding_failures` that returns the number of logical errors after `num_shots` Monte Carlo trials, simulating an independent error model with error probability `p`, with the $X$ stabiliser check matrix `H` and $X$ logical matrix `logicals`:"
    ]
   },
   {
@@ -158,11 +158,11 @@
    "source": [
     "from pymatching import Matching\n",
     "\n",
-    "def num_decoding_failures_via_physical_frame_changes(H, logicals, p, num_trials):\n",
-    "    matching = Matching.from_check_matrix(H, weights=np.log((1-p)/p))\n",
+    "def num_decoding_failures_via_physical_frame_changes(H, logicals, error_probability, num_shots):\n",
+    "    matching = Matching.from_check_matrix(H, weights=np.log((1-error_probability)/error_probability))\n",
     "    num_errors = 0\n",
-    "    for i in range(num_trials):\n",
-    "        noise = np.random.binomial(1, p, H.shape[1])\n",
+    "    for i in range(num_shots):\n",
+    "        noise = (np.random.random(H.shape[1]) < error_probability).astype(np.uint8)\n",
     "        syndrome = H@noise % 2\n",
     "        prediction = matching.decode(syndrome)\n",
     "        predicted_logicals_flipped = logicals@prediction % 2\n",
@@ -187,11 +187,11 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "def num_decoding_failures(H, logicals, p, num_trials):\n",
+    "def num_decoding_failures(H, logicals, p, num_shots):\n",
     "    matching = Matching.from_check_matrix(H, weights=np.log((1-p)/p), faults_matrix=logicals)\n",
     "    num_errors = 0\n",
-    "    for i in range(num_trials):\n",
-    "        noise = np.random.binomial(1, p, H.shape[1])\n",
+    "    for i in range(num_shots):\n",
+    "        noise = (np.random.random(H.shape[1]) < p).astype(np.uint8)\n",
     "        syndrome = H@noise % 2\n",
     "        predicted_logicals_flipped = matching.decode(syndrome)\n",
     "        actual_logicals_flipped = logicals@noise % 2\n",
@@ -204,13 +204,36 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Using this function, we can now estimate the threshold of the toric code by varying the error rate $p$, for a range of lattice sizes $L$:"
+    "We can optimise the code a bit further by vectorising over the shots, using the `Matching.decode_batch` method. This method takes in a binary numpy array with dimensions (num_shots, syndrome_length), where syndrome_length should be large enough to include all detector nodes, and be no larger than the number of nodes (including boundary nodes). By vectorising, the iteration over shots is done in C++ rather than Python, which can be significantly faster when the decoding problem itself is easy."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 5,
    "metadata": {},
+   "outputs": [],
+   "source": [
+    "def num_decoding_failures_vectorised(H, logicals, error_probability, num_shots):\n",
+    "    matching = Matching.from_check_matrix(H, weights=np.log((1-p)/p), faults_matrix=logicals)\n",
+    "    noise = (np.random.random((num_shots, H.shape[1])) < error_probability).astype(np.uint8)\n",
+    "    shots = (noise @ H.T) % 2\n",
+    "    actual_observables = (noise @ logicals.T) % 2\n",
+    "    predicted_observables = matching.decode_batch(shots)\n",
+    "    num_errors = np.sum(np.any(predicted_observables != actual_observables, axis=1))\n",
+    "    return num_errors"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Using this function, we can now estimate the threshold of the toric code by varying the error rate $p$, for a range of lattice sizes $L$:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -219,15 +242,15 @@
       "Simulating L=4...\n",
       "Simulating L=8...\n",
       "Simulating L=12...\n",
-      "CPU times: user 3.56 s, sys: 15 ms, total: 3.57 s\n",
-      "Wall time: 3.57 s\n"
+      "CPU times: user 1.41 s, sys: 19.8 ms, total: 1.43 s\n",
+      "Wall time: 1.43 s\n"
      ]
     }
    ],
    "source": [
     "%%time\n",
     "\n",
-    "num_trials = 3000\n",
+    "num_shots = 5000\n",
     "Ls = range(4,14,4)\n",
     "ps = np.linspace(0.01, 0.2, 9)\n",
     "np.random.seed(2)\n",
@@ -238,8 +261,8 @@
     "    logX = toric_code_x_logicals(L)\n",
     "    log_errors = []\n",
     "    for p in ps:\n",
-    "        num_errors = num_decoding_failures(Hx, logX, p, num_trials)\n",
-    "        log_errors.append(num_errors/num_trials)\n",
+    "        num_errors = num_decoding_failures_vectorised(Hx, logX, p, num_shots)\n",
+    "        log_errors.append(num_errors/num_shots)\n",
     "    log_errors_all_L.append(np.array(log_errors))"
    ]
   },
@@ -252,19 +275,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<Figure size 640x480 with 1 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
@@ -273,7 +294,7 @@
     "\n",
     "plt.figure()\n",
     "for L, logical_errors in zip(Ls, log_errors_all_L):\n",
-    "    std_err = (logical_errors*(1-logical_errors)/num_trials)**0.5\n",
+    "    std_err = (logical_errors*(1-logical_errors)/num_shots)**0.5\n",
     "    plt.errorbar(ps, logical_errors, yerr=std_err, label=\"L={}\".format(L))\n",
     "plt.xlabel(\"Physical error rate\")\n",
     "plt.ylabel(\"Logical error rate\")\n",
@@ -297,16 +318,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
-    "def num_decoding_failures_noisy_syndromes(H, logicals, p, q, num_trials, repetitions):\n",
+    "def num_decoding_failures_noisy_syndromes(H, logicals, p, q, num_shots, repetitions):\n",
     "    matching = Matching(H, weights=np.log((1-p)/p),\n",
     "                repetitions=repetitions, timelike_weights=np.log((1-q)/q), faults_matrix=logicals)\n",
     "    num_stabilisers, num_qubits = H.shape\n",
     "    num_errors = 0\n",
-    "    for i in range(num_trials):\n",
+    "    for i in range(num_shots):\n",
     "        noise_new = (np.random.rand(num_qubits, repetitions) < p).astype(np.uint8)\n",
     "        noise_cumulative = (np.cumsum(noise_new, 1) % 2).astype(np.uint8)\n",
     "        noise_total = noise_cumulative[:,-1]\n",
@@ -332,7 +353,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
@@ -342,15 +363,15 @@
       "Simulating L=8...\n",
       "Simulating L=10...\n",
       "Simulating L=12...\n",
-      "CPU times: user 15.2 s, sys: 160 ms, total: 15.3 s\n",
-      "Wall time: 15.1 s\n"
+      "CPU times: user 11.2 s, sys: 88 ms, total: 11.3 s\n",
+      "Wall time: 11 s\n"
      ]
     }
    ],
    "source": [
     "%%time\n",
     "\n",
-    "num_trials = 3000\n",
+    "num_shots = 3000\n",
     "Ls = range(8,13,2)\n",
     "ps = np.linspace(0.02, 0.04, 7)\n",
     "log_errors_all_L = []\n",
@@ -360,8 +381,8 @@
     "    logX = toric_code_x_logicals(L)\n",
     "    log_errors = []\n",
     "    for p in ps:\n",
-    "        num_errors = num_decoding_failures_noisy_syndromes(Hx, logX, p, p, num_trials, L)\n",
-    "        log_errors.append(num_errors/num_trials)\n",
+    "        num_errors = num_decoding_failures_noisy_syndromes(Hx, logX, p, p, num_shots, L)\n",
+    "        log_errors.append(num_errors/num_shots)\n",
     "    log_errors_all_L.append(np.array(log_errors))"
    ]
   },
@@ -374,19 +395,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<Figure size 640x480 with 1 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
@@ -395,7 +414,7 @@
     "\n",
     "plt.figure()\n",
     "for L, logical_errors in zip(Ls, log_errors_all_L):\n",
-    "    std_err = (logical_errors*(1-logical_errors)/num_trials)**0.5\n",
+    "    std_err = (logical_errors*(1-logical_errors)/num_shots)**0.5\n",
     "    plt.errorbar(ps, logical_errors, yerr=std_err, label=\"L={}\".format(L))\n",
     "plt.yscale(\"log\")\n",
     "plt.xlabel(\"Physical error rate\")\n",
@@ -403,17 +422,118 @@
     "plt.legend(loc=0);"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Simulating circuit-level noise\n",
+    "\n",
+    "PyMatching can be combined with [Stim](https://github.com/quantumlib/Stim) to decode in the presence of more realistic noise models, where errors can occur during any gate in the syndrome extraction circuit. To do this, you construct a Stim circuit for the noisy quantum error correction circuit you want to simulate (e.g. a toric code memory experiment). Stim can sample syndromes (detector measurement outcomes) from the circuit and also provides a DetectorErrorModel (essentially a generalisation of a matching graph) which PyMatching uses to construct the `Matching` object for decoding the syndrome.\n",
+    "\n",
+    "Note that the [sinter](https://github.com/quantumlib/Stim/tree/main/glue/sample) package combines Stim and PyMatching and uses parallelisation over shots to run error correction simulations more efficiently. It also includes other tools (such as for plotting and analysing data). However, here we will use Stim and PyMatching directly to demonstrate how the APIs can be used.\n",
+    "\n",
+    "We will use the surface code here (instead of the toric code), since surface code example circuits are already included with Stim. In general you should write your own circuits tailored to the research problem you are trying to solve, however the example circuits are useful for getting started. Here we will sample shots from surface code circuits over a range of lattice sizes and circuit-level error rates:\n"
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Simulating L=5...\n",
+      "Simulating L=9...\n",
+      "Simulating L=13...\n",
+      "CPU times: user 24.3 s, sys: 228 ms, total: 24.5 s\n",
+      "Wall time: 24.4 s\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "\n",
+    "import stim\n",
+    "\n",
+    "num_shots = 20000\n",
+    "Ls = range(5,14,4)\n",
+    "ps = np.linspace(0.004, 0.01, 7)\n",
+    "log_errors_all_L = []\n",
+    "for L in Ls:\n",
+    "    print(\"Simulating L={}...\".format(L))\n",
+    "    log_errors = []\n",
+    "    for p in ps:\n",
+    "        circuit = stim.Circuit.generated(\"surface_code:rotated_memory_x\", \n",
+    "                                        distance=L, \n",
+    "                                        rounds=L, \n",
+    "                                        after_clifford_depolarization=p,\n",
+    "                                        before_round_data_depolarization=p,\n",
+    "                                        after_reset_flip_probability=p,\n",
+    "                                        before_measure_flip_probability=p)\n",
+    "        model = circuit.detector_error_model(decompose_errors=True)\n",
+    "        matching = Matching.from_detector_error_model(model)\n",
+    "        sampler = circuit.compile_detector_sampler()\n",
+    "        syndrome, actual_observables = sampler.sample(shots=num_shots, separate_observables=True)\n",
+    "        predicted_observables = matching.decode_batch(syndrome)\n",
+    "        num_errors = np.sum(np.any(predicted_observables != actual_observables, axis=1))\n",
+    "        log_errors.append(num_errors/num_shots)\n",
+    "    log_errors_all_L.append(np.array(log_errors))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now let's plot the results:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%matplotlib inline\n",
+    "\n",
+    "plt.figure()\n",
+    "for L, logical_errors in zip(Ls, log_errors_all_L):\n",
+    "    std_err = (logical_errors*(1-logical_errors)/num_shots)**0.5\n",
+    "    plt.errorbar(ps, logical_errors, yerr=std_err, label=\"L={}\".format(L))\n",
+    "plt.yscale(\"log\")\n",
+    "plt.xlabel(\"Physical error rate\")\n",
+    "plt.ylabel(\"Logical error rate\")\n",
+    "plt.legend(loc=0);"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We see a threshold of around 0.7% for circuit-level depolarising noise in the surface code. For more examples of how to use Stim with PyMatching (e.g. to estimate the required size of a surface code circuit to achieve a given error rate), see the [Stim documentation](https://github.com/quantumlib/Stim/tree/main/doc), including the getting started notebook."
+   ]
+  },
+  {
+   "cell_type": "markdown",
    "metadata": {},
-   "outputs": [],
    "source": []
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3.9.15 64-bit",
+   "display_name": "Python 3.10.8 ('DOCS_ENV': venv)",
    "language": "python",
    "name": "python3"
   },
@@ -427,11 +547,11 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.15"
+   "version": "3.10.8"
   },
   "vscode": {
    "interpreter": {
-    "hash": "397704579725e15f5c7cb49fe5f0341eb7531c82d19f2c29d197e8b64ab5776b"
+    "hash": "f974771f0564b5ae695921bcf938d6264317d92cdc47360159288a59986c7a85"
    }
   }
  },
diff --git a/src/pymatching/matching.py b/src/pymatching/matching.py
index f86df96b..b0cfbe08 100644
--- a/src/pymatching/matching.py
+++ b/src/pymatching/matching.py
@@ -570,10 +570,11 @@ def decode_to_matched_dets_dict(self,
 
     def draw(self) -> None:
         """Draw the matching graph using matplotlib
-        Draws the matching graph as a matplotlib graph. Stabiliser nodes are
+        Draws the matching graph as a matplotlib graph. Detector nodes are
         filled grey and boundary nodes are filled white. The line thickness of each
         edge is determined from its weight (with min and max thicknesses of 0.2 pts
         and 2 pts respectively).
+        Each node is labelled with its id/index, and each edge is labelled with its `fault_ids`.
         Note that you may need to call `plt.figure()` before and `plt.show()` after calling
         this function.
         """
diff --git a/src/pymatching/sparse_blossom/driver/namespaced_main.cc b/src/pymatching/sparse_blossom/driver/namespaced_main.cc
index 9e5b65b2..dc122419 100644
--- a/src/pymatching/sparse_blossom/driver/namespaced_main.cc
+++ b/src/pymatching/sparse_blossom/driver/namespaced_main.cc
@@ -40,8 +40,8 @@ int main_predict(int argc, const char **argv) {
         argc,
         argv);
 
-    FILE *shots_in = stim::find_open_file_argument("--in", stdin, "r", argc, argv);
-    FILE *predictions_out = stim::find_open_file_argument("--out", stdout, "w", argc, argv);
+    FILE *shots_in = stim::find_open_file_argument("--in", stdin, "rb", argc, argv);
+    FILE *predictions_out = stim::find_open_file_argument("--out", stdout, "wb", argc, argv);
     FILE *dem_file = stim::find_open_file_argument("--dem", nullptr, "r", argc, argv);
     stim::FileFormatData shots_in_format =
         stim::find_enum_argument("--in_format", "b8", stim::format_name_to_enum_map, argc, argv);
@@ -100,9 +100,9 @@ int main_count_mistakes(int argc, const char **argv) {
         argc,
         argv);
 
-    FILE *shots_in = stim::find_open_file_argument("--in", stdin, "r", argc, argv);
-    FILE *obs_in = stim::find_open_file_argument("--obs_in", stdin, "r", argc, argv);
-    FILE *stats_out = stim::find_open_file_argument("--out", stdout, "w", argc, argv);
+    FILE *shots_in = stim::find_open_file_argument("--in", stdin, "rb", argc, argv);
+    FILE *obs_in = stim::find_open_file_argument("--obs_in", stdin, "rb", argc, argv);
+    FILE *stats_out = stim::find_open_file_argument("--out", stdout, "wb", argc, argv);
     FILE *dem_file = stim::find_open_file_argument("--dem", nullptr, "r", argc, argv);
     stim::FileFormatData shots_in_format =
         stim::find_enum_argument("--in_format", "01", stim::format_name_to_enum_map, argc, argv);


Test patch:
diff --git a/tests/cli_test.py b/tests/cli_test.py
index c65c7310..bca18079 100644
--- a/tests/cli_test.py
+++ b/tests/cli_test.py
@@ -10,7 +10,7 @@
 
 
 @contextmanager
-def three_errors_data():
+def three_errors_data(in_fmt: str):
     out_fn = os.path.join(DATA_DIR, "three_errors_predictions.dets")
     if os.path.isfile(out_fn):
         os.remove(out_fn)
@@ -18,8 +18,8 @@ def three_errors_data():
     args = [
         "predict",
         "--dem", os.path.join(DATA_DIR, "three_errors.dem"),
-        "--in", os.path.join(DATA_DIR, "three_errors.dets"),
-        "--in_format", "dets",
+        "--in", os.path.join(DATA_DIR, "three_errors." + in_fmt),
+        "--in_format", in_fmt,
         "--out", out_fn,
         "--out_format", "dets",
     ]
@@ -35,17 +35,39 @@ def three_errors_data():
 
 
 def test_cli():
-    with three_errors_data() as args:
+    with three_errors_data("dets") as args:
         cli(command_line_args=args)
 
 
 def test_protected_cli():
-    with three_errors_data() as args:
+    with three_errors_data("dets") as args:
+        pymatching._cpp_pymatching.main(command_line_args=args)
+
+
+def test_protected_cli_b8_in():
+    with three_errors_data("b8") as args:
         pymatching._cpp_pymatching.main(command_line_args=args)
 
 
 def test_cli_argv():
     from unittest.mock import patch
-    with three_errors_data() as args:
+    with three_errors_data("dets") as args:
         with patch.object(sys, 'argv', ["cli"] + args):
             cli_argv()
+
+
+def test_load_surface_code_b8_cli():
+    dem_path = os.path.join(DATA_DIR, "surface_code_rotated_memory_x_13_0.01.dem")
+    dets_b8_in_path = os.path.join(DATA_DIR, "surface_code_rotated_memory_x_13_0.01_1000_shots.b8")
+    out_fn = os.path.join(DATA_DIR, "surface_code_rotated_memory_x_13_0.01_1000_shots_temp_predictions.b8")
+
+    pymatching._cpp_pymatching.main(command_line_args=[
+        "predict",
+        "--dem", dem_path,
+        "--in", dets_b8_in_path,
+        "--in_format", "b8",
+        "--out", out_fn,
+        "--out_format", "b8",
+        "--in_includes_appended_observables"
+    ])
+    os.remove(out_fn)