From 7d4fa0f90dd7da61265c4d2e78a025829eef399e Mon Sep 17 00:00:00 2001
From: Lenny <lenny@delzio.ch>
Date: Fri, 15 May 2026 17:20:24 +0100
Subject: [PATCH 1/6] tmp trial

---
 docs/getting_started.ipynb                    | 466 +++++++++++++++++-
 .../core/compilation/compilation_context.py   |  31 +-
 .../core/compilation/compiled_experiment.py   |   3 +-
 .../core/compilation/measurement_record.py    |   2 +-
 src/epic/core/compilation/qec_compiler.py     |  20 +-
 src/epic/core/compilation/quantum_memory.py   | 186 +++++--
 src/epic/core/data_structure/__init__.py      |   2 +
 src/epic/core/data_structure/tanner_graph.py  |   1 +
 src/epic/core/language/qec_gadget.py          |   3 +
 src/epic/core/qec_object/__init__.py          |   5 +-
 .../interfaces/extract_syndrome.py            |   5 +-
 .../interfaces/qec_primitive.py               |  31 +-
 .../core/qec_primitives/primitive_compiler.py |   2 -
 .../naive_logical_measurement.py              |  21 +-
 .../qec_gadgets/logical_resets/init_code.py   |  32 +-
 .../pauli_product_measurement/rsc_surgery.py  |  37 +-
 src/epic/modules/qec_gadgets/readout_code.py  |   6 +
 .../apply_gates/simple_gate_application.py    |  40 +-
 .../qec_procedures/empty_procedure.py         |   8 +-
 .../qec_primitives/readouts/naive_readout.py  |  26 +-
 .../rsc_syndrome_extraction.py                |  42 +-
 .../simple_syndrome_extraction.py             |  44 +-
 .../zxcoloring_extraction.py                  |  48 +-
 tests/core/compilation/test_qec_compiler.py   |  24 +-
 tests/core/compilation/test_quantum_memory.py |  62 ++-
 25 files changed, 915 insertions(+), 232 deletions(-)

diff --git a/docs/getting_started.ipynb b/docs/getting_started.ipynb
index 3daafdd..1d50066 100644
--- a/docs/getting_started.ipynb
+++ b/docs/getting_started.ipynb
@@ -134,6 +134,7 @@
     "        \"epic.core.qec_primitives.interfaces.ExtractSyndrome\": \"epic.modules.qec_primitives.RSCSyndromeExtraction\",\n",
     "    },\n",
     "    \"objective_distance\": 3,\n",
+    "    \"physical_qubits_limit\": -1,\n",
     "}"
    ]
   },
@@ -150,10 +151,461 @@
    "execution_count": 4,
    "id": "6c785daf",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "RX 4 6 2 5 1 8 7 3 0\n",
+      "# RSC syndrome extraction \n",
+      "RZ 33 28 32 30 27 29 31 34\n",
+      "REPEAT 3 {\n",
+      "   TICK\n",
+      "   H 33 28 32 27\n",
+      "   TICK\n",
+      "   CX 28 4 32 7 0 30 27 8 2 29 1 31\n",
+      "   TICK\n",
+      "   CX 28 2 32 1 7 30 27 6 3 29 8 31\n",
+      "   TICK\n",
+      "   CX 33 0 28 1 32 5 4 30 3 31 7 34\n",
+      "   TICK\n",
+      "   CX 33 4 28 3 32 8 1 30 6 31 5 34\n",
+      "   TICK\n",
+      "   H 33 28 32 27\n",
+      "   TICK\n",
+      "   MRZ 33 28 32 30 27 29 31 34\n",
+      "}\n",
+      "RZ 9 14 17 12 16 13 11 10 15\n",
+      "# RSC syndrome extraction \n",
+      "RZ 33 32 28 30 29 27 31 34\n",
+      "REPEAT 3 {\n",
+      "   TICK\n",
+      "   H 32 30 27 31\n",
+      "   TICK\n",
+      "   CX 13 33 14 28 30 12 27 9 31 17 16 34\n",
+      "   TICK\n",
+      "   CX 9 33 17 28 30 16 27 14 31 15 10 34\n",
+      "   TICK\n",
+      "   CX 12 33 32 13 10 28 30 14 9 29 27 11\n",
+      "   TICK\n",
+      "   CX 14 33 32 12 15 28 30 10 11 29 27 17\n",
+      "   TICK\n",
+      "   H 32 30 27 31\n",
+      "   TICK\n",
+      "   MRZ 33 32 28 30 29 27 31 34\n",
+      "}\n",
+      "RZ 19 21 25 26 20 24 23 18 22\n",
+      "# RSC syndrome extraction \n",
+      "RZ 33 28 32 30 27 29 31 34\n",
+      "REPEAT 3 {\n",
+      "   TICK\n",
+      "   H 33 30 29 34\n",
+      "   TICK\n",
+      "   CX 26 28 25 32 30 18 23 27 29 20 34 22\n",
+      "   TICK\n",
+      "   CX 22 28 21 32 30 25 20 27 29 26 34 19\n",
+      "   TICK\n",
+      "   CX 33 23 21 28 30 26 18 27 29 24 20 31\n",
+      "   TICK\n",
+      "   CX 33 18 19 28 30 21 26 27 29 22 24 31\n",
+      "   TICK\n",
+      "   H 33 30 29 34\n",
+      "   TICK\n",
+      "   MRZ 33 28 32 30 27 29 31 34\n",
+      "}\n",
+      "RX 29 35 42 44 45 49 33\n",
+      "# RSC syndrome extraction rsc_surgery_merged_syndrome_MZZ_ac\n",
+      "RZ 45 36 33 32 37 39 47 28 40 48 44 41 46 34 30 31 27 43 35 38\n",
+      "REPEAT 3 {\n",
+      "   TICK\n",
+      "   H 36 32 37 28 48 41 31 43\n",
+      "   TICK\n",
+      "   CX 6 45 36 4 5 33 32 12 37 8 2 47 28 9 1 40 41 7 0 46 16 34 13 30 31 29 14 27 43 17 49 35\n",
+      "   TICK\n",
+      "   CX 42 45 36 2 29 33 32 16 37 6 3 47 28 14 8 40 41 1 7 46 10 34 9 30 31 49 17 27 43 15 12 35\n",
+      "   TICK\n",
+      "   CX 36 1 8 33 32 14 37 49 9 39 28 11 3 40 48 0 29 44 41 5 4 46 12 30 31 13 10 27 42 35 7 38\n",
+      "   TICK\n",
+      "   CX 36 3 49 33 32 10 37 42 11 39 28 17 6 40 48 4 13 44 41 8 1 46 14 30 31 12 15 27 16 35 5 38\n",
+      "   TICK\n",
+      "   H 36 32 37 28 48 41 31 43\n",
+      "   TICK\n",
+      "   MRZ 45 36 33 32 37 39 47 28 40 48 44 41 46 34 30 31 27 43 35 38\n",
+      "}\n",
+      "MX 49 42 29\n",
+      "# RSC syndrome extraction rsc_surgery_split_syndrome_MZZ_ac\n",
+      "RZ 30 31 27 32 39 28 43 34\n",
+      "REPEAT 3 {\n",
+      "   TICK\n",
+      "   H 31 32 28 43\n",
+      "   TICK\n",
+      "   CX 13 30 14 27 32 12 28 9 43 17 16 34\n",
+      "   TICK\n",
+      "   CX 9 30 17 27 32 16 28 14 43 15 10 34\n",
+      "   TICK\n",
+      "   CX 12 30 31 13 10 27 32 14 9 39 28 11\n",
+      "   TICK\n",
+      "   CX 14 30 31 12 15 27 32 10 11 39 28 17\n",
+      "   TICK\n",
+      "   H 31 32 28 43\n",
+      "   TICK\n",
+      "   MRZ 30 31 27 32 39 28 43 34\n",
+      "}\n",
+      "# RSC syndrome extraction rsc_surgery_split_syndrome_MZZ_ac\n",
+      "RZ 48 36 41 46 37 47 40 38\n",
+      "REPEAT 3 {\n",
+      "   TICK\n",
+      "   H 48 36 41 37\n",
+      "   TICK\n",
+      "   CX 36 4 41 7 0 46 37 8 2 47 1 40\n",
+      "   TICK\n",
+      "   CX 36 2 41 1 7 46 37 6 3 47 8 40\n",
+      "   TICK\n",
+      "   CX 48 0 36 1 41 5 4 46 3 40 7 38\n",
+      "   TICK\n",
+      "   CX 48 4 36 3 41 8 1 46 6 40 5 38\n",
+      "   TICK\n",
+      "   H 48 36 41 37\n",
+      "   TICK\n",
+      "   MRZ 48 36 41 46 37 47 40 38\n",
+      "}\n",
+      "RZ 45 38 39 49 47 32 43\n",
+      "# RSC syndrome extraction rsc_surgery_merged_syndrome_MXX_ct\n",
+      "RZ 30 29 33 32 37 42 28 40 43 48 44 41 46 34 38 49 31 27 35 36\n",
+      "REPEAT 3 {\n",
+      "   TICK\n",
+      "   H 30 29 33 32 28 40 43 44 34 38 49 31\n",
+      "   TICK\n",
+      "   CX 30 18 29 4 33 8 2 37 1 42 43 21 26 48 44 7 23 41 0 46 34 22 38 45 49 47 31 20 25 35 39 36\n",
+      "   TICK\n",
+      "   CX 30 25 29 2 33 6 3 37 8 42 43 39 22 48 44 1 20 41 7 46 34 19 38 5 49 0 31 26 21 35 45 36\n",
+      "   TICK\n",
+      "   CX 30 26 29 1 32 25 3 42 28 0 40 23 43 19 21 48 44 5 18 41 4 46 49 39 31 24 20 27 47 35 7 36\n",
+      "   TICK\n",
+      "   CX 30 21 29 3 32 47 6 42 28 4 40 18 43 45 19 48 44 8 26 41 1 46 49 7 31 22 24 27 39 35 5 36\n",
+      "   TICK\n",
+      "   H 30 29 33 32 28 40 43 44 34 38 49 31\n",
+      "   TICK\n",
+      "   MRZ 30 29 33 32 37 42 28 40 43 48 44 41 46 34 38 49 31 27 35 36\n",
+      "}\n",
+      "MZ 45 39 47\n",
+      "# RSC syndrome extraction rsc_surgery_split_syndrome_MXX_ct\n",
+      "RZ 28 29 44 46 33 37 42 36\n",
+      "REPEAT 3 {\n",
+      "   TICK\n",
+      "   H 28 29 44 33\n",
+      "   TICK\n",
+      "   CX 29 4 44 7 0 46 33 8 2 37 1 42\n",
+      "   TICK\n",
+      "   CX 29 2 44 1 7 46 33 6 3 37 8 42\n",
+      "   TICK\n",
+      "   CX 28 0 29 1 44 5 4 46 3 42 7 36\n",
+      "   TICK\n",
+      "   CX 28 4 29 3 44 8 1 46 6 42 5 36\n",
+      "   TICK\n",
+      "   H 28 29 44 33\n",
+      "   TICK\n",
+      "   MRZ 28 29 44 46 33 37 42 36\n",
+      "}\n",
+      "# RSC syndrome extraction rsc_surgery_split_syndrome_MXX_ct\n",
+      "RZ 40 48 35 30 41 31 27 34\n",
+      "REPEAT 3 {\n",
+      "   TICK\n",
+      "   H 40 30 31 34\n",
+      "   TICK\n",
+      "   CX 26 48 25 35 30 18 23 41 31 20 34 22\n",
+      "   TICK\n",
+      "   CX 22 48 21 35 30 25 20 41 31 26 34 19\n",
+      "   TICK\n",
+      "   CX 40 23 21 48 30 26 18 41 31 24 20 27\n",
+      "   TICK\n",
+      "   CX 40 18 19 48 30 21 26 41 31 22 24 27\n",
+      "   TICK\n",
+      "   H 40 30 31 34\n",
+      "   TICK\n",
+      "   MRZ 40 48 35 30 41 31 27 34\n",
+      "}\n",
+      "MZ 14 9 11 12 17 16 13 10 15\n",
+      "MZ 6 1 0 2 7 8 3 4 5\n",
+      "MZ 23 21 24 26 18 22 20 25 19\n",
+      "DETECTOR rec[-321] rec[-313]\n",
+      "DETECTOR rec[-313] rec[-305]\n",
+      "DETECTOR rec[-320] rec[-312]\n",
+      "DETECTOR rec[-312] rec[-304]\n",
+      "DETECTOR rec[-319] rec[-311]\n",
+      "DETECTOR rec[-311] rec[-303]\n",
+      "DETECTOR rec[-318] rec[-310]\n",
+      "DETECTOR rec[-310] rec[-302]\n",
+      "DETECTOR rec[-317] rec[-309]\n",
+      "DETECTOR rec[-309] rec[-301]\n",
+      "DETECTOR rec[-316] rec[-308]\n",
+      "DETECTOR rec[-308] rec[-300]\n",
+      "DETECTOR rec[-315] rec[-307]\n",
+      "DETECTOR rec[-307] rec[-299]\n",
+      "DETECTOR rec[-314] rec[-306]\n",
+      "DETECTOR rec[-306] rec[-298]\n",
+      "DETECTOR rec[-297] rec[-289]\n",
+      "DETECTOR rec[-289] rec[-281]\n",
+      "DETECTOR rec[-296] rec[-288]\n",
+      "DETECTOR rec[-288] rec[-280]\n",
+      "DETECTOR rec[-295] rec[-287]\n",
+      "DETECTOR rec[-287] rec[-279]\n",
+      "DETECTOR rec[-294] rec[-286]\n",
+      "DETECTOR rec[-286] rec[-278]\n",
+      "DETECTOR rec[-293] rec[-285]\n",
+      "DETECTOR rec[-285] rec[-277]\n",
+      "DETECTOR rec[-292] rec[-284]\n",
+      "DETECTOR rec[-284] rec[-276]\n",
+      "DETECTOR rec[-291] rec[-283]\n",
+      "DETECTOR rec[-283] rec[-275]\n",
+      "DETECTOR rec[-290] rec[-282]\n",
+      "DETECTOR rec[-282] rec[-274]\n",
+      "DETECTOR rec[-273] rec[-265]\n",
+      "DETECTOR rec[-265] rec[-257]\n",
+      "DETECTOR rec[-272] rec[-264]\n",
+      "DETECTOR rec[-264] rec[-256]\n",
+      "DETECTOR rec[-271] rec[-263]\n",
+      "DETECTOR rec[-263] rec[-255]\n",
+      "DETECTOR rec[-270] rec[-262]\n",
+      "DETECTOR rec[-262] rec[-254]\n",
+      "DETECTOR rec[-269] rec[-261]\n",
+      "DETECTOR rec[-261] rec[-253]\n",
+      "DETECTOR rec[-268] rec[-260]\n",
+      "DETECTOR rec[-260] rec[-252]\n",
+      "DETECTOR rec[-267] rec[-259]\n",
+      "DETECTOR rec[-259] rec[-251]\n",
+      "DETECTOR rec[-266] rec[-258]\n",
+      "DETECTOR rec[-258] rec[-250]\n",
+      "DETECTOR rec[-249] rec[-229]\n",
+      "DETECTOR rec[-229] rec[-209]\n",
+      "DETECTOR rec[-248] rec[-304]\n",
+      "DETECTOR rec[-248] rec[-228]\n",
+      "DETECTOR rec[-228] rec[-208]\n",
+      "DETECTOR rec[-247] rec[-227]\n",
+      "DETECTOR rec[-227] rec[-207]\n",
+      "DETECTOR rec[-246] rec[-278]\n",
+      "DETECTOR rec[-246] rec[-226]\n",
+      "DETECTOR rec[-226] rec[-206]\n",
+      "DETECTOR rec[-245] rec[-301]\n",
+      "DETECTOR rec[-245] rec[-225]\n",
+      "DETECTOR rec[-225] rec[-205]\n",
+      "DETECTOR rec[-244] rec[-277]\n",
+      "DETECTOR rec[-244] rec[-224]\n",
+      "DETECTOR rec[-224] rec[-204]\n",
+      "DETECTOR rec[-243] rec[-300]\n",
+      "DETECTOR rec[-243] rec[-223]\n",
+      "DETECTOR rec[-223] rec[-203]\n",
+      "DETECTOR rec[-242] rec[-276]\n",
+      "DETECTOR rec[-242] rec[-222]\n",
+      "DETECTOR rec[-222] rec[-202]\n",
+      "DETECTOR rec[-241] rec[-299]\n",
+      "DETECTOR rec[-241] rec[-221]\n",
+      "DETECTOR rec[-221] rec[-201]\n",
+      "DETECTOR rec[-240] rec[-305]\n",
+      "DETECTOR rec[-240] rec[-220]\n",
+      "DETECTOR rec[-220] rec[-200]\n",
+      "DETECTOR rec[-239] rec[-219]\n",
+      "DETECTOR rec[-219] rec[-199]\n",
+      "DETECTOR rec[-238] rec[-303]\n",
+      "DETECTOR rec[-238] rec[-218]\n",
+      "DETECTOR rec[-218] rec[-198]\n",
+      "DETECTOR rec[-237] rec[-302]\n",
+      "DETECTOR rec[-237] rec[-217]\n",
+      "DETECTOR rec[-217] rec[-197]\n",
+      "DETECTOR rec[-236] rec[-274]\n",
+      "DETECTOR rec[-236] rec[-216]\n",
+      "DETECTOR rec[-216] rec[-196]\n",
+      "DETECTOR rec[-235] rec[-281]\n",
+      "DETECTOR rec[-235] rec[-215]\n",
+      "DETECTOR rec[-215] rec[-195]\n",
+      "DETECTOR rec[-234] rec[-280]\n",
+      "DETECTOR rec[-234] rec[-214]\n",
+      "DETECTOR rec[-214] rec[-194]\n",
+      "DETECTOR rec[-233] rec[-279]\n",
+      "DETECTOR rec[-233] rec[-213]\n",
+      "DETECTOR rec[-213] rec[-193]\n",
+      "DETECTOR rec[-232] rec[-275]\n",
+      "DETECTOR rec[-232] rec[-212]\n",
+      "DETECTOR rec[-212] rec[-192]\n",
+      "DETECTOR rec[-231] rec[-211]\n",
+      "DETECTOR rec[-211] rec[-191]\n",
+      "DETECTOR rec[-230] rec[-298]\n",
+      "DETECTOR rec[-230] rec[-210]\n",
+      "DETECTOR rec[-210] rec[-190]\n",
+      "DETECTOR rec[-186] rec[-195]\n",
+      "DETECTOR rec[-186] rec[-178]\n",
+      "DETECTOR rec[-178] rec[-170]\n",
+      "DETECTOR rec[-185] rec[-194] rec[-187] rec[-189]\n",
+      "DETECTOR rec[-185] rec[-177]\n",
+      "DETECTOR rec[-177] rec[-169]\n",
+      "DETECTOR rec[-184] rec[-193]\n",
+      "DETECTOR rec[-184] rec[-176]\n",
+      "DETECTOR rec[-176] rec[-168]\n",
+      "DETECTOR rec[-183] rec[-206]\n",
+      "DETECTOR rec[-183] rec[-175]\n",
+      "DETECTOR rec[-175] rec[-167]\n",
+      "DETECTOR rec[-182] rec[-204]\n",
+      "DETECTOR rec[-182] rec[-174]\n",
+      "DETECTOR rec[-174] rec[-166]\n",
+      "DETECTOR rec[-181] rec[-202]\n",
+      "DETECTOR rec[-181] rec[-173]\n",
+      "DETECTOR rec[-173] rec[-165]\n",
+      "DETECTOR rec[-180] rec[-192]\n",
+      "DETECTOR rec[-180] rec[-172]\n",
+      "DETECTOR rec[-172] rec[-164]\n",
+      "DETECTOR rec[-179] rec[-196]\n",
+      "DETECTOR rec[-179] rec[-171]\n",
+      "DETECTOR rec[-171] rec[-163]\n",
+      "DETECTOR rec[-162] rec[-200]\n",
+      "DETECTOR rec[-162] rec[-154]\n",
+      "DETECTOR rec[-154] rec[-146]\n",
+      "DETECTOR rec[-161] rec[-208]\n",
+      "DETECTOR rec[-161] rec[-153]\n",
+      "DETECTOR rec[-153] rec[-145]\n",
+      "DETECTOR rec[-160] rec[-198]\n",
+      "DETECTOR rec[-160] rec[-152]\n",
+      "DETECTOR rec[-152] rec[-144]\n",
+      "DETECTOR rec[-159] rec[-197]\n",
+      "DETECTOR rec[-159] rec[-151]\n",
+      "DETECTOR rec[-151] rec[-143]\n",
+      "DETECTOR rec[-158] rec[-205] rec[-189] rec[-188]\n",
+      "DETECTOR rec[-158] rec[-150]\n",
+      "DETECTOR rec[-150] rec[-142]\n",
+      "DETECTOR rec[-157] rec[-203]\n",
+      "DETECTOR rec[-157] rec[-149]\n",
+      "DETECTOR rec[-149] rec[-141]\n",
+      "DETECTOR rec[-156] rec[-201]\n",
+      "DETECTOR rec[-156] rec[-148]\n",
+      "DETECTOR rec[-148] rec[-140]\n",
+      "DETECTOR rec[-155] rec[-190]\n",
+      "DETECTOR rec[-155] rec[-147]\n",
+      "DETECTOR rec[-147] rec[-139]\n",
+      "DETECTOR rec[-138] rec[-254]\n",
+      "DETECTOR rec[-138] rec[-118]\n",
+      "DETECTOR rec[-118] rec[-98]\n",
+      "DETECTOR rec[-137] rec[-145]\n",
+      "DETECTOR rec[-137] rec[-117]\n",
+      "DETECTOR rec[-117] rec[-97]\n",
+      "DETECTOR rec[-136] rec[-142]\n",
+      "DETECTOR rec[-136] rec[-116]\n",
+      "DETECTOR rec[-116] rec[-96]\n",
+      "DETECTOR rec[-135] rec[-115]\n",
+      "DETECTOR rec[-115] rec[-95]\n",
+      "DETECTOR rec[-134] rec[-141]\n",
+      "DETECTOR rec[-134] rec[-114]\n",
+      "DETECTOR rec[-114] rec[-94]\n",
+      "DETECTOR rec[-133] rec[-140]\n",
+      "DETECTOR rec[-133] rec[-113]\n",
+      "DETECTOR rec[-113] rec[-93]\n",
+      "DETECTOR rec[-132] rec[-146]\n",
+      "DETECTOR rec[-132] rec[-112]\n",
+      "DETECTOR rec[-112] rec[-92]\n",
+      "DETECTOR rec[-131] rec[-257]\n",
+      "DETECTOR rec[-131] rec[-111]\n",
+      "DETECTOR rec[-111] rec[-91]\n",
+      "DETECTOR rec[-130] rec[-110]\n",
+      "DETECTOR rec[-110] rec[-90]\n",
+      "DETECTOR rec[-129] rec[-256]\n",
+      "DETECTOR rec[-129] rec[-109]\n",
+      "DETECTOR rec[-109] rec[-89]\n",
+      "DETECTOR rec[-128] rec[-144]\n",
+      "DETECTOR rec[-128] rec[-108]\n",
+      "DETECTOR rec[-108] rec[-88]\n",
+      "DETECTOR rec[-127] rec[-253]\n",
+      "DETECTOR rec[-127] rec[-107]\n",
+      "DETECTOR rec[-107] rec[-87]\n",
+      "DETECTOR rec[-126] rec[-143]\n",
+      "DETECTOR rec[-126] rec[-106]\n",
+      "DETECTOR rec[-106] rec[-86]\n",
+      "DETECTOR rec[-125] rec[-250]\n",
+      "DETECTOR rec[-125] rec[-105]\n",
+      "DETECTOR rec[-105] rec[-85]\n",
+      "DETECTOR rec[-124] rec[-104]\n",
+      "DETECTOR rec[-104] rec[-84]\n",
+      "DETECTOR rec[-123] rec[-103]\n",
+      "DETECTOR rec[-103] rec[-83]\n",
+      "DETECTOR rec[-122] rec[-252]\n",
+      "DETECTOR rec[-122] rec[-102]\n",
+      "DETECTOR rec[-102] rec[-82]\n",
+      "DETECTOR rec[-121] rec[-251]\n",
+      "DETECTOR rec[-121] rec[-101]\n",
+      "DETECTOR rec[-101] rec[-81]\n",
+      "DETECTOR rec[-120] rec[-255]\n",
+      "DETECTOR rec[-120] rec[-100]\n",
+      "DETECTOR rec[-100] rec[-80]\n",
+      "DETECTOR rec[-119] rec[-139]\n",
+      "DETECTOR rec[-119] rec[-99]\n",
+      "DETECTOR rec[-99] rec[-79]\n",
+      "DETECTOR rec[-75] rec[-92]\n",
+      "DETECTOR rec[-75] rec[-67]\n",
+      "DETECTOR rec[-67] rec[-59]\n",
+      "DETECTOR rec[-74] rec[-97]\n",
+      "DETECTOR rec[-74] rec[-66]\n",
+      "DETECTOR rec[-66] rec[-58]\n",
+      "DETECTOR rec[-73] rec[-88]\n",
+      "DETECTOR rec[-73] rec[-65]\n",
+      "DETECTOR rec[-65] rec[-57]\n",
+      "DETECTOR rec[-72] rec[-86]\n",
+      "DETECTOR rec[-72] rec[-64]\n",
+      "DETECTOR rec[-64] rec[-56]\n",
+      "DETECTOR rec[-71] rec[-96]\n",
+      "DETECTOR rec[-71] rec[-63]\n",
+      "DETECTOR rec[-63] rec[-55]\n",
+      "DETECTOR rec[-70] rec[-94]\n",
+      "DETECTOR rec[-70] rec[-62]\n",
+      "DETECTOR rec[-62] rec[-54]\n",
+      "DETECTOR rec[-69] rec[-93]\n",
+      "DETECTOR rec[-69] rec[-61]\n",
+      "DETECTOR rec[-61] rec[-53]\n",
+      "DETECTOR rec[-68] rec[-79] rec[-78] rec[-77]\n",
+      "DETECTOR rec[-68] rec[-60]\n",
+      "DETECTOR rec[-60] rec[-52]\n",
+      "DETECTOR rec[-51] rec[-91]\n",
+      "DETECTOR rec[-51] rec[-43]\n",
+      "DETECTOR rec[-43] rec[-35]\n",
+      "DETECTOR rec[-50] rec[-89]\n",
+      "DETECTOR rec[-50] rec[-42]\n",
+      "DETECTOR rec[-42] rec[-34]\n",
+      "DETECTOR rec[-49] rec[-80] rec[-77] rec[-76]\n",
+      "DETECTOR rec[-49] rec[-41]\n",
+      "DETECTOR rec[-41] rec[-33]\n",
+      "DETECTOR rec[-48] rec[-98]\n",
+      "DETECTOR rec[-48] rec[-40]\n",
+      "DETECTOR rec[-40] rec[-32]\n",
+      "DETECTOR rec[-47] rec[-87]\n",
+      "DETECTOR rec[-47] rec[-39]\n",
+      "DETECTOR rec[-39] rec[-31]\n",
+      "DETECTOR rec[-46] rec[-82]\n",
+      "DETECTOR rec[-46] rec[-38]\n",
+      "DETECTOR rec[-38] rec[-30]\n",
+      "DETECTOR rec[-45] rec[-81]\n",
+      "DETECTOR rec[-45] rec[-37]\n",
+      "DETECTOR rec[-37] rec[-29]\n",
+      "DETECTOR rec[-44] rec[-85]\n",
+      "DETECTOR rec[-44] rec[-36]\n",
+      "DETECTOR rec[-36] rec[-28]\n",
+      "DETECTOR rec[-26] rec[-27] rec[-24] rec[-21] rec[-170]\n",
+      "DETECTOR rec[-20] rec[-23] rec[-19] rec[-27] rec[-168]\n",
+      "DETECTOR rec[-26] rec[-25] rec[-166]\n",
+      "DETECTOR rec[-20] rec[-22] rec[-163]\n",
+      "DETECTOR rec[-17] rec[-16] rec[-14] rec[-11] rec[-56]\n",
+      "DETECTOR rec[-12] rec[-15] rec[-54]\n",
+      "DETECTOR rec[-17] rec[-12] rec[-13] rec[-18] rec[-53]\n",
+      "DETECTOR rec[-14] rec[-10] rec[-52]\n",
+      "DETECTOR rec[-8] rec[-4] rec[-1] rec[-6] rec[-34]\n",
+      "DETECTOR rec[-8] rec[-2] rec[-33]\n",
+      "DETECTOR rec[-9] rec[-5] rec[-6] rec[-3] rec[-31]\n",
+      "DETECTOR rec[-7] rec[-3] rec[-29]\n",
+      "OBSERVABLE_INCLUDE(0) rec[-24] rec[-22] rec[-21]\n",
+      "OBSERVABLE_INCLUDE(1) rec[-209] rec[-207] rec[-203] rec[-201] rec[-199] rec[-197] rec[-191] rec[-190] rec[-76] rec[-16] rec[-15] rec[-11] rec[-9] rec[-5] rec[-2]\n"
+     ]
+    }
+   ],
    "source": [
     "from pathlib import Path\n",
     "\n",
+    "import stim\n",
+    "\n",
     "from epic import QECCompiler, StimLikeNoiseModel\n",
     "\n",
     "compiler = QECCompiler(config)\n",
@@ -161,7 +613,7 @@
     "# compiled_program = compiler.compile(program, visual_output_path=Path(\"visualizations/getting_started/comp_vis.pdf\"))\n",
     "compiled_program = compiler.compile(program)\n",
     "\n",
-    "noise = 0\n",
+    "noise = 0.1\n",
     "noise_model = StimLikeNoiseModel.from_stim_like_probabilities(\n",
     "    after_clifford_depolarization=noise,\n",
     "    after_reset_flip_probability=noise,\n",
@@ -170,7 +622,9 @@
     ")\n",
     "\n",
     "stim_observables = [[\"readout_LZ_control\"], [\"rsc_surgery_MZZ_ac\", \"readout_LZ_ancilla\", \"readout_LZ_target\"]]\n",
-    "stim_program = compiled_program.to_stim_program(stim_observables, noise_model)"
+    "stim_program = compiled_program.to_stim_program(stim_observables)\n",
+    "\n",
+    "print(stim_program)"
    ]
   },
   {
@@ -245,6 +699,8 @@
     "    stim_program = compiled_program.to_stim_program(stim_observables, noise_model)\n",
     "\n",
     "    stim_circuit = stim.Circuit(stim_program)\n",
+    "\n",
+    "    \n",
     "    return stim_circuit"
    ]
   },
@@ -256,7 +712,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 768x576 with 1 Axes>"
       ]
@@ -294,7 +750,7 @@
     "    x_func=lambda stats: stats.json_metadata[\"p\"],\n",
     "    group_func=lambda stats: stats.json_metadata[\"d\"],\n",
     ")\n",
-    "ax.set_ylim(1e-9, 1e-0)\n",
+    "ax.set_ylim(1e-5, 1e-0)\n",
     "ax.set_xlim(1e-4, 1e-1)\n",
     "ax.loglog()\n",
     "ax.set_title(\"CNOT Code Error Rates\")\n",
diff --git a/src/epic/core/compilation/compilation_context.py b/src/epic/core/compilation/compilation_context.py
index c44011e..a104c9f 100644
--- a/src/epic/core/compilation/compilation_context.py
+++ b/src/epic/core/compilation/compilation_context.py
@@ -5,18 +5,20 @@
 from uuid import UUID
 import warnings
 
-from epic.core.qec_object.detector import (
-    Detector,
-    DetectorGraphPort,
-    QubitPortState,
-)
-from epic.core.qec_object.measurement import Measurement
-
 from .compiled_experiment import CompiledExperiment
 from .measurement_record import MeasurementRecord
 from .quantum_memory import QuantumMemory
 from ..data_structure.tanner_node import TannerNode
-from ..qec_object import LogicalOperator, LogicalQubit, Observable, StabilizerCode
+from ..qec_object import (
+    LogicalOperator,
+    LogicalQubit,
+    Observable,
+    StabilizerCode,
+    Measurement,
+    Detector,
+    DetectorGraphPort,
+    QubitPortState,
+)
 
 TargetT = TypeVar("TargetT", LogicalQubit, StabilizerCode)
 
@@ -34,7 +36,7 @@ class CompilationContext:
         measurement_record: Tracks measurements emitted by compiled primitives.
     """
 
-    def __init__(self):
+    def __init__(self, memory_size: int = -1) -> None:
         """Initialize the compilation state and all its registers. At the start, everything is empty."""
         self._uuid_memory: Dict[UUID, Any] = {}
         self._naming_registry: Dict[str, UUID] = {}
@@ -45,7 +47,7 @@ def __init__(self):
         self._circuit_instructions = []
         self._detectors = []
 
-        self.quantum_memory = QuantumMemory()
+        self.quantum_memory = QuantumMemory(size_limit=memory_size)
         self.measurement_record = MeasurementRecord()
 
         self._compilation_time = (0, 0)
@@ -160,7 +162,10 @@ def get_observable_by_tag(self, tag: str) -> Observable:
     def register_code(
         self, lqb_name: List[str], code: StabilizerCode, code_varname: str
     ):
-        """Register a code, its logical qubits, and their logical operators."""
+        """
+        Register a code, its logical qubits, and their logical operators.
+        Allocate physical qubits for the data qubits nodes
+        """
         self._uuid_memory[code.id] = code
         self._naming_registry[code_varname] = code.id
         for idx, qubit in enumerate(code.logical_qubits):
@@ -170,6 +175,9 @@ def register_code(
             for op in [qubit.logical_x, qubit.logical_z]:
                 self._uuid_memory[op.id] = op
                 self._operator_to_qubit[op.id] = qubit.id
+        self.quantum_memory.allocate_qubits(
+            qubits=list(code.tanner_graph.variable_nodes)
+        )
 
     def unregister_code(self, code_varname: str):
         """Remove a registered code and all objects derived from it."""
@@ -197,6 +205,7 @@ def unregister_code(self, code_varname: str):
                 del self._operator_to_qubit[op.id]
         del self._uuid_memory[code_id]
         del self._naming_registry[code_varname]
+        self.quantum_memory.free_qubits(qubits=list(code.tanner_graph.variable_nodes))
 
     def allocated_code_varnames(self) -> List[str]:
         """Return the variable names of all currently registered codes."""
diff --git a/src/epic/core/compilation/compiled_experiment.py b/src/epic/core/compilation/compiled_experiment.py
index 4250ea5..456ec04 100644
--- a/src/epic/core/compilation/compiled_experiment.py
+++ b/src/epic/core/compilation/compiled_experiment.py
@@ -6,9 +6,10 @@
 from epic.core.experiment.noise_model import NoiseModel
 
 from ..qec_object import Measurement
-from .measurement_record import MeasurementRecord
 from ..qec_object import Detector, Observable
 
+from .measurement_record import MeasurementRecord
+
 
 class CompiledExperiment(BaseModel):
     """Immutable compiled representation of an experiment ready for Stim export."""
diff --git a/src/epic/core/compilation/measurement_record.py b/src/epic/core/compilation/measurement_record.py
index 8356a87..0b99d45 100644
--- a/src/epic/core/compilation/measurement_record.py
+++ b/src/epic/core/compilation/measurement_record.py
@@ -1,7 +1,7 @@
 from uuid import UUID
 from collections.abc import Iterable
 
-from pydantic import BaseModel, Field, PrivateAttr
+from pydantic import BaseModel, PrivateAttr
 
 from ..qec_object import Measurement
 
diff --git a/src/epic/core/compilation/qec_compiler.py b/src/epic/core/compilation/qec_compiler.py
index e147767..b453284 100644
--- a/src/epic/core/compilation/qec_compiler.py
+++ b/src/epic/core/compilation/qec_compiler.py
@@ -2,19 +2,17 @@
 from typing import Any, List, Mapping, Sequence, Tuple
 import warnings
 
-from epic.core.language.qec_gadget import AllocCode, CodeGadget, FreeCode, LogicGadget
-from epic.core.qec_object.logical_qubit import LogicalQubit
-from epic.core.qec_object.observable import Observable
-from epic.core.qec_object.stabilizer_code import StabilizerCode
 from debug.warnings import CodeBelowDistanceWarning
-from epic.core.visualization.tanner_graph_vis import TannerGraphVisualizer
 
 from .compiled_experiment import CompiledExperiment
 from .compilation_context import CompilationContext
-from ..language import QECGadget
+from ..qec_object import LogicalQubit, StabilizerCode, Observable
+from ..language import QECGadget, AllocCode, CodeGadget, FreeCode, LogicGadget
 from ..qec_primitives.interfaces import QECPrimitive
 from ..qec_primitives import PrimitiveCompiler
 
+from epic.core.visualization.tanner_graph_vis import TannerGraphVisualizer
+
 
 class QECCompiler:
     """Compile high-level QEC gadgets into a compiled experiment."""
@@ -28,7 +26,8 @@ def __init__(self, config: dict[str, Any]) -> None:
         """
         self.config = config
         self.distance = self.config.get("objective_distance", 0)
-        self.ctx = CompilationContext()
+        self.quantum_memory_limit = self.config.get("physical_qubits_limit", -1)
+        self.ctx = CompilationContext(memory_size=self.quantum_memory_limit)
         self.primitive_compiler = PrimitiveCompiler(config=config)
         # self.gadget_compiler = GadgetCompiler(config)
 
@@ -162,6 +161,7 @@ def compile(
                         gadget.compile(
                             resolved_targets,
                             self.ctx.measurement_record.view(),
+                            self.ctx.quantum_memory,
                             self.ctx.t_gadget,
                             self.distance,
                         )
@@ -174,6 +174,7 @@ def compile(
                         gadget.compile(
                             resolved_targets,
                             self.ctx.measurement_record.view(),
+                            self.ctx.quantum_memory,
                             self.ctx.t_gadget,
                             self.distance,
                         )
@@ -181,15 +182,11 @@ def compile(
                 case _:
                     raise ValueError(f"Unsupported gadget type: {type(gadget)}")
 
-            # TODO
-            # lock = self.ctx.quantum_memory.acquire_lock(ctx_nodes, ancilla_cost) <= dict node->idx, list[reserved idx]
-            # => alloc ancilla_cost
             gadget_measurements = []
             for p_op in primitive_code_instructions:
                 c_instructions, measurements, detectors, new_dg_port = (
                     self.primitive_compiler.compile(
                         p_op,
-                        self.ctx.quantum_memory,
                         self.ctx.measurement_record.view(),
                         self.ctx.detector_graph_port_view(),
                         parent_gadget_id=gadget.id,
@@ -213,7 +210,6 @@ def compile(
                         observables,
                         gadget.tag,
                     )
-            # => release lock, dealloc ancillas
 
             # Should I apply the frame correction the Observable with or without the gadget's own logical correction ? ???
             if observables is not None:
diff --git a/src/epic/core/compilation/quantum_memory.py b/src/epic/core/compilation/quantum_memory.py
index 42ab314..51a349d 100644
--- a/src/epic/core/compilation/quantum_memory.py
+++ b/src/epic/core/compilation/quantum_memory.py
@@ -1,88 +1,166 @@
 from collections.abc import Mapping, Sequence
 from types import MappingProxyType
+from typing import Set
+from uuid import UUID
 
 from pydantic import BaseModel, Field, PrivateAttr
 
-from ..data_structure.tanner_node import TannerNode
+from ..data_structure import VariableNode, PhysicalQubit
 
 
 class QuantumMemory(BaseModel):
     """Track slot allocation for physical qubits during compilation."""
 
+    size_limit: int = Field(
+        description="Total number of qubits in the quantum memory. -1 indicates unbounded memory that can grow as needed.",
+        default=-1,
+    )
     size: int = Field(
-        description="Total number of qubits in the quantum memory.",
+        description="Current number of qubits in the quantum memory. -1 indicates unbounded memory that can grow as needed.",
         default=0,
     )
-    _slots: list[int] = PrivateAttr(default_factory=list)
-    _free_slots: list[int] = PrivateAttr(default_factory=list)
-    _allocation: dict[TannerNode, int] = PrivateAttr(default_factory=dict)
+
+    _existing_qubits: set[PhysicalQubit] = PrivateAttr(default_factory=set)
+    _free_qubits: set[PhysicalQubit] = PrivateAttr(default_factory=set)
+
+    _data_qubits_allocation: dict[VariableNode, PhysicalQubit] = PrivateAttr(
+        default_factory=dict
+    )
+
+    _data_qubits_locked: dict[PhysicalQubit, UUID] = PrivateAttr(default_factory=dict)
+    _ancilla_locked: dict[PhysicalQubit, UUID] = PrivateAttr(default_factory=dict)
 
     @property
-    def slots(self) -> tuple[int, ...]:
+    def slots(self) -> tuple[PhysicalQubit, ...]:
         """Return all slot indices that have been created so far."""
-        return tuple(self._slots)
+        return tuple(self._existing_qubits)
 
     @property
-    def free_slots(self) -> tuple[int, ...]:
-        """Return the currently unallocated slot indices."""
-        return tuple(self._free_slots)
+    def free_slots(self) -> tuple[PhysicalQubit, ...]:
+        """Return the currently unallocated physical qubits."""
+        return tuple(self._free_qubits)
 
-    @property
-    def allocation(self) -> Mapping[TannerNode, int]:
-        """Return a read-only mapping from qubits to their allocated slot."""
-        # Expose a read-only view so external callers cannot mutate memory state.
-        return MappingProxyType(self._allocation)
+    def data_qubits_allocation_snapshot(
+        self, subset_keys: Set[VariableNode]
+    ) -> MappingProxyType[VariableNode, PhysicalQubit]:
+        """Return a snapshot of the current data qubits allocation for the requested subset of variable nodes."""
+
+        subset = {
+            k: self._data_qubits_allocation[k]
+            for k in subset_keys
+            if k in self._data_qubits_allocation
+        }
+
+        return MappingProxyType(subset)
 
-    def is_allocated(self, qubit_id: TannerNode) -> bool:
-        """Return whether a qubit currently has a slot assignment."""
-        return qubit_id in self._allocation
+    def is_allocated(self, variable_node: VariableNode) -> bool:
+        """Return whether a variable node currently has a slot assignment."""
+        return variable_node in self._data_qubits_allocation
 
-    def get_slot(self, qubit_id: TannerNode) -> int:
-        """Return the slot assigned to a previously allocated qubit."""
-        return self._allocation[qubit_id]
+    def get_physical_qubit(self, variable_node: VariableNode) -> PhysicalQubit:
+        """Return the physical qubit assigned to a data node."""
+        return self._data_qubits_allocation[variable_node]
 
-    def allocate_qubits(self, qubits: TannerNode | Sequence[TannerNode]) -> list[int]:
-        """Allocate one or more qubits and return their assigned slots."""
+    def allocate_qubits(
+        self, qubits: VariableNode | Sequence[VariableNode]
+    ) -> list[PhysicalQubit]:
+        """Allocate one or more qubits to data nodes and return their assigned slots."""
 
-        if isinstance(qubits, TannerNode):
+        if isinstance(qubits, VariableNode):
             qubits = [qubits]
 
-        if len(self._free_slots) < len(qubits):
-            new_slots = len(qubits) - len(self._free_slots)
-            self._slots.extend(range(self.size, self.size + new_slots))
-            self._free_slots.extend(range(self.size, self.size + new_slots))
+        if len(self._free_qubits) < len(qubits):
+            if self.size_limit != -1:
+                raise RuntimeError(
+                    f"Not enough free qubits to allocate {len(qubits)} qubits. Only {len(self._free_qubits)} free qubits available."
+                )
+            new_slots = len(qubits) - len(self._free_qubits)
+            self._existing_qubits.update(
+                PhysicalQubit(integer_index=i)
+                for i in range(self.size, self.size + new_slots)
+            )
+            self._free_qubits.update(
+                PhysicalQubit(integer_index=i)
+                for i in range(self.size, self.size + new_slots)
+            )
             self.size += new_slots
 
         for qid in qubits:
-            slot = self._free_slots.pop(0)
-            self._allocation[qid] = slot
-        return [self._allocation[qid] for qid in qubits]
+            slot = self._free_qubits.pop()
+            self._data_qubits_allocation[qid] = slot
+        return [self._data_qubits_allocation[qid] for qid in qubits]
 
-    def free_qubits(self, qubits: TannerNode | Sequence[TannerNode]) -> None:
+    def free_qubits(self, qubits: VariableNode | Sequence[VariableNode]) -> None:
         """Release one or more qubits and return their slots to the free pool."""
-        if isinstance(qubits, TannerNode):
+        if isinstance(qubits, VariableNode):
             qubits = [qubits]
         for qid in qubits:
-            slot = self._allocation.pop(qid)
-            self._free_slots.append(slot)
+            if qid not in self._data_qubits_allocation:
+                raise RuntimeError(
+                    f"Tried to free a data node {qid.tag} that is not currently allocated."
+                )
+            pqb = self._data_qubits_allocation.pop(qid)
+            self._free_qubits.add(pqb)
         return None
 
-
-# class TopologicalMemory(QuantumMemory):
-#     """Class representing a topological quantum memory, which is a specific type of quantum memory used in quantum error correction codes.
-#     In topological memories, physical qubits are associated with a position in a n-dimensional lattice.
-#     """
-
-#     dimension: int = Field(
-#         description="Dimension of the lattice in which the physical qubits are embedded.",
-#         default=2,
-#     )
-#     bounds: Tuple[int, ...] = Field(
-#         description="Bounds of the lattice in each dimension, defining the size of the lattice.",
-#         default=(),
-#     )
-#     slot_positions: dict[int, Tuple[int, ...]] = Field(
-#         description="Mapping from slot index to the coordinates of the corresponding physical qubit in the lattice.",
-#         default_factory=dict,
-#         init=False,
-#     )
+    def lock_data_qubits(
+        self, qubits: Sequence[PhysicalQubit], requestor_id: UUID
+    ) -> None:
+        """Lock the given qubits for data use by a specific compiler pass."""
+        for q in qubits:
+            if q in self._data_qubits_locked:
+                raise RuntimeError(
+                    f"Physical qubit {q} is already locked for data use."
+                )
+            self._data_qubits_locked[q] = requestor_id
+
+    def unlock_data_qubits(
+        self, qubits: Sequence[PhysicalQubit], owner_id: UUID
+    ) -> None:
+        """Unlock the given qubits for data use by a specific compiler pass."""
+        for q in qubits:
+            if self._data_qubits_locked.get(q) != owner_id:
+                raise RuntimeError(
+                    f"Physical qubit {q} is not locked by requestor {owner_id}."
+                )
+            del self._data_qubits_locked[q]
+
+    def lock_ancilla_qubits(self, n: int, requestor_id: UUID) -> Set[PhysicalQubit]:
+        """Lock n ancilla qubits for ancilla use by a specific compiler pass."""
+        if len(self._free_qubits) < n:
+            if self.size_limit == -1:
+                new_slots = n - len(self._free_qubits)
+                self._existing_qubits.update(
+                    PhysicalQubit(integer_index=i)
+                    for i in range(self.size, self.size + new_slots)
+                )
+                self._free_qubits.update(
+                    PhysicalQubit(integer_index=i)
+                    for i in range(self.size, self.size + new_slots)
+                )
+                self.size += new_slots
+            else:
+                raise RuntimeError(
+                    f"Not enough free qubits to lock {n} ancilla qubits. Only {len(self._free_qubits)} free qubits available."
+                )
+
+        locked_qubits = set()
+        for _ in range(n):
+            q = self._free_qubits.pop()
+            self._ancilla_locked[q] = requestor_id
+            locked_qubits.add(q)
+
+        return locked_qubits
+
+    def unlock_ancilla_qubits(
+        self, qubits: Sequence[PhysicalQubit], owner_id: UUID
+    ) -> None:
+        """Unlock the given ancilla qubits for ancilla use by a specific compiler pass."""
+        for q in qubits:
+            if self._ancilla_locked.get(q) != owner_id:
+                raise RuntimeError(
+                    f"Physical qubit {q} is not locked by requestor {owner_id}."
+                )
+            del self._ancilla_locked[q]
+            self._free_qubits.add(q)
+        return None
diff --git a/src/epic/core/data_structure/__init__.py b/src/epic/core/data_structure/__init__.py
index e93e87f..237b024 100644
--- a/src/epic/core/data_structure/__init__.py
+++ b/src/epic/core/data_structure/__init__.py
@@ -4,6 +4,7 @@
 from .tanner_node import CheckNode, TannerNode, VariableNode
 from .tanner_graph import TannerEdge, TannerGraph
 from .graph_algorithm import GraphAlgorithm
+from .physical_qubit import PhysicalQubit
 
 __all__ = [
     "TannerNode",
@@ -14,4 +15,5 @@
     "PauliChar",
     "PauliEigenState",
     "PauliString",
+    "PhysicalQubit",
 ]
diff --git a/src/epic/core/data_structure/tanner_graph.py b/src/epic/core/data_structure/tanner_graph.py
index f624e90..929531f 100644
--- a/src/epic/core/data_structure/tanner_graph.py
+++ b/src/epic/core/data_structure/tanner_graph.py
@@ -4,6 +4,7 @@
 
 from pydantic import BaseModel, Field, field_validator, model_validator
 from scipy.sparse import csr_matrix
+
 from .tanner_node import TannerNode, VariableNode, CheckNode
 from .pauli import PauliChar
 
diff --git a/src/epic/core/language/qec_gadget.py b/src/epic/core/language/qec_gadget.py
index 02dba94..c4aab0c 100644
--- a/src/epic/core/language/qec_gadget.py
+++ b/src/epic/core/language/qec_gadget.py
@@ -5,6 +5,7 @@
 from pydantic import BaseModel, ConfigDict, Field
 
 from epic.core.compilation.measurement_record import MeasurementRecordView
+from epic.core.compilation.quantum_memory import QuantumMemory
 from epic.core.qec_object.logical_qubit import LogicalQubit
 
 from ..qec_object import (
@@ -53,6 +54,7 @@ def compile(
         self,
         resolved_targets: List[Tuple[LogicalQubit, StabilizerCode]],
         record: MeasurementRecordView,
+        quantum_memory: QuantumMemory,
         timestep: int,
         objective_distance: int,
     ) -> Tuple[Dict[UUID, LogicalOperatorUpdate], List[Observable], List[QECPrimitive]]:
@@ -71,6 +73,7 @@ def compile(
         self,
         resolved_targets: List[StabilizerCode],
         record: MeasurementRecordView,
+        quantum_memory: QuantumMemory,
         timestep: int,
         objective_distance: int,
     ) -> Tuple[Dict[UUID, LogicalOperatorUpdate], List[Observable], List[QECPrimitive]]:
diff --git a/src/epic/core/qec_object/__init__.py b/src/epic/core/qec_object/__init__.py
index 84eee26..57d7986 100644
--- a/src/epic/core/qec_object/__init__.py
+++ b/src/epic/core/qec_object/__init__.py
@@ -1,6 +1,6 @@
 """QEC object-model exports."""
 
-from .detector import Detector
+from .detector import Detector, DetectorGraphPort, NodeKnowledge, QubitPortState
 from .logical_operator import LogicalOperator, LogicalOperatorUpdate
 from .logical_qubit import LogicalQubit
 from .measurement import Measurement
@@ -9,6 +9,9 @@
 
 __all__ = [
     "Detector",
+    "DetectorGraphPort",
+    "NodeKnowledge",
+    "QubitPortState",
     "LogicalOperator",
     "LogicalOperatorUpdate",
     "LogicalQubit",
diff --git a/src/epic/core/qec_primitives/interfaces/extract_syndrome.py b/src/epic/core/qec_primitives/interfaces/extract_syndrome.py
index 8c39398..4d965cb 100644
--- a/src/epic/core/qec_primitives/interfaces/extract_syndrome.py
+++ b/src/epic/core/qec_primitives/interfaces/extract_syndrome.py
@@ -35,7 +35,10 @@ def _detector_round_zero(
         tag: str,
     ) -> Detector | None:
         measurement_in_detectors = [round_zero_measurement]
-        check_knowledge = dgp[check].knowledge
+        if check not in dgp:
+            check_knowledge = NodeKnowledge.UNKNOWN
+        else:
+            check_knowledge = dgp[check].knowledge
         match check_knowledge:
             case NodeKnowledge.STABLE:
                 # By default, if a check was stable, we expect it to have the same parity as the previous round
diff --git a/src/epic/core/qec_primitives/interfaces/qec_primitive.py b/src/epic/core/qec_primitives/interfaces/qec_primitive.py
index 9d8d862..3934ee1 100644
--- a/src/epic/core/qec_primitives/interfaces/qec_primitive.py
+++ b/src/epic/core/qec_primitives/interfaces/qec_primitive.py
@@ -1,13 +1,15 @@
 from abc import ABC
-from typing import Any, Generic, List, Protocol, Tuple, TypeVar
+from typing import Any, Generic, List, Mapping, Protocol, Set, Tuple, TypeVar
 from uuid import UUID, uuid4
 
 
-from pydantic import BaseModel, Field, field_validator
+from pydantic import BaseModel, Field, field_validator, model_validator
+
+from epic.core.data_structure.tanner_node import TannerNode, VariableNode
 
 from ...qec_object.detector import DetectorGraphPort
 from ...compilation.measurement_record import MeasurementRecordView
-from ...compilation.quantum_memory import QuantumMemory
+from ...compilation.quantum_memory import PhysicalQubit, QuantumMemory
 from ...data_structure import TannerGraph
 from ...qec_object import Detector, Measurement
 
@@ -16,6 +18,13 @@ class QECPrimitive(ABC, BaseModel):
     """Abstract base class for primitives compiled against a Tanner graph."""
 
     target: TannerGraph
+    physical_data_qubits: Mapping[VariableNode, PhysicalQubit] = Field(
+        default_factory=dict
+    )
+    physical_ancilla_qubits: Mapping[TannerNode, PhysicalQubit] = Field(
+        default_factory=dict
+    )
+
     tag: str = ""
     distance: int = 0
 
@@ -28,6 +37,21 @@ def validate_distance(cls, distance):
             raise ValueError("Distance must be a non-negative integer.")
         return distance
 
+    @model_validator(mode="after")
+    def validate_qubits_in_target(cls, model):
+        """Ensure all data node in the primitive's Tanner graph target have corresponding physical qubits."""
+        if not model.physical_data_qubits:
+            return model
+
+        target_nodes = set(model.target.variable_nodes)
+        allocated_nodes = set(model.physical_data_qubits.keys())
+        if not target_nodes.issubset(allocated_nodes):
+            missing = target_nodes - allocated_nodes
+            raise ValueError(
+                f"Data nodes {missing} in the primitive's target do not have corresponding physical data qubits allocated."
+            )
+        return model
+
     def to_payload(self) -> dict[str, Any]:
         """Serialize the primitive while preserving its Tanner-graph target."""
         data = self.model_dump(exclude={"target"})
@@ -48,7 +72,6 @@ class PrimitiveImplementation(Protocol, Generic[T]):
     def compile(
         self,
         instruction: T,
-        memory: QuantumMemory,
         record: MeasurementRecordView,
         det_graph_port: DetectorGraphPort,
         parent_gadget_id: UUID,
diff --git a/src/epic/core/qec_primitives/primitive_compiler.py b/src/epic/core/qec_primitives/primitive_compiler.py
index c05357d..dcfd60c 100644
--- a/src/epic/core/qec_primitives/primitive_compiler.py
+++ b/src/epic/core/qec_primitives/primitive_compiler.py
@@ -69,7 +69,6 @@ def model_post_init(self, __context: Any) -> None:
     def compile(
         self,
         primitive_instruction: QECPrimitive,
-        memory: QuantumMemory,
         record: MeasurementRecordView,
         det_graph_port: MappingProxyType[TannerNode, QubitPortState],
         parent_gadget_id: UUID,
@@ -82,7 +81,6 @@ def compile(
 
         result = implementation.compile(
             instruction=primitive_instruction,
-            memory=memory,
             record=record,
             det_graph_port=det_graph_port,
             parent_gadget_id=parent_gadget_id,
diff --git a/src/epic/modules/qec_gadgets/logical_measurements/naive_logical_measurement.py b/src/epic/modules/qec_gadgets/logical_measurements/naive_logical_measurement.py
index 854ef35..b9fab8f 100644
--- a/src/epic/modules/qec_gadgets/logical_measurements/naive_logical_measurement.py
+++ b/src/epic/modules/qec_gadgets/logical_measurements/naive_logical_measurement.py
@@ -3,6 +3,7 @@
 
 from pydantic import model_validator
 
+from epic.core.compilation.quantum_memory import QuantumMemory
 from epic.core.data_structure import PauliChar, TannerGraph
 from epic.core.language import LogicGadget
 from epic.core.qec_object import LogicalOperatorUpdate, Measurement, Observable
@@ -26,7 +27,12 @@ def validate_basis_len(self):
         return self
 
     def compile(
-        self, resolved_targets, record, timestep, objective_distance
+        self,
+        resolved_targets,
+        record,
+        quantum_memory: QuantumMemory,
+        timestep,
+        objective_distance,
     ) -> Tuple[Dict[UUID, LogicalOperatorUpdate], List[Observable], List[QECPrimitive]]:
         primitives = []
         lop_targets: List[LogicalOperator] = []
@@ -42,13 +48,18 @@ def compile(
                     )
 
         for lop in lop_targets:
+            target = TannerGraph(
+                variable_nodes=set(lop.target_nodes),
+                check_nodes=set(),
+                edges=set(),
+            )
             primitives.append(
                 Readout(
-                    target=TannerGraph(
-                        variable_nodes=set(lop.target_nodes),
-                        check_nodes=set(),
-                        edges=set(),
+                    target=target,
+                    physical_data_qubits=quantum_memory.data_qubits_allocation_snapshot(
+                        target.variable_nodes
                     ),
+                    physical_ancilla_qubits={},  # no ancilla needed since no check in target nodes
                     readout_basis=lop.logical_type,
                     tag=f"measurement_{self.tag}_{lop.id}",
                 )
diff --git a/src/epic/modules/qec_gadgets/logical_resets/init_code.py b/src/epic/modules/qec_gadgets/logical_resets/init_code.py
index 41476ab..ffea0e5 100644
--- a/src/epic/modules/qec_gadgets/logical_resets/init_code.py
+++ b/src/epic/modules/qec_gadgets/logical_resets/init_code.py
@@ -1,10 +1,14 @@
+from collections import defaultdict
 from typing import Dict, List, Set, Tuple, cast
 from uuid import UUID
 
 from pydantic import Field
 
 from epic.core.compilation.measurement_record import MeasurementRecordView
+from epic.core.compilation.quantum_memory import QuantumMemory
 from epic.core.data_structure import PauliEigenState, TannerNode
+from epic.core.data_structure.physical_qubit import PhysicalQubit
+from epic.core.data_structure.tanner_graph import TannerGraph
 from epic.core.language import CodeGadget
 from epic.core.qec_object import LogicalOperatorUpdate, Observable
 from epic.core.qec_object.stabilizer_code import StabilizerCode
@@ -25,6 +29,7 @@ def compile(
         self,
         resolved_targets: List[StabilizerCode],
         record: MeasurementRecordView,
+        quantum_memory: QuantumMemory,
         timestep: int,
         objective_distance: int,
     ) -> Tuple[Dict[UUID, LogicalOperatorUpdate], List[Observable], List[QECPrimitive]]:
@@ -43,24 +48,43 @@ def compile(
                     "Unsupported initial eigenstate, only X and Z basis are allowed"
                 )
         primitives: List[QECPrimitive] = []
+        # Lock 1 ancilla per checks:
+        ancilla_locked: Dict[UUID, Dict[TannerNode, PhysicalQubit]] = defaultdict(dict)
         for code in resolved_targets:
-            target_nodes = cast(
-                Set[TannerNode],
-                code.tanner_graph.variable_nodes | code.tanner_graph.check_nodes,
+            anc = quantum_memory.lock_ancilla_qubits(
+                n=len(code.tanner_graph.check_nodes), requestor_id=self.id
             )
+            ancilla_locked[code.id] = {
+                n: q for n, q in zip(code.tanner_graph.check_nodes, anc)
+            }
+
+        for code in resolved_targets:
             primitives.append(
                 ApplyGate(
                     target=code.tanner_graph,
-                    target_nodes=target_nodes,
+                    physical_data_qubits=quantum_memory.data_qubits_allocation_snapshot(
+                        code.tanner_graph.variable_nodes
+                    ),
+                    physical_ancilla_qubits={},
+                    target_nodes=code.tanner_graph.variable_nodes,  # type: ignore
                     gates=gates,
                 )
             )
             primitives.append(
                 ExtractSyndrome(
                     target=code.tanner_graph,
+                    physical_data_qubits=quantum_memory.data_qubits_allocation_snapshot(
+                        code.tanner_graph.variable_nodes
+                    ),
+                    physical_ancilla_qubits=ancilla_locked[code.id],
                     distance=objective_distance,
                     rounds=objective_distance,
                 )
             )
 
+        for code, anc_checks_map in ancilla_locked.items():
+            quantum_memory.unlock_ancilla_qubits(
+                list(anc_checks_map.values()), owner_id=self.id
+            )
+
         return {}, [], primitives
diff --git a/src/epic/modules/qec_gadgets/pauli_product_measurement/rsc_surgery.py b/src/epic/modules/qec_gadgets/pauli_product_measurement/rsc_surgery.py
index e0fff76..35d0821 100644
--- a/src/epic/modules/qec_gadgets/pauli_product_measurement/rsc_surgery.py
+++ b/src/epic/modules/qec_gadgets/pauli_product_measurement/rsc_surgery.py
@@ -2,6 +2,7 @@
 
 from pydantic import field_validator
 
+from epic.core.compilation.quantum_memory import QuantumMemory
 from epic.core.data_structure.pauli import PauliChar
 from epic.core.data_structure.tanner_graph import TannerEdge, TannerGraph
 from epic.core.data_structure.tanner_node import CheckNode, CheckNode
@@ -38,7 +39,6 @@ def validate_product_to_measure(cls, v):
 
     def _check_axis(
         self,
-        resolved_targets: List[Tuple[LogicalQubit, StabilizerCode]],
         lop_involved,
     ) -> int:
 
@@ -206,6 +206,7 @@ def compile(
         self,
         resolved_targets: List[Tuple[LogicalQubit, StabilizerCode]],
         record,
+        quantum_memory: QuantumMemory,
         timestep,
         objective_distance: int,
     ):
@@ -238,7 +239,7 @@ def compile(
         merge_type = self.product_to_measure.string[0]
 
         # Get axis along which the merge occurs, horizontal (0) or vertical (1)
-        axis = self._check_axis(resolved_targets, lop_involved)
+        axis = self._check_axis(lop_involved)
 
         ## Compute translated lop, i.e. the chain that is on the merge boundary.
         # The current lop.target_nodes may represent a chain far from the merge boundary.
@@ -285,20 +286,44 @@ def compile(
         primitives = []
         lop_updates = {}
 
+        ancilla_qubits_to_node = dict()
+        ancilla_qubits_locked = quantum_memory.lock_ancilla_qubits(
+            n=len(merged_system.check_nodes) + len(ancilla_system.variable_nodes),
+            requestor_id=self.id,
+        )
+        for node, phys_qubit in zip(
+            merged_system.check_nodes | ancilla_system.variable_nodes,
+            ancilla_qubits_locked,
+        ):
+            ancilla_qubits_to_node[node] = phys_qubit
+
         init_ancilla = ApplyGate(
             target=ancilla_system,
             target_nodes=ancilla_system.variable_nodes | ancilla_system.check_nodes,  # type: ignore
+            physical_data_qubits={k: v for k, v in ancilla_qubits_to_node.items() if isinstance(k, VariableNode)},  # type: ignore
+            physical_ancilla_qubits=ancilla_qubits_to_node,
             gates=(
                 ["RX"] if merge_type == PauliChar.Z else ["RZ"]
             ),  # Init in dual of the merge type.
         )
         merged_syndrome = ExtractSyndrome(
             target=merged_system,
+            physical_data_qubits=quantum_memory.data_qubits_allocation_snapshot(
+                merged_system.variable_nodes
+            )
+            | {k: v for k, v in ancilla_qubits_to_node.items() if isinstance(k, VariableNode)},  # type: ignore
+            physical_ancilla_qubits=ancilla_qubits_to_node,
             rounds=objective_distance,
             tag=f"rsc_surgery_merged_syndrome_{self.tag}",
         )
         ancilla_readout = Readout(
             target=ancilla_system,
+            physical_data_qubits={
+                k: v
+                for k, v in ancilla_qubits_to_node.items()
+                if isinstance(k, VariableNode)
+            },
+            physical_ancilla_qubits=ancilla_qubits_to_node,  # readout look only at data qubits, no need for ancilla.
             readout_basis=merge_type.dual(),
             tag=f"rsc_surgery_measurement_{self.tag}",
         )
@@ -306,6 +331,10 @@ def compile(
         split_syndrome = [
             ExtractSyndrome(
                 target=initial_code,
+                physical_data_qubits=quantum_memory.data_qubits_allocation_snapshot(
+                    initial_code.variable_nodes
+                ),
+                physical_ancilla_qubits=ancilla_qubits_to_node,
                 rounds=objective_distance,
                 tag=f"rsc_surgery_split_syndrome_{self.tag}",
             )
@@ -357,4 +386,8 @@ def compile(
             )
         ]
 
+        quantum_memory.unlock_ancilla_qubits(
+            qubits=list(ancilla_qubits_locked), owner_id=self.id
+        )
+
         return lop_updates, observable, primitives
diff --git a/src/epic/modules/qec_gadgets/readout_code.py b/src/epic/modules/qec_gadgets/readout_code.py
index 4b4c856..c71e474 100644
--- a/src/epic/modules/qec_gadgets/readout_code.py
+++ b/src/epic/modules/qec_gadgets/readout_code.py
@@ -2,6 +2,7 @@
 from uuid import UUID
 
 from epic.core.compilation.measurement_record import MeasurementRecordView
+from epic.core.compilation.quantum_memory import QuantumMemory
 from epic.core.data_structure.pauli import PauliChar
 from epic.core.language.qec_gadget import CodeGadget
 from epic.core.qec_object import LogicalOperatorUpdate, Observable
@@ -19,6 +20,7 @@ def compile(
         self,
         resolved_targets: List[StabilizerCode],
         record: MeasurementRecordView,
+        quantum_memory: QuantumMemory,
         timestep: int,
         objective_distance: int,
     ) -> Tuple[Dict[UUID, LogicalOperatorUpdate], List[Observable], List[QECPrimitive]]:
@@ -27,6 +29,10 @@ def compile(
         for code in resolved_targets:
             ro = Readout(
                 target=code.tanner_graph,
+                physical_data_qubits=quantum_memory.data_qubits_allocation_snapshot(
+                    code.tanner_graph.variable_nodes
+                ),
+                physical_ancilla_qubits={},  # readout look only at data qubits
                 readout_basis=PauliChar.Z,
                 tag=f"readout_{code.name}",
             )
diff --git a/src/epic/modules/qec_primitives/apply_gates/simple_gate_application.py b/src/epic/modules/qec_primitives/apply_gates/simple_gate_application.py
index 6d37b9a..1caed3f 100644
--- a/src/epic/modules/qec_primitives/apply_gates/simple_gate_application.py
+++ b/src/epic/modules/qec_primitives/apply_gates/simple_gate_application.py
@@ -1,15 +1,11 @@
 from typing import List, Set, Tuple, Union, cast
 from uuid import UUID
 
-from epic.core.compilation import QuantumMemory
 from epic.core.compilation.measurement_record import MeasurementRecordView
-from epic.core.data_structure import TannerNode
-from epic.core.qec_object import Detector, Measurement
-from epic.core.qec_object.detector import (
-    DetectorGraphPort,
-    NodeKnowledge,
-    QubitPortState,
-)
+from epic.core.data_structure import TannerNode, VariableNode
+from epic.core.qec_object import Detector, Measurement, DetectorGraphPort, NodeKnowledge
+
+from epic.core.qec_object.detector import QubitPortState
 from epic.core.qec_primitives.interfaces import ApplyGate, PrimitiveImplementation
 
 
@@ -19,7 +15,7 @@ class SimpleGateApplication(PrimitiveImplementation[ApplyGate]):
     @staticmethod
     def _sanitize_target_nodes(
         target_nodes: Union[Set[TannerNode], Set[Tuple[TannerNode, ...]]],
-    ) -> Set[Tuple[TannerNode, ...]]:
+    ) -> Set[Tuple[VariableNode, ...]]:
         """Normalize targets to a set of tuples and validate homogeneous tuple sizes."""
         if not target_nodes:
             raise ValueError("ApplyGate instruction must specify target_nodes.")
@@ -28,7 +24,7 @@ def _sanitize_target_nodes(
 
         if isinstance(first, tuple):
             sanitized_targets = set(
-                cast(Tuple[TannerNode, ...], group) for group in target_nodes
+                cast(Tuple[VariableNode, ...], group) for group in target_nodes
             )
 
             tuple_lengths = {len(group) for group in sanitized_targets}
@@ -43,15 +39,14 @@ def _sanitize_target_nodes(
 
         if any(isinstance(item, tuple) for item in target_nodes):
             raise ValueError(
-                "target_nodes must be either a set of TannerNode or a set of tuple[TannerNode, ...]."
+                "target_nodes must be either a set of VariableNode or a set of tuple[VariableNode, ...]."
             )
 
-        return {(cast(TannerNode, node),) for node in target_nodes}
+        return {(cast(VariableNode, node),) for node in target_nodes}
 
     def compile(
         self,
         instruction: ApplyGate,
-        memory: QuantumMemory,
         record: MeasurementRecordView,
         det_graph_port: DetectorGraphPort,
         parent_gadget_id: UUID,
@@ -72,23 +67,24 @@ def compile(
             "RX": NodeKnowledge.RX,
         }
 
+        mem = {
+            **instruction.physical_data_qubits,
+            **instruction.physical_ancilla_qubits,
+        }
+
         if instruction.gates[-1] in gate_to_knowledge:
             node_knowledge = gate_to_knowledge[instruction.gates[-1]]
         else:
             node_knowledge = NodeKnowledge.UNKNOWN
 
-        for targets in sanitized_targets:
-            to_alloc = []
-            for node in targets:
-                if not memory.is_allocated(node):
-                    to_alloc.append(node)
-                new_dg_port[node] = QubitPortState(knowledge=node_knowledge)
-
-            memory.allocate_qubits(to_alloc)
+        if node_knowledge != NodeKnowledge.UNKNOWN:
+            for t in sanitized_targets:
+                for node in t:
+                    new_dg_port[node] = QubitPortState(knowledge=node_knowledge)
 
         for gate in instruction.gates:
             slots = " ".join(
-                str(memory.get_slot(node)) for t in sanitized_targets for node in t
+                str(mem[node].integer_index) for t in sanitized_targets for node in t
             )
             stim_instructions.append(f"{gate} {slots}")
 
diff --git a/src/epic/modules/qec_primitives/qec_procedures/empty_procedure.py b/src/epic/modules/qec_primitives/qec_procedures/empty_procedure.py
index ee294f2..aab1fab 100644
--- a/src/epic/modules/qec_primitives/qec_procedures/empty_procedure.py
+++ b/src/epic/modules/qec_primitives/qec_procedures/empty_procedure.py
@@ -1,10 +1,7 @@
-from types import MappingProxyType
-from typing import Dict, List, Tuple
+from typing import List, Tuple
 from uuid import UUID
 
-from epic.core.qec_object.detector import NodeKnowledge
 from epic.core.compilation.measurement_record import MeasurementRecordView
-from epic.core.data_structure import TannerNode
 from epic.core.qec_object import Detector, Measurement
 from epic.core.qec_object.detector import DetectorGraphPort
 from epic.core.qec_primitives.interfaces import PrimitiveImplementation, QECProcedure
@@ -14,9 +11,8 @@ class EmptyProcedure(PrimitiveImplementation[QECProcedure]):
     def compile(
         self,
         instruction: QECProcedure,
-        memory,
         record: MeasurementRecordView,
         det_graph_port: DetectorGraphPort,
         parent_gadget_id: UUID,
     ) -> Tuple[List[str], List[Measurement], List[Detector], DetectorGraphPort]:
-        return [], [], [], {}
+        return [], [], [], DetectorGraphPort()
diff --git a/src/epic/modules/qec_primitives/readouts/naive_readout.py b/src/epic/modules/qec_primitives/readouts/naive_readout.py
index c99e3e9..9e3001a 100644
--- a/src/epic/modules/qec_primitives/readouts/naive_readout.py
+++ b/src/epic/modules/qec_primitives/readouts/naive_readout.py
@@ -1,14 +1,15 @@
-from types import MappingProxyType
-from typing import Dict, List, Tuple, cast
+from typing import Dict, List, Tuple
 from uuid import UUID
 
-from epic.core.compilation import QuantumMemory
-from epic.core.qec_object.detector import NodeKnowledge
 from epic.core.compilation.measurement_record import MeasurementRecordView
-from epic.core.data_structure import CheckNode, TannerNode
-from epic.core.data_structure.pauli import PauliChar
-from epic.core.qec_object import Detector, Measurement
-from epic.core.qec_object.detector import DetectorGraphPort, QubitPortState
+from epic.core.data_structure import PauliChar
+from epic.core.qec_object import (
+    Detector,
+    Measurement,
+    DetectorGraphPort,
+    QubitPortState,
+    NodeKnowledge,
+)
 from epic.core.qec_primitives.interfaces import PrimitiveImplementation, Readout
 
 
@@ -18,7 +19,6 @@ class NaiveReadout(PrimitiveImplementation[Readout]):
     def compile(
         self,
         instruction: Readout,
-        memory: QuantumMemory,
         record: MeasurementRecordView,
         det_graph_port: DetectorGraphPort,
         parent_gadget_id: UUID,
@@ -33,11 +33,7 @@ def compile(
         )
         nm = []
         for node in instruction.target.variable_nodes:
-            if not memory.is_allocated(node):
-                raise ValueError(
-                    f"Cannot measure node {node.id} in gadget={parent_gadget_id} as it is not allocated in memory."
-                )
-            nm.append(str(memory.get_slot(node)))
+            nm.append(str(instruction.physical_data_qubits[node].integer_index))
             new_m = Measurement(
                 node_id=node.id,
                 parent_gadget_id=parent_gadget_id,
@@ -45,6 +41,7 @@ def compile(
                 tag=f"readout_{node.tag}",
             )
             new_measurements[node.id] = new_m
+
         instructions.append(f"M{instruction.readout_basis.value} {' '.join(nm)}")
 
         detectors: List[Detector] = []
@@ -101,6 +98,5 @@ def compile(
         new_dg_port = DetectorGraphPort()
         for node in instruction.target.variable_nodes:
             new_dg_port[node] = QubitPortState(knowledge=new_port_state)
-        memory.free_qubits(list(instruction.target.variable_nodes))
 
         return instructions, list(new_measurements.values()), detectors, new_dg_port
diff --git a/src/epic/modules/qec_primitives/syndrome_extraction/rsc_syndrome_extraction.py b/src/epic/modules/qec_primitives/syndrome_extraction/rsc_syndrome_extraction.py
index acb23c1..953d994 100644
--- a/src/epic/modules/qec_primitives/syndrome_extraction/rsc_syndrome_extraction.py
+++ b/src/epic/modules/qec_primitives/syndrome_extraction/rsc_syndrome_extraction.py
@@ -2,14 +2,17 @@
 from uuid import UUID
 
 
-from epic.core.qec_object.detector import NodeKnowledge
 from epic.core.compilation.measurement_record import (
     MeasurementRecordView,
 )
-from epic.core.compilation.quantum_memory import QuantumMemory
 from epic.core.data_structure import PauliChar, PauliEigenState, TannerNode
-from epic.core.qec_object import Detector, Measurement
-from epic.core.qec_object.detector import DetectorGraphPort, QubitPortState
+from epic.core.qec_object import (
+    Detector,
+    Measurement,
+    DetectorGraphPort,
+    QubitPortState,
+    NodeKnowledge,
+)
 from epic.core.qec_primitives.interfaces import ExtractSyndrome, PrimitiveImplementation
 
 
@@ -19,7 +22,6 @@ class RSCSyndromeExtraction(PrimitiveImplementation[ExtractSyndrome]):
     def compile(
         self,
         instruction: ExtractSyndrome,
-        memory: QuantumMemory,
         record: MeasurementRecordView,
         det_graph_port: DetectorGraphPort,
         parent_gadget_id: UUID,
@@ -33,22 +35,30 @@ def compile(
         measurements_ordered: List[Measurement] = []
         detectors: List[Detector] = []
 
-        to_alloc: List[TannerNode] = []
-        for n in instruction.target.variable_nodes | instruction.target.check_nodes:
-            if not memory.is_allocated(n):
-                to_alloc.append(n)
-        memory.allocate_qubits(to_alloc)
+        if len(check_nodes) > len(instruction.physical_ancilla_qubits):
+            raise ValueError(f"""
+                Not enough physical ancilla qubits provided for syndrome extraction.
+                Required: {len(check_nodes)}, Provided: {len(instruction.physical_ancilla_qubits)}
+                This schedule expect 1 ancilla per check node.
+                """)
+
+        checks_qubits = {
+            check: instruction.physical_ancilla_qubits[check] for check in check_nodes
+        }
+        data_qubits = instruction.physical_data_qubits
+
+        node_to_qubit = {**checks_qubits, **data_qubits}
 
         # RESET ANCILLA
 
         match instruction.ancilla_reset_state:
             case PauliEigenState.Z_plus:
                 reset_ancilla_instructions.append(
-                    f"RZ {" ".join([str(memory.get_slot(check)) for check in check_nodes])}"
+                    f"RZ {" ".join([str(node_to_qubit[check].integer_index) for check in check_nodes])}"
                 )
             case PauliEigenState.X_plus:
                 reset_ancilla_instructions.append(
-                    f"RX {" ".join([str(memory.get_slot(check)) for check in check_nodes])}"
+                    f"RX {" ".join([str(node_to_qubit[check].integer_index) for check in check_nodes])}"
                 )
             case _:
                 raise ValueError(
@@ -115,20 +125,20 @@ def compile(
 
         single_round_instructions.append("TICK")
         single_round_instructions.append(
-            f"H {" ".join(str(memory.get_slot(xc)) for xc in x_checks)}"
+            f"H {" ".join(str(node_to_qubit[xc].integer_index) for xc in x_checks)}"
         )
         single_round_instructions.append("TICK")
         for t in [t1, t2, t3, t4]:
             single_round_instructions.append(
-                f"CX {" ".join(f"{str(memory.get_slot(con))} {str(memory.get_slot(tar))}" for con, tar in t)}"
+                f"CX {" ".join(f"{str(node_to_qubit[con].integer_index)} {str(node_to_qubit[tar].integer_index)}" for con, tar in t)}"
             )
             single_round_instructions.append("TICK")
         single_round_instructions.append(
-            f"H {" ".join(str(memory.get_slot(xc)) for xc in x_checks)}"
+            f"H {" ".join(str(node_to_qubit[xc].integer_index) for xc in x_checks)}"
         )
         single_round_instructions.append("TICK")
         single_round_instructions.append(
-            f"MRZ {" ".join(str(memory.get_slot(c)) for c in node_measured)}"
+            f"MRZ {" ".join(str(node_to_qubit[c].integer_index) for c in node_measured)}"
         )
 
         stim_instructions.append(f"REPEAT {instruction.rounds} {{")
diff --git a/src/epic/modules/qec_primitives/syndrome_extraction/simple_syndrome_extraction.py b/src/epic/modules/qec_primitives/syndrome_extraction/simple_syndrome_extraction.py
index d30a8bb..1efab30 100644
--- a/src/epic/modules/qec_primitives/syndrome_extraction/simple_syndrome_extraction.py
+++ b/src/epic/modules/qec_primitives/syndrome_extraction/simple_syndrome_extraction.py
@@ -3,16 +3,18 @@
 from uuid import UUID
 import warnings
 
-from epic.core.qec_object.detector import NodeKnowledge
 from epic.core.compilation.measurement_record import (
-    MeasurementRecord,
     MeasurementRecordView,
 )
-from epic.core.compilation.quantum_memory import QuantumMemory
-from epic.core.data_structure import PauliChar, PauliEigenState, TannerNode
-from epic.core.data_structure.tanner_node import CheckNode
-from epic.core.qec_object import Detector, Measurement
-from epic.core.qec_object.detector import DetectorGraphPort, QubitPortState
+
+from epic.core.data_structure import PauliChar, PauliEigenState, TannerNode, CheckNode
+from epic.core.qec_object import (
+    Detector,
+    Measurement,
+    DetectorGraphPort,
+    QubitPortState,
+    NodeKnowledge,
+)
 from epic.core.qec_primitives.interfaces import ExtractSyndrome, PrimitiveImplementation
 
 
@@ -22,7 +24,6 @@ class SimpleSyndromeExtraction(PrimitiveImplementation[ExtractSyndrome]):
     def compile(
         self,
         instruction: ExtractSyndrome,
-        memory: QuantumMemory,
         record: MeasurementRecordView,
         det_graph_port: DetectorGraphPort,
         parent_gadget_id: UUID,
@@ -34,22 +35,29 @@ def compile(
         measurements: Dict[TannerNode, List[Measurement]] = {}
         measurements_ordered: List[Measurement] = []
         detectors: List[Detector] = []
-        to_alloc: List[TannerNode] = []
 
-        for n in instruction.target.variable_nodes | instruction.target.check_nodes:
-            if not memory.is_allocated(n):
-                to_alloc.append(n)
-        memory.allocate_qubits(to_alloc)
+        if len(check_nodes) > len(instruction.physical_ancilla_qubits):
+            raise ValueError(f"""
+                Not enough physical ancilla qubits provided for syndrome extraction.
+                Required: {len(check_nodes)}, Provided: {len(instruction.physical_ancilla_qubits)}
+                This schedule expect 1 ancilla per check node.
+                """)
+
+        checks_qubits = {
+            check: instruction.physical_ancilla_qubits[check] for check in check_nodes
+        }
+
+        data_qubits = instruction.physical_data_qubits
 
         # RESET ANCILLA
 
         if instruction.ancilla_reset_state == PauliEigenState.Z_plus:
             reset_ancilla_instructions.append(
-                f"RZ {" ".join([str(memory.get_slot(check)) for check in check_nodes])}"
+                f"RZ {" ".join([str(checks_qubits[check].integer_index) for check in check_nodes])}"
             )
         elif instruction.ancilla_reset_state == PauliEigenState.X_plus:
             reset_ancilla_instructions.append(
-                f"RX {" ".join([str(memory.get_slot(check)) for check in check_nodes])}"
+                f"RX {" ".join([str(checks_qubits[check].integer_index) for check in check_nodes])}"
             )
         else:
             raise ValueError(
@@ -66,9 +74,9 @@ def compile(
             )  # for clarity in the generated stim code
             if check.check_type:
                 check_circuit = self._extract_check_circuit(
-                    memory.get_slot(check),
+                    checks_qubits[check].integer_index,
                     [
-                        memory.get_slot(n)
+                        data_qubits[n].integer_index  # type: ignore
                         for n in instruction.target.get_neighbourhood(check)
                     ],
                     check.check_type,
@@ -81,7 +89,7 @@ def compile(
             [f"    {instr}" for instr in single_round_instructions]
         )
         stim_instructions.append(
-            f"    MRZ {" ".join(str(memory.get_slot(n)) for n in node_measured)}"
+            f"    MRZ {" ".join(str(checks_qubits[n].integer_index) for n in node_measured)}"
         )
         stim_instructions.append("}")
 
diff --git a/src/epic/modules/qec_primitives/syndrome_extraction/zxcoloring_extraction.py b/src/epic/modules/qec_primitives/syndrome_extraction/zxcoloring_extraction.py
index a824548..83391f3 100644
--- a/src/epic/modules/qec_primitives/syndrome_extraction/zxcoloring_extraction.py
+++ b/src/epic/modules/qec_primitives/syndrome_extraction/zxcoloring_extraction.py
@@ -2,19 +2,16 @@
 from uuid import UUID
 
 from epic.core.compilation.measurement_record import MeasurementRecordView
-from epic.core.compilation.quantum_memory import QuantumMemory
-from epic.core.data_structure.pauli import PauliChar, PauliEigenState
-from epic.core.data_structure.tanner_node import TannerNode
-from epic.core.qec_object.detector import (
+from epic.core.data_structure import PauliChar, PauliEigenState, TannerNode, TannerEdge
+from epic.core.qec_object import (
     Detector,
     DetectorGraphPort,
     NodeKnowledge,
     QubitPortState,
+    Measurement,
 )
-from epic.core.qec_object.measurement import Measurement
 from epic.core.qec_primitives.interfaces.extract_syndrome import ExtractSyndrome
 from epic.core.qec_primitives.interfaces.qec_primitive import PrimitiveImplementation
-from epic.core.data_structure.tanner_graph import TannerEdge
 
 
 class ZXColoringExtraction(PrimitiveImplementation[ExtractSyndrome]):
@@ -52,22 +49,29 @@ def _color_edges(edges: set[TannerEdge]) -> Tuple[Dict[TannerEdge, int], int]:
     def compile(
         self,
         instruction: ExtractSyndrome,
-        memory: QuantumMemory,
         record: MeasurementRecordView,
         det_graph_port: DetectorGraphPort,
         parent_gadget_id: UUID,
     ) -> Tuple[List[str], List[Measurement], List[Detector], DetectorGraphPort]:
 
+        check_nodes = instruction.target.check_nodes
         stim_instructions = []
         detectors = []
         measurements = []
 
-        # Alloc qubits if needed
-        to_alloc: List[TannerNode] = []
-        for n in instruction.target.variable_nodes | instruction.target.check_nodes:
-            if not memory.is_allocated(n):
-                to_alloc.append(n)
-        memory.allocate_qubits(to_alloc)
+        if len(check_nodes) > len(instruction.physical_ancilla_qubits):
+            raise ValueError(f"""
+                    Not enough physical ancilla qubits provided for syndrome extraction.
+                    Required: {len(check_nodes)}, Provided: {len(instruction.physical_ancilla_qubits)}
+                    This schedule expect 1 ancilla per check node.
+                    """)
+
+        checks_qubits = {
+            check: instruction.physical_ancilla_qubits[check] for check in check_nodes
+        }
+        data_qubits = instruction.physical_data_qubits
+
+        node_to_qubit = {**checks_qubits, **data_qubits}
 
         # Separate X and Z edges
         tanner = instruction.target
@@ -99,11 +103,11 @@ def compile(
         match instruction.ancilla_reset_state:
             case PauliEigenState.Z_plus:
                 stim_instructions.append(
-                    f"RZ {" ".join([str(memory.get_slot(check)) for check in check_nodes])}"
+                    f"RZ {" ".join([str(node_to_qubit[check].integer_index) for check in check_nodes])}"
                 )
             case PauliEigenState.X_plus:
                 stim_instructions.append(
-                    f"RX {" ".join([str(memory.get_slot(check)) for check in check_nodes])}"
+                    f"RX {" ".join([str(node_to_qubit[check].integer_index) for check in check_nodes])}"
                 )
             case _:
                 raise ValueError(
@@ -117,13 +121,13 @@ def compile(
         # X checks:
         if x_checks:
             single_round_instructions.append(
-                f"H {" ".join(str(memory.get_slot(xc)) for xc in x_checks)}"
+                f"H {" ".join(str(node_to_qubit[xc].integer_index) for xc in x_checks)}"
             )
             single_round_instructions.append("TICK")
         x_cnot_steps = [[] for _ in range(x_color_count + 1)]
         for edge in x_edges:
-            var_slot = memory.get_slot(edge.variable_node)
-            check_slot = memory.get_slot(edge.check_node)
+            var_slot = node_to_qubit[edge.variable_node].integer_index
+            check_slot = node_to_qubit[edge.check_node].integer_index
             color = x_coloring[edge]
             x_cnot_steps[color].append((check_slot, var_slot))
         for step in x_cnot_steps:
@@ -135,15 +139,15 @@ def compile(
             single_round_instructions.append("TICK")
         if x_checks:
             single_round_instructions.append(
-                f"H {" ".join(str(memory.get_slot(xc)) for xc in x_checks)}"
+                f"H {" ".join(str(node_to_qubit[xc].integer_index) for xc in x_checks)}"
             )
             single_round_instructions.append("TICK")
 
         # Z checks:
         z_cnot_steps = [[] for _ in range(z_color_count + 1)]
         for edge in z_edges:
-            var_slot = memory.get_slot(edge.variable_node)
-            check_slot = memory.get_slot(edge.check_node)
+            var_slot = node_to_qubit[edge.variable_node].integer_index
+            check_slot = node_to_qubit[edge.check_node].integer_index
             color = z_coloring[edge]
             z_cnot_steps[color].append((check_slot, var_slot))
         for step in z_cnot_steps:
@@ -157,7 +161,7 @@ def compile(
         # Measure ancilla qubits
         check_order = list(instruction.target.check_nodes)
         single_round_instructions.append(
-            f"MRZ {" ".join(str(memory.get_slot(c)) for c in check_order)}"
+            f"MRZ {" ".join(str(node_to_qubit[c].integer_index) for c in check_order)}"
         )
         stim_instructions.append(f"REPEAT {instruction.rounds} {{")
         stim_instructions.extend(
diff --git a/tests/core/compilation/test_qec_compiler.py b/tests/core/compilation/test_qec_compiler.py
index d1d48a5..618e7f4 100644
--- a/tests/core/compilation/test_qec_compiler.py
+++ b/tests/core/compilation/test_qec_compiler.py
@@ -29,9 +29,17 @@ class DummyCodeGadget(CodeGadget):
     updates: dict[UUID, LogicalOperatorUpdate] = Field(default_factory=dict)
     call_log: dict[str, Any] = Field(default_factory=dict)
 
-    def compile(self, resolved_targets, record, timestep, objective_distance):
+    def compile(
+        self,
+        resolved_targets,
+        record,
+        quantum_memory,
+        timestep,
+        objective_distance,
+    ):
         self.call_log["resolved_targets"] = resolved_targets
         self.call_log["record_size"] = len(record.measurements())
+        self.call_log["quantum_memory"] = quantum_memory
         self.call_log["timestep"] = timestep
         self.call_log["objective_distance"] = objective_distance
         primitives = cast(list[QECPrimitive], [self.primitive])
@@ -44,9 +52,17 @@ class DummyLogicGadget(LogicGadget):
     updates: dict[UUID, LogicalOperatorUpdate] = Field(default_factory=dict)
     call_log: dict[str, Any] = Field(default_factory=dict)
 
-    def compile(self, resolved_targets, record, timestep, objective_distance):
+    def compile(
+        self,
+        resolved_targets,
+        record,
+        quantum_memory,
+        timestep,
+        objective_distance,
+    ):
         self.call_log["resolved_targets"] = resolved_targets
         self.call_log["record_size"] = len(record.measurements())
+        self.call_log["quantum_memory"] = quantum_memory
         self.call_log["timestep"] = timestep
         self.call_log["objective_distance"] = objective_distance
         primitives = cast(list[QECPrimitive], [self.primitive])
@@ -85,7 +101,6 @@ def test_compile_runs_code_gadget_and_collects_outputs(
         def fake_compile(
             self,
             primitive_instruction,
-            memory,
             record,
             det_graph_port,
             parent_gadget_id,
@@ -112,6 +127,7 @@ def fake_compile(
 
         assert gadget.call_log["resolved_targets"] == [stabilizer_code]
         assert gadget.call_log["record_size"] == 0
+        assert gadget.call_log["quantum_memory"] == qec_compiler.ctx.quantum_memory
         assert gadget.call_log["timestep"] == 0
         assert gadget.call_log["objective_distance"] == 1
         assert compiled.record.view().measurements() == (measurement_a,)
@@ -149,7 +165,6 @@ def test_compile_runs_logic_gadget_and_visualization_hook(
         def fake_compile(
             self,
             primitive_instruction,
-            memory,
             record,
             det_graph_port,
             parent_gadget_id,
@@ -176,6 +191,7 @@ def fake_visualize(
         )
 
         assert gadget.call_log["resolved_targets"] == [(logical_qubit, stabilizer_code)]
+        assert gadget.call_log["quantum_memory"] == qec_compiler.ctx.quantum_memory
         assert compiled.circuit_instructions == ["M 0"]
         assert visualized["path"] == Path("visuals/out.svg")
         assert visualized["primitive"] == primitive
diff --git a/tests/core/compilation/test_quantum_memory.py b/tests/core/compilation/test_quantum_memory.py
index 2901359..308914a 100644
--- a/tests/core/compilation/test_quantum_memory.py
+++ b/tests/core/compilation/test_quantum_memory.py
@@ -6,6 +6,7 @@
 import pytest
 
 from epic.core.compilation.quantum_memory import QuantumMemory
+from epic.core.data_structure.physical_qubit import PhysicalQubit
 from epic.core.data_structure.tanner_node import VariableNode
 
 
@@ -21,13 +22,16 @@ def test_allocate_qubits_grows_capacity_and_assigns_slots(
         memory = QuantumMemory()
 
         slots = memory.allocate_qubits(memory_nodes[:2])
+        allocation = memory.data_qubits_allocation_snapshot(set(memory_nodes[:2]))
 
-        assert slots == [0, 1]
-        assert memory.size == 2
-        assert memory.slots == (0, 1)
+        assert len(slots) == 2
+        assert all(isinstance(slot, PhysicalQubit) for slot in slots)
+        assert memory.size == 1
+        assert {slot.integer_index for slot in slots} == {-1, 0}
+        assert {slot.integer_index for slot in memory.slots} == {-1, 0}
         assert memory.free_slots == ()
-        assert memory.get_slot(memory_nodes[0]) == 0
-        assert memory.get_slot(memory_nodes[1]) == 1
+        assert allocation[memory_nodes[0]] == slots[0]
+        assert allocation[memory_nodes[1]] == slots[1]
         assert memory.is_allocated(memory_nodes[0])
         assert memory.is_allocated(memory_nodes[1])
 
@@ -35,37 +39,41 @@ def test_allocate_qubits_reuses_freed_slots_before_growing(
         self, memory_nodes: list[VariableNode]
     ) -> None:
         memory = QuantumMemory()
-        memory.allocate_qubits(memory_nodes[:2])
+        initial_slots = memory.allocate_qubits(memory_nodes[:2])
         memory.free_qubits([memory_nodes[0]])
 
         slots = memory.allocate_qubits([memory_nodes[2]])
 
-        assert slots == [0]
-        assert memory.size == 2
-        assert memory.get_slot(memory_nodes[2]) == 0
+        assert slots == [initial_slots[0]]
+        assert memory.size == 1
+        assert (
+            memory.data_qubits_allocation_snapshot(
+                cast(set[VariableNode], {cast(Any, memory_nodes[2])})
+            )[memory_nodes[2]]
+            == initial_slots[0]
+        )
         assert not memory.is_allocated(memory_nodes[0])
         assert memory.free_slots == ()
 
-    def test_allocate_qubits_partially_reuses_free_slots_and_expands(
+    def test_allocate_qubits_raises_when_request_exceeds_available_capacity(
         self, memory_nodes: list[VariableNode]
     ) -> None:
         memory = QuantumMemory()
         memory.allocate_qubits(memory_nodes[:2])
         memory.free_qubits([memory_nodes[1]])
 
-        slots = memory.allocate_qubits(memory_nodes[2:4])
+        with pytest.raises(RuntimeError, match="Not enough free qubits"):
+            memory.allocate_qubits(memory_nodes[2:4])
 
-        assert slots == [1, 2]
-        assert memory.size == 3
-        assert memory.slots == (0, 1, 2)
-        assert memory.get_slot(memory_nodes[2]) == 1
-        assert memory.get_slot(memory_nodes[3]) == 2
+        assert memory.size == 1
+        assert not memory.is_allocated(memory_nodes[2])
+        assert not memory.is_allocated(memory_nodes[3])
 
     def test_free_qubits_releases_slots_and_updates_allocation(
         self, memory_nodes: list[VariableNode]
     ) -> None:
         memory = QuantumMemory()
-        memory.allocate_qubits(memory_nodes[:3])
+        allocated_qubits = memory.allocate_qubits(memory_nodes[:3])
 
         result = memory.free_qubits(memory_nodes[:2])
 
@@ -73,34 +81,36 @@ def test_free_qubits_releases_slots_and_updates_allocation(
         assert not memory.is_allocated(memory_nodes[0])
         assert not memory.is_allocated(memory_nodes[1])
         assert memory.is_allocated(memory_nodes[2])
-        assert memory.free_slots == (0, 1)
+        assert set(memory.free_slots) == set(allocated_qubits[:2])
 
-    def test_get_slot_raises_for_unallocated_qubit(
+    def test_get_physical_qubit_raises_for_unallocated_qubit(
         self, memory_nodes: list[VariableNode]
     ) -> None:
         memory = QuantumMemory()
 
         with pytest.raises(KeyError):
-            memory.get_slot(memory_nodes[0])
+            memory.get_physical_qubit(memory_nodes[0])
 
     def test_free_qubits_raises_for_unallocated_qubit(
         self, memory_nodes: list[VariableNode]
     ) -> None:
         memory = QuantumMemory()
 
-        with pytest.raises(KeyError):
+        with pytest.raises(RuntimeError, match="is not currently allocated"):
             memory.free_qubits([memory_nodes[0]])
 
-    def test_allocation_property_exposes_read_only_view(
+    def test_data_qubits_allocation_snapshot_exposes_read_only_view(
         self, memory_nodes: list[VariableNode]
     ) -> None:
         memory = QuantumMemory()
-        memory.allocate_qubits([memory_nodes[0]])
+        allocated_qubit = memory.allocate_qubits([memory_nodes[0]])[0]
 
-        allocation = memory.allocation
+        allocation = memory.data_qubits_allocation_snapshot(
+            cast(set[VariableNode], {cast(Any, memory_nodes[0])})
+        )
         unsafe_allocation = cast(Any, allocation)
 
         assert isinstance(allocation, MappingProxyType)
-        assert allocation[memory_nodes[0]] == 0
+        assert allocation[memory_nodes[0]] == allocated_qubit
         with pytest.raises(TypeError):
-            unsafe_allocation[memory_nodes[1]] = 1
+            unsafe_allocation[memory_nodes[1]] = allocated_qubit

From 9ecacb91be846b19f243d99eef8bca9fd5332acb Mon Sep 17 00:00:00 2001
From: Lenny <lenny@delzio.ch>
Date: Fri, 15 May 2026 17:20:55 +0100
Subject: [PATCH 2/6] add file

---
 .../core/data_structure/physical_qubit.py     | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 src/epic/core/data_structure/physical_qubit.py

diff --git a/src/epic/core/data_structure/physical_qubit.py b/src/epic/core/data_structure/physical_qubit.py
new file mode 100644
index 0000000..b9d2cdd
--- /dev/null
+++ b/src/epic/core/data_structure/physical_qubit.py
@@ -0,0 +1,23 @@
+from uuid import UUID, uuid4
+
+from pydantic import Field
+from pydantic.dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class PhysicalQubit:
+    """Class representing a physical qubit in the quantum memory."""
+
+    integer_index: int = Field(
+        description="Index refs used in Stim",
+    )
+
+    position: tuple[float, ...] = Field(
+        description="Position of the physical qubit in a multi-dimensional space.",
+        default=(),
+    )
+
+    id: UUID = Field(
+        description="Unique identifier of the physical qubit",
+        default_factory=uuid4,
+    )

From 1429bd819cd9b2bf3deafce28b601f364b7b08b0 Mon Sep 17 00:00:00 2001
From: Lenny <lenny@delzio.ch>
Date: Fri, 15 May 2026 18:07:34 +0100
Subject: [PATCH 3/6] fix init

---
 src/epic/modules/qec_gadgets/logical_resets/init_code.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/epic/modules/qec_gadgets/logical_resets/init_code.py b/src/epic/modules/qec_gadgets/logical_resets/init_code.py
index ffea0e5..0f628bc 100644
--- a/src/epic/modules/qec_gadgets/logical_resets/init_code.py
+++ b/src/epic/modules/qec_gadgets/logical_resets/init_code.py
@@ -65,8 +65,9 @@ def compile(
                     physical_data_qubits=quantum_memory.data_qubits_allocation_snapshot(
                         code.tanner_graph.variable_nodes
                     ),
-                    physical_ancilla_qubits={},
-                    target_nodes=code.tanner_graph.variable_nodes,  # type: ignore
+                    physical_ancilla_qubits=ancilla_locked[code.id],
+                    target_nodes=code.tanner_graph.variable_nodes
+                    | code.tanner_graph.check_nodes,  # type: ignore
                     gates=gates,
                 )
             )

From b25fc5f72717d6ea7fcb26e7076b0409b6834f9c Mon Sep 17 00:00:00 2001
From: Lenny <lenny@delzio.ch>
Date: Fri, 15 May 2026 18:27:35 +0100
Subject: [PATCH 4/6] edit doc

---
 docs/core_logic.md     |  6 +++---
 docs/qec_gadget.md     | 34 ++++++++++++++++++++++++++++++++++
 docs/qec_primitives.md | 26 +++++++++++---------------
 3 files changed, 48 insertions(+), 18 deletions(-)

diff --git a/docs/core_logic.md b/docs/core_logic.md
index d5b5806..86c7a85 100644
--- a/docs/core_logic.md
+++ b/docs/core_logic.md
@@ -36,18 +36,18 @@ The context stores the following data:
 - `operator_to_qubits`: a map from a logical operator's ID to the ID of the logical qubit it belongs to.
 - `qubit_to_code`: similar to the previous one, but for logical qubits belonging to a code.
 - `detector_port`: a state object used to create detectors between primitives. See the [primitives guide](qec_primitives.md) for more details.
-- `quantum_memory`: a `QuantumMemory` object that stores the assignment of physical qubits to Tanner-graph nodes.
+- `quantum_memory`: a `QuantumMemory` object that stores the assignment of physical qubits to the data nodes and a pool of ancilla available for the gadget to reserve.
 - `measurement_record`: a `MeasurementRecord` object that stores all measurements, alongside indexing that allows them to be explored efficiently.
 - `compilation_time`: a kind of internal clock tracking which cycle we are in. This is not really used, though.
 
 Although the logic is quite straightforward, the following points are worth noting:
- - First, when codes are allocated, they are added to the context's memory alongside their logical qubits and the corresponding logical operators. The context stores these structures until they are freed. While they are stored, we expect that nothing will modify them, except for logical-operator corrections, which are handled only by the compiler itself.
+ - First, when codes are allocated, they are added to the context's memory alongside their logical qubits and the corresponding logical operators. The context stores these structures until they are freed. While they are stored, we expect that nothing will modify them, except for logical-operator corrections, which are handled only by the compiler itself. When allocated, physical qubits are assigned to each data qubits of the code (not to checks, as they aren't necessary map 1-1 with physical qubits).
 
 - Second, logical-operator corrections are added to the logical operators at the end of each gadget, in `ctx.add_updates(lop_updates)` in the pseudocode. They are stored within the `LogicalOperator` object itself as a list of measurements, which will flip the observable outcome if their outcome parity is odd.
 
 - Finally, observables are "resolved" when they are added to the context. This means that we append to their set of measurements the corrections that exist in each of the logical operators involved in the observables, and we correctly refer the measurements to those created by the primitives.
 
-Also, the context is supposed to be modified only by the compiler, so we tried, as much as possible, to provide only views of the different objects to gadgets and primitives. Quantum memory is still allocated inside primitives, which is not ideal. This will be fixed in the near future; see the targeted design fix here.
+Also, the context is supposed to be modified only by the compiler, so we tried, as much as possible, to provide only views of the different objects to gadgets and primitives. Quantum memory is given to gadgets, that are allowed to lock/free ancillas. This is not ideal, and we'll eventually find a way to restrict the interface.
  
 
 
diff --git a/docs/qec_gadget.md b/docs/qec_gadget.md
index b382068..1b63ff7 100644
--- a/docs/qec_gadget.md
+++ b/docs/qec_gadget.md
@@ -15,6 +15,7 @@ def compile(
         self,
         resolved_targets: List[StabilizerCode], # List[Tuple[LogicalQubit, StabilizerCode]]
         record: MeasurementRecordView,
+        quantum_memory: QuantumMemory,
         timestep: int,
         objective_distance: int,
     ) -> Tuple[Dict[UUID, LogicalOperatorUpdate], List[Observable], List[QECPrimitive]]:
@@ -22,6 +23,7 @@ def compile(
 
 The function is given the resolved targets, which are codes for `CodeGadget` and logical qubits with their host codes for `LogicGadget`. It also receives the following information from the compiler:
 - A view of the measurement record, which is an object maintained by the compiler that contains the measurements performed so far. *Why though? I'm not sure anymore, and I should remove this parameter ASAP.*
+- An access to the quantum memory, to reserve eventally needed ancilla and to be aware of the data qubits assignement.
 - The timestep, which indicates the position at which this gadget was processed by the compiler.
 - The objective distance of the whole experiment. This can typically be used to determine how many rounds of error correction should be performed.
 
@@ -50,6 +52,7 @@ class RSCSurgery(LogicGadget):
         self,
         resolved_targets: List[Tuple[LogicalQubit, StabilizerCode]],
         record,
+        quantum_memory,
         timestep,
         objective_distance: int,
     ) -> Tuple[Dict[UUID, LogicalOperatorUpdate], List[Observable], List[QECPrimitive]]:
@@ -80,10 +83,21 @@ class RSCSurgery(LogicGadget):
             code1.tanner_graph | code2.tanner_graph, connecting_edges
         )
 
+        # Get ancilla for the ancilla data qubits in the merge
+        # And for the checks, so that we can use them to measure the stabilizser
+        # Make sure to unlock them at the end
+        ancilla = quantum_memory.lock_ancilla_qubits(n=len(ancilla_system.variable_nodes + merged_code.check_nodes), requestor_id=self.id)
+
+        # map ancilla to node so we always reuse the same
+        # This is not strictly necessary, and we could for example reserve less ancilla and use them to measure several different stabilizers
+        ancilla_qubits_to_node = {...}
+
         # Primitive 1: initialize the ancilla qubits in the right basis.
         init_ancilla = ApplyGate(
             target=ancilla_system,
             target_nodes=ancilla_system.variable_nodes | ancilla_system.check_nodes,  # type: ignore
+            physical_data_qubits={k: v for k, v in ancilla_qubits_to_node.items() if isinstance(k, VariableNode)},  # type: ignore
+            physical_ancilla_qubits=ancilla_qubits_to_node,
             gates=(
                 ["RX"] if m_type == PauliChar.Z else ["RZ"]
             ),  # Initialize in the dual basis of the merge type.
@@ -92,6 +106,11 @@ class RSCSurgery(LogicGadget):
         # Primitive 2: do d rounds of syndrome measurement on the merged system.
         merged_syndrome = ExtractSyndrome(
             target=merged_system,
+            physical_data_qubits=quantum_memory.data_qubits_allocation_snapshot(
+                merged_system.variable_nodes
+            )
+            | {k: v for k, v in ancilla_qubits_to_node.items() if isinstance(k, VariableNode)},
+            physical_ancilla_qubits=ancilla_qubits_to_node,
             rounds=objective_distance,
             tag=f"rsc_surgery_merged_syndrome_{self.tag}",
         )
@@ -99,6 +118,12 @@ class RSCSurgery(LogicGadget):
         # Primitive 3: read out the ancilla system in the right basis.
         ancilla_readout = Readout(
             target=ancilla_system,
+            physical_data_qubits={
+                k: v
+                for k, v in ancilla_qubits_to_node.items()
+                if isinstance(k, VariableNode)
+            },
+            physical_ancilla_qubits=ancilla_qubits_to_node,
             readout_basis=m_type.dual(),
             tag=f"rsc_surgery_measurement_{self.tag}",
         )
@@ -107,6 +132,10 @@ class RSCSurgery(LogicGadget):
         split_syndrome = [
             ExtractSyndrome(
                 target=initial_code,
+                physical_data_qubits=quantum_memory.data_qubits_allocation_snapshot(
+                    initial_code.variable_nodes
+                ),
+                physical_ancilla_qubits=ancilla_qubits_to_node,
                 rounds=objective_distance,
                 tag=f"rsc_surgery_split_syndrome_{self.tag}",
             )
@@ -151,6 +180,10 @@ class RSCSurgery(LogicGadget):
             ),
         }
 
+        quantum_memory.unlock_ancilla_qubits(
+            qubits=list(ancilla), owner_id=self.id
+        )
+
         return correction, observable, primitives
 ```
 
@@ -159,6 +192,7 @@ Although the full implementation may require some tedious computation to navigat
 We now state some important points to remember when implementing a gadget:
 - The state, meaning the Tanner-graph structure, of the stabilizer-code object must not be changed by the gadget. To build the merged code, for example, we build a Tanner graph that uses references to the code's graph, but we do not modify it.
 - The logical operators must not be changed directly. We only provide `LogicalOperatorUpdate`, which will be processed by the compiler after the gadget is processed. These corrections will be effective only in the next gadget. A logical-operator update can also remap the logical operator to some other support, as long as it stays within the same code.
+- All the ancilla reserved (locked) should be unlock. Otherwise they will not be reusable by the next gadgets.
 - The measurements in the observables and corrections must include the primitive ID and the gadget ID. Then the compiler will associate them with the last measurement instruction of the given node ID that was added in the corresponding primitive.
 - The observable's tag is used as the variable name for it.
 - If the observable corresponds to a logical measurement, it must specify which logical operators are associated with it. This is required so that the compiler can complete it with the corrections previously added to these logical operators.
diff --git a/docs/qec_primitives.md b/docs/qec_primitives.md
index dfb1878..c0c00ff 100644
--- a/docs/qec_primitives.md
+++ b/docs/qec_primitives.md
@@ -25,8 +25,6 @@ class ImplementationName(PrimitiveImplementation[ApplyGate]):
     def compile(
         self,
         instruction: ApplyGate,
-        memory: QuantumMemory,
-        
         record: MeasurementRecordView,
         det_graph_port: DetectorGraphPort,
         parent_gadget_id: UUID,
@@ -38,7 +36,6 @@ The class must inherit from `PrimitiveImplementation[<...>]`, where the placehol
 `QECPrimitive` instruction that is implemented. The `compile` method then builds the expected information.
 It receives the following as input:
 - An instruction, which is the implemented `QECPrimitive`.
-- The quantum memory being used. This is important because primitives are responsible for allocating qubits if necessary.
 - A view of the measurement record, which can be used when building detectors between two primitives.
 - A detector graph port, which provides information on the states of the qubits in the previous primitive in order to build detectors correctly.
 - The ID of the gadget using the primitive.
@@ -59,7 +56,6 @@ class RSCSyndromeExtraction(PrimitiveImplementation[ExtractSyndrome]):
     def compile(
         self,
         instruction: ExtractSyndrome,
-        memory: QuantumMemory,
         record: MeasurementRecordView,
         det_graph_port: DetectorGraphPort,
         parent_gadget_id: UUID,
@@ -71,16 +67,16 @@ class RSCSyndromeExtraction(PrimitiveImplementation[ExtractSyndrome]):
         measurements_ordered: List[Measurement] = []
         detectors: List[Detector] = []
 
-        # Allocate the nodes that are not allocated yet.
-        to_alloc: List[TannerNode] = []
-        for n in instruction.target.variable_nodes | instruction.target.check_nodes:
-            if not memory.is_allocated(n):
-                to_alloc.append(n)
-        memory.allocate_qubits(to_alloc)
+        # Physical qubits that we are allowed to used are given in the instruction.
+        checks_qubits = {
+            check: instruction.physical_ancilla_qubits[check] for check in check_nodes
+        }
+        data_qubits = instruction.physical_data_qubits
+        node_to_qubit = {**checks_qubits, **data_qubits}
 
         # Reset the ancilla used to measure the syndromes.
         stim_instructions.extend(
-            f"RZ {" ".join([str(memory.get_slot(check)) for check in check_nodes])}"
+            f"RZ {" ".join([str(node_to_qubit[check].integer_index) for check in check_nodes])}"
         )
 
         # Build the syndrome-extraction circuit for one round.
@@ -122,20 +118,20 @@ class RSCSyndromeExtraction(PrimitiveImplementation[ExtractSyndrome]):
 
         single_round_instructions.append("TICK")
         single_round_instructions.append(
-            f"H {" ".join(str(memory.get_slot(xc)) for xc in x_checks)}"
+            f"H {" ".join(str(node_to_qubit[xc].integer_index) for xc in x_checks)}"
         )
         single_round_instructions.append("TICK")
         for t in [t1, t2, t3, t4]:
             single_round_instructions.append(
-                f"CX {" ".join(f"{str(memory.get_slot(con))} {str(memory.get_slot(tar))}" for con, tar in t)}"
+                f"CX {" ".join(f"{str(node_to_qubit[con].integer_index)} {str(node_to_qubit[tar].integer_index)}" for con, tar in t)}"
             )
             single_round_instructions.append("TICK")
         single_round_instructions.append(
-            f"H {" ".join(str(memory.get_slot(xc)) for xc in x_checks)}"
+            f"H {" ".join(str(node_to_qubit[xc].integer_index) for xc in x_checks)}"
         )
         single_round_instructions.append("TICK")
         single_round_instructions.append(
-            f"MRZ {" ".join(str(memory.get_slot(c)) for c in node_measured)}"
+            f"MRZ {" ".join(str(node_to_qubit[c].integer_index) for c in node_measured)}"
         )
 
         # Repeat the round.

From 682ea080c68a011f3017c0b726557b22dd9790b3 Mon Sep 17 00:00:00 2001
From: Lenny <lenny@delzio.ch>
Date: Fri, 15 May 2026 18:37:09 +0100
Subject: [PATCH 5/6] fix mem test

---
 src/epic/core/compilation/quantum_memory.py   | 16 +++++++++++++++-
 tests/core/compilation/test_quantum_memory.py | 12 ++++++------
 2 files changed, 21 insertions(+), 7 deletions(-)

diff --git a/src/epic/core/compilation/quantum_memory.py b/src/epic/core/compilation/quantum_memory.py
index 51a349d..c2a07d3 100644
--- a/src/epic/core/compilation/quantum_memory.py
+++ b/src/epic/core/compilation/quantum_memory.py
@@ -3,7 +3,7 @@
 from typing import Set
 from uuid import UUID
 
-from pydantic import BaseModel, Field, PrivateAttr
+from pydantic import BaseModel, Field, PrivateAttr, model_validator
 
 from ..data_structure import VariableNode, PhysicalQubit
 
@@ -20,6 +20,20 @@ class QuantumMemory(BaseModel):
         default=0,
     )
 
+    @model_validator(mode="after")
+    def validate_size(cls, model):
+        if model.size_limit == -1:
+            return model
+        else:
+            model.size = model.size_limit
+            model._existing_qubits.update(
+                PhysicalQubit(integer_index=i) for i in range(model.size_limit)
+            )
+            model._free_qubits.update(
+                PhysicalQubit(integer_index=i) for i in range(model.size_limit)
+            )
+            return model
+
     _existing_qubits: set[PhysicalQubit] = PrivateAttr(default_factory=set)
     _free_qubits: set[PhysicalQubit] = PrivateAttr(default_factory=set)
 
diff --git a/tests/core/compilation/test_quantum_memory.py b/tests/core/compilation/test_quantum_memory.py
index 308914a..fe5686c 100644
--- a/tests/core/compilation/test_quantum_memory.py
+++ b/tests/core/compilation/test_quantum_memory.py
@@ -26,9 +26,9 @@ def test_allocate_qubits_grows_capacity_and_assigns_slots(
 
         assert len(slots) == 2
         assert all(isinstance(slot, PhysicalQubit) for slot in slots)
-        assert memory.size == 1
-        assert {slot.integer_index for slot in slots} == {-1, 0}
-        assert {slot.integer_index for slot in memory.slots} == {-1, 0}
+        assert memory.size == 2
+        assert {slot.integer_index for slot in slots} == {0, 1}
+        assert {slot.integer_index for slot in memory.slots} == {0, 1}
         assert memory.free_slots == ()
         assert allocation[memory_nodes[0]] == slots[0]
         assert allocation[memory_nodes[1]] == slots[1]
@@ -45,7 +45,7 @@ def test_allocate_qubits_reuses_freed_slots_before_growing(
         slots = memory.allocate_qubits([memory_nodes[2]])
 
         assert slots == [initial_slots[0]]
-        assert memory.size == 1
+        assert memory.size == 2
         assert (
             memory.data_qubits_allocation_snapshot(
                 cast(set[VariableNode], {cast(Any, memory_nodes[2])})
@@ -58,14 +58,14 @@ def test_allocate_qubits_reuses_freed_slots_before_growing(
     def test_allocate_qubits_raises_when_request_exceeds_available_capacity(
         self, memory_nodes: list[VariableNode]
     ) -> None:
-        memory = QuantumMemory()
+        memory = QuantumMemory(size_limit=2)
         memory.allocate_qubits(memory_nodes[:2])
         memory.free_qubits([memory_nodes[1]])
 
         with pytest.raises(RuntimeError, match="Not enough free qubits"):
             memory.allocate_qubits(memory_nodes[2:4])
 
-        assert memory.size == 1
+        assert memory.size == 2
         assert not memory.is_allocated(memory_nodes[2])
         assert not memory.is_allocated(memory_nodes[3])
 

From c0d94c2adc57ec6d46772c10ab382b01ae531689 Mon Sep 17 00:00:00 2001
From: Lenny <lenny@delzio.ch>
Date: Mon, 18 May 2026 08:44:04 +0100
Subject: [PATCH 6/6] memory fixed

---
 docs/getting_started.ipynb | 353 +++++++++++++++++++------------------
 1 file changed, 180 insertions(+), 173 deletions(-)

diff --git a/docs/getting_started.ipynb b/docs/getting_started.ipynb
index 1d50066..0807256 100644
--- a/docs/getting_started.ipynb
+++ b/docs/getting_started.ipynb
@@ -16,7 +16,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 13,
    "id": "19bc88b3",
    "metadata": {},
    "outputs": [],
@@ -41,7 +41,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 14,
    "id": "8689def6",
    "metadata": {},
    "outputs": [],
@@ -122,7 +122,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 15,
    "id": "f5112dfb",
    "metadata": {},
    "outputs": [],
@@ -134,7 +134,6 @@
     "        \"epic.core.qec_primitives.interfaces.ExtractSyndrome\": \"epic.modules.qec_primitives.RSCSyndromeExtraction\",\n",
     "    },\n",
     "    \"objective_distance\": 3,\n",
-    "    \"physical_qubits_limit\": -1,\n",
     "}"
    ]
   },
@@ -148,7 +147,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 16,
    "id": "6c785daf",
    "metadata": {},
    "outputs": [
@@ -156,198 +155,204 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "RX 4 6 2 5 1 8 7 3 0\n",
+      "RX 34 7 28 8 1 33 32 31 6 30 29 5 0 27 2 4 3\n",
       "# RSC syndrome extraction \n",
-      "RZ 33 28 32 30 27 29 31 34\n",
+      "RZ 31 33 27 30 34 32 29 28\n",
       "REPEAT 3 {\n",
       "   TICK\n",
-      "   H 33 28 32 27\n",
+      "   H 27 34 32 29\n",
       "   TICK\n",
-      "   CX 28 4 32 7 0 30 27 8 2 29 1 31\n",
+      "   CX 7 31 6 33 27 3 1 30 34 2 32 5\n",
       "   TICK\n",
-      "   CX 28 2 32 1 7 30 27 6 3 29 8 31\n",
+      "   CX 3 31 5 33 27 6 8 30 34 1 32 0\n",
       "   TICK\n",
-      "   CX 33 0 28 1 32 5 4 30 3 31 7 34\n",
+      "   CX 2 31 8 33 27 4 34 6 29 7 3 28\n",
       "   TICK\n",
-      "   CX 33 4 28 3 32 8 1 30 6 31 5 34\n",
+      "   CX 6 31 0 33 27 5 34 8 29 2 4 28\n",
       "   TICK\n",
-      "   H 33 28 32 27\n",
+      "   H 27 34 32 29\n",
       "   TICK\n",
-      "   MRZ 33 28 32 30 27 29 31 34\n",
+      "   MRZ 31 33 27 30 34 32 29 28\n",
       "}\n",
-      "RZ 9 14 17 12 16 13 11 10 15\n",
+      "RZ 29 10 32 17 33 15 16 34 13 14 28 12 31 27 30 9 11\n",
       "# RSC syndrome extraction \n",
-      "RZ 33 32 28 30 29 27 31 34\n",
+      "RZ 31 33 27 30 34 32 29 28\n",
       "REPEAT 3 {\n",
       "   TICK\n",
-      "   H 32 30 27 31\n",
+      "   H 31 30 34 32\n",
       "   TICK\n",
-      "   CX 13 33 14 28 30 12 27 9 31 17 16 34\n",
+      "   CX 31 13 15 33 30 14 34 12 11 29 10 28\n",
       "   TICK\n",
-      "   CX 9 33 17 28 30 16 27 14 31 15 10 34\n",
+      "   CX 31 11 12 33 30 16 34 10 17 29 14 28\n",
       "   TICK\n",
-      "   CX 12 33 32 13 10 28 30 14 9 29 27 11\n",
+      "   CX 31 10 13 33 12 27 34 9 32 15 17 28\n",
       "   TICK\n",
-      "   CX 14 33 32 12 15 28 30 10 11 29 27 17\n",
+      "   CX 31 17 10 33 9 27 34 14 32 13 16 28\n",
       "   TICK\n",
-      "   H 32 30 27 31\n",
+      "   H 31 30 34 32\n",
       "   TICK\n",
-      "   MRZ 33 32 28 30 29 27 31 34\n",
+      "   MRZ 31 33 27 30 34 32 29 28\n",
       "}\n",
-      "RZ 19 21 25 26 20 24 23 18 22\n",
+      "RZ 31 18 28 32 25 30 29 22 20 19 27 24 26 21 23 33 34\n",
       "# RSC syndrome extraction \n",
-      "RZ 33 28 32 30 27 29 31 34\n",
+      "RZ 31 33 27 30 34 32 29 28\n",
       "REPEAT 3 {\n",
       "   TICK\n",
-      "   H 33 30 29 34\n",
+      "   H 31 33 27 30\n",
       "   TICK\n",
-      "   CX 26 28 25 32 30 18 23 27 29 20 34 22\n",
+      "   CX 31 19 33 20 27 22 23 34 25 32 18 29\n",
       "   TICK\n",
-      "   CX 22 28 21 32 30 25 20 27 29 26 34 19\n",
+      "   CX 31 25 33 24 27 18 19 34 20 32 21 29\n",
       "   TICK\n",
-      "   CX 33 23 21 28 30 26 18 27 29 24 20 31\n",
+      "   CX 31 26 27 25 30 23 22 34 21 32 19 28\n",
       "   TICK\n",
-      "   CX 33 18 19 28 30 21 26 27 29 22 24 31\n",
+      "   CX 31 20 27 21 30 22 25 34 24 32 26 28\n",
       "   TICK\n",
-      "   H 33 30 29 34\n",
+      "   H 31 33 27 30\n",
       "   TICK\n",
-      "   MRZ 33 28 32 30 27 29 31 34\n",
+      "   MRZ 31 33 27 30 34 32 29 28\n",
       "}\n",
-      "RX 29 35 42 44 45 49 33\n",
+      "RX 40 37 31 28 32 29 43\n",
       "# RSC syndrome extraction rsc_surgery_merged_syndrome_MZZ_ac\n",
-      "RZ 45 36 33 32 37 39 47 28 40 48 44 41 46 34 30 31 27 43 35 38\n",
+      "RZ 42 30 43 46 37 49 44 34 32 27 36 35 29 41 45 47 38 48 33 39\n",
       "REPEAT 3 {\n",
       "   TICK\n",
-      "   H 36 32 37 28 48 41 31 43\n",
+      "   H 42 49 34 36 35 38 48 33\n",
       "   TICK\n",
-      "   CX 6 45 36 4 5 33 32 12 37 8 2 47 28 9 1 40 41 7 0 46 16 34 13 30 31 29 14 27 43 17 49 35\n",
+      "   CX 42 13 7 30 4 43 15 46 31 37 49 14 11 44 34 5 35 3 0 29 6 45 1 47 38 2 48 12 33 40 10 39\n",
       "   TICK\n",
-      "   CX 42 45 36 2 29 33 32 16 37 6 3 47 28 14 8 40 41 1 7 46 10 34 9 30 31 49 17 27 43 15 12 35\n",
+      "   CX 42 11 3 30 40 43 12 46 13 37 49 16 17 44 34 0 35 6 28 29 5 45 8 47 38 1 48 10 33 31 14 39\n",
       "   TICK\n",
-      "   CX 36 1 8 33 32 14 37 49 9 39 28 11 3 40 48 0 29 44 41 5 4 46 12 30 31 13 10 27 42 35 7 38\n",
+      "   CX 42 10 2 30 5 43 13 46 28 37 34 31 40 32 12 27 36 7 35 4 3 41 8 45 38 6 48 9 33 15 17 39\n",
       "   TICK\n",
-      "   CX 36 3 49 33 32 10 37 42 11 39 28 17 6 40 48 4 13 44 41 8 1 46 14 30 31 12 15 27 16 35 5 38\n",
+      "   CX 42 17 6 30 31 43 10 46 11 37 34 28 15 32 9 27 36 2 35 5 4 41 0 45 38 8 48 14 33 13 16 39\n",
       "   TICK\n",
-      "   H 36 32 37 28 48 41 31 43\n",
+      "   H 42 49 34 36 35 38 48 33\n",
       "   TICK\n",
-      "   MRZ 45 36 33 32 37 39 47 28 40 48 44 41 46 34 30 31 27 43 35 38\n",
+      "   MRZ 42 30 43 46 37 49 44 34 32 27 36 35 29 41 45 47 38 48 33 39\n",
       "}\n",
-      "MX 49 42 29\n",
+      "MX 28 40 31\n",
       "# RSC syndrome extraction rsc_surgery_split_syndrome_MZZ_ac\n",
-      "RZ 30 31 27 32 39 28 43 34\n",
+      "RZ 42 46 27 49 48 33 44 39\n",
       "REPEAT 3 {\n",
       "   TICK\n",
-      "   H 31 32 28 43\n",
+      "   H 42 49 48 33\n",
       "   TICK\n",
-      "   CX 13 30 14 27 32 12 28 9 43 17 16 34\n",
+      "   CX 42 13 15 46 49 14 48 12 11 44 10 39\n",
       "   TICK\n",
-      "   CX 9 30 17 27 32 16 28 14 43 15 10 34\n",
+      "   CX 42 11 12 46 49 16 48 10 17 44 14 39\n",
       "   TICK\n",
-      "   CX 12 30 31 13 10 27 32 14 9 39 28 11\n",
+      "   CX 42 10 13 46 12 27 48 9 33 15 17 39\n",
       "   TICK\n",
-      "   CX 14 30 31 12 15 27 32 10 11 39 28 17\n",
+      "   CX 42 17 10 46 9 27 48 14 33 13 16 39\n",
       "   TICK\n",
-      "   H 31 32 28 43\n",
+      "   H 42 49 48 33\n",
       "   TICK\n",
-      "   MRZ 30 31 27 32 39 28 43 34\n",
+      "   MRZ 42 46 27 49 48 33 44 39\n",
       "}\n",
       "# RSC syndrome extraction rsc_surgery_split_syndrome_MZZ_ac\n",
-      "RZ 48 36 41 46 37 47 40 38\n",
+      "RZ 30 45 35 47 38 34 36 41\n",
       "REPEAT 3 {\n",
       "   TICK\n",
-      "   H 48 36 41 37\n",
+      "   H 35 38 34 36\n",
       "   TICK\n",
-      "   CX 36 4 41 7 0 46 37 8 2 47 1 40\n",
+      "   CX 7 30 6 45 35 3 1 47 38 2 34 5\n",
       "   TICK\n",
-      "   CX 36 2 41 1 7 46 37 6 3 47 8 40\n",
+      "   CX 3 30 5 45 35 6 8 47 38 1 34 0\n",
       "   TICK\n",
-      "   CX 48 0 36 1 41 5 4 46 3 40 7 38\n",
+      "   CX 2 30 8 45 35 4 38 6 36 7 3 41\n",
       "   TICK\n",
-      "   CX 48 4 36 3 41 8 1 46 6 40 5 38\n",
+      "   CX 6 30 0 45 35 5 38 8 36 2 4 41\n",
       "   TICK\n",
-      "   H 48 36 41 37\n",
+      "   H 35 38 34 36\n",
       "   TICK\n",
-      "   MRZ 48 36 41 46 37 47 40 38\n",
+      "   MRZ 30 45 35 47 38 34 36 41\n",
       "}\n",
-      "RZ 45 38 39 49 47 32 43\n",
+      "RZ 29 37 49 28 36 42 27\n",
       "# RSC syndrome extraction rsc_surgery_merged_syndrome_MXX_ct\n",
-      "RZ 30 29 33 32 37 42 28 40 43 48 44 41 46 34 38 49 31 27 35 36\n",
+      "RZ 30 35 37 44 41 34 48 40 43 46 49 32 45 28 39 31 47 38 33 36\n",
       "REPEAT 3 {\n",
       "   TICK\n",
-      "   H 30 29 33 32 28 40 43 44 34 38 49 31\n",
+      "   H 35 37 44 34 43 46 49 28 31 47 38 36\n",
       "   TICK\n",
-      "   CX 30 18 29 4 33 8 2 37 1 42 43 21 26 48 44 7 23 41 0 46 34 22 38 45 49 47 31 20 25 35 39 36\n",
+      "   CX 7 30 35 19 37 29 44 22 25 41 34 5 23 48 46 3 49 21 27 32 6 45 1 39 31 2 47 20 18 33 36 42\n",
       "   TICK\n",
-      "   CX 30 25 29 2 33 6 3 37 8 42 43 39 22 48 44 1 20 41 7 46 34 19 38 5 49 0 31 26 21 35 45 36\n",
+      "   CX 3 30 35 25 37 7 44 18 20 41 34 0 19 48 46 6 49 27 42 32 5 45 8 39 31 1 47 24 21 33 36 4\n",
       "   TICK\n",
-      "   CX 30 26 29 1 32 25 3 42 28 0 40 23 43 19 21 48 44 5 18 41 4 46 49 39 31 24 20 27 47 35 7 36\n",
+      "   CX 2 30 35 26 37 27 44 25 21 41 22 48 19 40 43 7 46 4 49 24 3 32 8 45 28 18 31 6 38 23 29 33\n",
       "   TICK\n",
-      "   CX 30 21 29 3 32 47 6 42 28 4 40 18 43 45 19 48 44 8 26 41 1 46 49 7 31 22 24 27 39 35 5 36\n",
+      "   CX 6 30 35 20 37 3 44 21 24 41 25 48 26 40 43 2 46 5 49 42 4 32 0 45 28 29 31 8 38 22 27 33\n",
       "   TICK\n",
-      "   H 30 29 33 32 28 40 43 44 34 38 49 31\n",
+      "   H 35 37 44 34 43 46 49 28 31 47 38 36\n",
       "   TICK\n",
-      "   MRZ 30 29 33 32 37 42 28 40 43 48 44 41 46 34 38 49 31 27 35 36\n",
+      "   MRZ 30 35 37 44 41 34 48 40 43 46 49 32 45 28 39 31 47 38 33 36\n",
       "}\n",
-      "MZ 45 39 47\n",
+      "MZ 27 42 29\n",
       "# RSC syndrome extraction rsc_surgery_split_syndrome_MXX_ct\n",
-      "RZ 28 29 44 46 33 37 42 36\n",
+      "RZ 30 45 46 39 31 34 43 32\n",
       "REPEAT 3 {\n",
       "   TICK\n",
-      "   H 28 29 44 33\n",
+      "   H 46 31 34 43\n",
       "   TICK\n",
-      "   CX 29 4 44 7 0 46 33 8 2 37 1 42\n",
+      "   CX 7 30 6 45 46 3 1 39 31 2 34 5\n",
       "   TICK\n",
-      "   CX 29 2 44 1 7 46 33 6 3 37 8 42\n",
+      "   CX 3 30 5 45 46 6 8 39 31 1 34 0\n",
       "   TICK\n",
-      "   CX 28 0 29 1 44 5 4 46 3 42 7 36\n",
+      "   CX 2 30 8 45 46 4 31 6 43 7 3 32\n",
       "   TICK\n",
-      "   CX 28 4 29 3 44 8 1 46 6 42 5 36\n",
+      "   CX 6 30 0 45 46 5 31 8 43 2 4 32\n",
       "   TICK\n",
-      "   H 28 29 44 33\n",
+      "   H 46 31 34 43\n",
       "   TICK\n",
-      "   MRZ 28 29 44 46 33 37 42 36\n",
+      "   MRZ 30 45 46 39 31 34 43 32\n",
       "}\n",
       "# RSC syndrome extraction rsc_surgery_split_syndrome_MXX_ct\n",
-      "RZ 40 48 35 30 41 31 27 34\n",
+      "RZ 35 47 44 38 48 41 33 40\n",
       "REPEAT 3 {\n",
       "   TICK\n",
-      "   H 40 30 31 34\n",
+      "   H 35 47 44 38\n",
       "   TICK\n",
-      "   CX 26 48 25 35 30 18 23 41 31 20 34 22\n",
+      "   CX 35 19 47 20 44 22 23 48 25 41 18 33\n",
       "   TICK\n",
-      "   CX 22 48 21 35 30 25 20 41 31 26 34 19\n",
+      "   CX 35 25 47 24 44 18 19 48 20 41 21 33\n",
       "   TICK\n",
-      "   CX 40 23 21 48 30 26 18 41 31 24 20 27\n",
+      "   CX 35 26 44 25 38 23 22 48 21 41 19 40\n",
       "   TICK\n",
-      "   CX 40 18 19 48 30 21 26 41 31 22 24 27\n",
+      "   CX 35 20 44 21 38 22 25 48 24 41 26 40\n",
       "   TICK\n",
-      "   H 40 30 31 34\n",
+      "   H 35 47 44 38\n",
       "   TICK\n",
-      "   MRZ 40 48 35 30 41 31 27 34\n",
+      "   MRZ 35 47 44 38 48 41 33 40\n",
       "}\n",
-      "MZ 14 9 11 12 17 16 13 10 15\n",
-      "MZ 6 1 0 2 7 8 3 4 5\n",
-      "MZ 23 21 24 26 18 22 20 25 19\n",
+      "MZ 14 9 10 16 15 13 11 17 12\n",
+      "MZ 5 4 1 6 3 0 2 7 8\n",
+      "MZ 24 19 20 21 23 18 26 25 22\n",
       "DETECTOR rec[-321] rec[-313]\n",
       "DETECTOR rec[-313] rec[-305]\n",
       "DETECTOR rec[-320] rec[-312]\n",
       "DETECTOR rec[-312] rec[-304]\n",
+      "DETECTOR rec[-319]\n",
       "DETECTOR rec[-319] rec[-311]\n",
       "DETECTOR rec[-311] rec[-303]\n",
       "DETECTOR rec[-318] rec[-310]\n",
       "DETECTOR rec[-310] rec[-302]\n",
+      "DETECTOR rec[-317]\n",
       "DETECTOR rec[-317] rec[-309]\n",
       "DETECTOR rec[-309] rec[-301]\n",
+      "DETECTOR rec[-316]\n",
       "DETECTOR rec[-316] rec[-308]\n",
       "DETECTOR rec[-308] rec[-300]\n",
+      "DETECTOR rec[-315]\n",
       "DETECTOR rec[-315] rec[-307]\n",
       "DETECTOR rec[-307] rec[-299]\n",
       "DETECTOR rec[-314] rec[-306]\n",
       "DETECTOR rec[-306] rec[-298]\n",
       "DETECTOR rec[-297] rec[-289]\n",
       "DETECTOR rec[-289] rec[-281]\n",
+      "DETECTOR rec[-296]\n",
       "DETECTOR rec[-296] rec[-288]\n",
       "DETECTOR rec[-288] rec[-280]\n",
+      "DETECTOR rec[-295]\n",
       "DETECTOR rec[-295] rec[-287]\n",
       "DETECTOR rec[-287] rec[-279]\n",
       "DETECTOR rec[-294] rec[-286]\n",
@@ -356,8 +361,10 @@
       "DETECTOR rec[-285] rec[-277]\n",
       "DETECTOR rec[-292] rec[-284]\n",
       "DETECTOR rec[-284] rec[-276]\n",
+      "DETECTOR rec[-291]\n",
       "DETECTOR rec[-291] rec[-283]\n",
       "DETECTOR rec[-283] rec[-275]\n",
+      "DETECTOR rec[-290]\n",
       "DETECTOR rec[-290] rec[-282]\n",
       "DETECTOR rec[-282] rec[-274]\n",
       "DETECTOR rec[-273] rec[-265]\n",
@@ -368,244 +375,246 @@
       "DETECTOR rec[-263] rec[-255]\n",
       "DETECTOR rec[-270] rec[-262]\n",
       "DETECTOR rec[-262] rec[-254]\n",
+      "DETECTOR rec[-269]\n",
       "DETECTOR rec[-269] rec[-261]\n",
       "DETECTOR rec[-261] rec[-253]\n",
+      "DETECTOR rec[-268]\n",
       "DETECTOR rec[-268] rec[-260]\n",
       "DETECTOR rec[-260] rec[-252]\n",
+      "DETECTOR rec[-267]\n",
       "DETECTOR rec[-267] rec[-259]\n",
       "DETECTOR rec[-259] rec[-251]\n",
+      "DETECTOR rec[-266]\n",
       "DETECTOR rec[-266] rec[-258]\n",
       "DETECTOR rec[-258] rec[-250]\n",
+      "DETECTOR rec[-249] rec[-281]\n",
       "DETECTOR rec[-249] rec[-229]\n",
       "DETECTOR rec[-229] rec[-209]\n",
-      "DETECTOR rec[-248] rec[-304]\n",
+      "DETECTOR rec[-248] rec[-305]\n",
       "DETECTOR rec[-248] rec[-228]\n",
       "DETECTOR rec[-228] rec[-208]\n",
       "DETECTOR rec[-247] rec[-227]\n",
       "DETECTOR rec[-227] rec[-207]\n",
-      "DETECTOR rec[-246] rec[-278]\n",
+      "DETECTOR rec[-246] rec[-280]\n",
       "DETECTOR rec[-246] rec[-226]\n",
       "DETECTOR rec[-226] rec[-206]\n",
-      "DETECTOR rec[-245] rec[-301]\n",
       "DETECTOR rec[-245] rec[-225]\n",
       "DETECTOR rec[-225] rec[-205]\n",
-      "DETECTOR rec[-244] rec[-277]\n",
+      "DETECTOR rec[-244] rec[-278]\n",
       "DETECTOR rec[-244] rec[-224]\n",
       "DETECTOR rec[-224] rec[-204]\n",
-      "DETECTOR rec[-243] rec[-300]\n",
+      "DETECTOR rec[-243] rec[-275]\n",
       "DETECTOR rec[-243] rec[-223]\n",
       "DETECTOR rec[-223] rec[-203]\n",
-      "DETECTOR rec[-242] rec[-276]\n",
+      "DETECTOR rec[-242] rec[-300]\n",
       "DETECTOR rec[-242] rec[-222]\n",
       "DETECTOR rec[-222] rec[-202]\n",
-      "DETECTOR rec[-241] rec[-299]\n",
       "DETECTOR rec[-241] rec[-221]\n",
       "DETECTOR rec[-221] rec[-201]\n",
-      "DETECTOR rec[-240] rec[-305]\n",
+      "DETECTOR rec[-240] rec[-279]\n",
       "DETECTOR rec[-240] rec[-220]\n",
       "DETECTOR rec[-220] rec[-200]\n",
+      "DETECTOR rec[-239] rec[-299]\n",
       "DETECTOR rec[-239] rec[-219]\n",
       "DETECTOR rec[-219] rec[-199]\n",
       "DETECTOR rec[-238] rec[-303]\n",
       "DETECTOR rec[-238] rec[-218]\n",
       "DETECTOR rec[-218] rec[-198]\n",
-      "DETECTOR rec[-237] rec[-302]\n",
       "DETECTOR rec[-237] rec[-217]\n",
       "DETECTOR rec[-217] rec[-197]\n",
-      "DETECTOR rec[-236] rec[-274]\n",
+      "DETECTOR rec[-236] rec[-298]\n",
       "DETECTOR rec[-236] rec[-216]\n",
       "DETECTOR rec[-216] rec[-196]\n",
-      "DETECTOR rec[-235] rec[-281]\n",
+      "DETECTOR rec[-235] rec[-304]\n",
       "DETECTOR rec[-235] rec[-215]\n",
       "DETECTOR rec[-215] rec[-195]\n",
-      "DETECTOR rec[-234] rec[-280]\n",
+      "DETECTOR rec[-234] rec[-302]\n",
       "DETECTOR rec[-234] rec[-214]\n",
       "DETECTOR rec[-214] rec[-194]\n",
-      "DETECTOR rec[-233] rec[-279]\n",
+      "DETECTOR rec[-233] rec[-301]\n",
       "DETECTOR rec[-233] rec[-213]\n",
       "DETECTOR rec[-213] rec[-193]\n",
-      "DETECTOR rec[-232] rec[-275]\n",
+      "DETECTOR rec[-232] rec[-277]\n",
       "DETECTOR rec[-232] rec[-212]\n",
       "DETECTOR rec[-212] rec[-192]\n",
+      "DETECTOR rec[-231] rec[-276]\n",
       "DETECTOR rec[-231] rec[-211]\n",
       "DETECTOR rec[-211] rec[-191]\n",
-      "DETECTOR rec[-230] rec[-298]\n",
+      "DETECTOR rec[-230] rec[-274]\n",
       "DETECTOR rec[-230] rec[-210]\n",
       "DETECTOR rec[-210] rec[-190]\n",
-      "DETECTOR rec[-186] rec[-195]\n",
+      "DETECTOR rec[-186] rec[-209]\n",
       "DETECTOR rec[-186] rec[-178]\n",
       "DETECTOR rec[-178] rec[-170]\n",
-      "DETECTOR rec[-185] rec[-194] rec[-187] rec[-189]\n",
+      "DETECTOR rec[-185] rec[-206]\n",
       "DETECTOR rec[-185] rec[-177]\n",
       "DETECTOR rec[-177] rec[-169]\n",
-      "DETECTOR rec[-184] rec[-193]\n",
+      "DETECTOR rec[-184] rec[-200]\n",
       "DETECTOR rec[-184] rec[-176]\n",
       "DETECTOR rec[-176] rec[-168]\n",
-      "DETECTOR rec[-183] rec[-206]\n",
+      "DETECTOR rec[-183] rec[-204]\n",
       "DETECTOR rec[-183] rec[-175]\n",
       "DETECTOR rec[-175] rec[-167]\n",
-      "DETECTOR rec[-182] rec[-204]\n",
+      "DETECTOR rec[-182] rec[-192]\n",
       "DETECTOR rec[-182] rec[-174]\n",
       "DETECTOR rec[-174] rec[-166]\n",
-      "DETECTOR rec[-181] rec[-202]\n",
+      "DETECTOR rec[-181] rec[-191] rec[-188] rec[-187]\n",
       "DETECTOR rec[-181] rec[-173]\n",
       "DETECTOR rec[-173] rec[-165]\n",
-      "DETECTOR rec[-180] rec[-192]\n",
+      "DETECTOR rec[-180] rec[-203]\n",
       "DETECTOR rec[-180] rec[-172]\n",
       "DETECTOR rec[-172] rec[-164]\n",
-      "DETECTOR rec[-179] rec[-196]\n",
+      "DETECTOR rec[-179] rec[-190]\n",
       "DETECTOR rec[-179] rec[-171]\n",
       "DETECTOR rec[-171] rec[-163]\n",
-      "DETECTOR rec[-162] rec[-200]\n",
+      "DETECTOR rec[-162] rec[-208]\n",
       "DETECTOR rec[-162] rec[-154]\n",
       "DETECTOR rec[-154] rec[-146]\n",
-      "DETECTOR rec[-161] rec[-208]\n",
+      "DETECTOR rec[-161] rec[-195]\n",
       "DETECTOR rec[-161] rec[-153]\n",
       "DETECTOR rec[-153] rec[-145]\n",
       "DETECTOR rec[-160] rec[-198]\n",
       "DETECTOR rec[-160] rec[-152]\n",
       "DETECTOR rec[-152] rec[-144]\n",
-      "DETECTOR rec[-159] rec[-197]\n",
+      "DETECTOR rec[-159] rec[-194]\n",
       "DETECTOR rec[-159] rec[-151]\n",
       "DETECTOR rec[-151] rec[-143]\n",
-      "DETECTOR rec[-158] rec[-205] rec[-189] rec[-188]\n",
+      "DETECTOR rec[-158] rec[-193]\n",
       "DETECTOR rec[-158] rec[-150]\n",
       "DETECTOR rec[-150] rec[-142]\n",
-      "DETECTOR rec[-157] rec[-203]\n",
+      "DETECTOR rec[-157] rec[-202] rec[-189] rec[-187]\n",
       "DETECTOR rec[-157] rec[-149]\n",
       "DETECTOR rec[-149] rec[-141]\n",
-      "DETECTOR rec[-156] rec[-201]\n",
+      "DETECTOR rec[-156] rec[-199]\n",
       "DETECTOR rec[-156] rec[-148]\n",
       "DETECTOR rec[-148] rec[-140]\n",
-      "DETECTOR rec[-155] rec[-190]\n",
+      "DETECTOR rec[-155] rec[-196]\n",
       "DETECTOR rec[-155] rec[-147]\n",
       "DETECTOR rec[-147] rec[-139]\n",
-      "DETECTOR rec[-138] rec[-254]\n",
+      "DETECTOR rec[-138] rec[-146]\n",
       "DETECTOR rec[-138] rec[-118]\n",
       "DETECTOR rec[-118] rec[-98]\n",
-      "DETECTOR rec[-137] rec[-145]\n",
+      "DETECTOR rec[-137] rec[-257]\n",
       "DETECTOR rec[-137] rec[-117]\n",
       "DETECTOR rec[-117] rec[-97]\n",
-      "DETECTOR rec[-136] rec[-142]\n",
       "DETECTOR rec[-136] rec[-116]\n",
       "DETECTOR rec[-116] rec[-96]\n",
+      "DETECTOR rec[-135] rec[-255]\n",
       "DETECTOR rec[-135] rec[-115]\n",
       "DETECTOR rec[-115] rec[-95]\n",
-      "DETECTOR rec[-134] rec[-141]\n",
+      "DETECTOR rec[-134] rec[-252]\n",
       "DETECTOR rec[-134] rec[-114]\n",
       "DETECTOR rec[-114] rec[-94]\n",
-      "DETECTOR rec[-133] rec[-140]\n",
+      "DETECTOR rec[-133] rec[-141]\n",
       "DETECTOR rec[-133] rec[-113]\n",
       "DETECTOR rec[-113] rec[-93]\n",
-      "DETECTOR rec[-132] rec[-146]\n",
+      "DETECTOR rec[-132] rec[-253]\n",
       "DETECTOR rec[-132] rec[-112]\n",
       "DETECTOR rec[-112] rec[-92]\n",
-      "DETECTOR rec[-131] rec[-257]\n",
+      "DETECTOR rec[-131] rec[-250]\n",
       "DETECTOR rec[-131] rec[-111]\n",
       "DETECTOR rec[-111] rec[-91]\n",
+      "DETECTOR rec[-130] rec[-140]\n",
       "DETECTOR rec[-130] rec[-110]\n",
       "DETECTOR rec[-110] rec[-90]\n",
-      "DETECTOR rec[-129] rec[-256]\n",
+      "DETECTOR rec[-129] rec[-144]\n",
       "DETECTOR rec[-129] rec[-109]\n",
       "DETECTOR rec[-109] rec[-89]\n",
-      "DETECTOR rec[-128] rec[-144]\n",
       "DETECTOR rec[-128] rec[-108]\n",
       "DETECTOR rec[-108] rec[-88]\n",
-      "DETECTOR rec[-127] rec[-253]\n",
+      "DETECTOR rec[-127] rec[-139]\n",
       "DETECTOR rec[-127] rec[-107]\n",
       "DETECTOR rec[-107] rec[-87]\n",
-      "DETECTOR rec[-126] rec[-143]\n",
+      "DETECTOR rec[-126] rec[-145]\n",
       "DETECTOR rec[-126] rec[-106]\n",
       "DETECTOR rec[-106] rec[-86]\n",
-      "DETECTOR rec[-125] rec[-250]\n",
       "DETECTOR rec[-125] rec[-105]\n",
       "DETECTOR rec[-105] rec[-85]\n",
+      "DETECTOR rec[-124] rec[-143]\n",
       "DETECTOR rec[-124] rec[-104]\n",
       "DETECTOR rec[-104] rec[-84]\n",
+      "DETECTOR rec[-123] rec[-142]\n",
       "DETECTOR rec[-123] rec[-103]\n",
       "DETECTOR rec[-103] rec[-83]\n",
-      "DETECTOR rec[-122] rec[-252]\n",
+      "DETECTOR rec[-122] rec[-256]\n",
       "DETECTOR rec[-122] rec[-102]\n",
       "DETECTOR rec[-102] rec[-82]\n",
-      "DETECTOR rec[-121] rec[-251]\n",
+      "DETECTOR rec[-121] rec[-254]\n",
       "DETECTOR rec[-121] rec[-101]\n",
       "DETECTOR rec[-101] rec[-81]\n",
-      "DETECTOR rec[-120] rec[-255]\n",
+      "DETECTOR rec[-120] rec[-251]\n",
       "DETECTOR rec[-120] rec[-100]\n",
       "DETECTOR rec[-100] rec[-80]\n",
-      "DETECTOR rec[-119] rec[-139]\n",
       "DETECTOR rec[-119] rec[-99]\n",
       "DETECTOR rec[-99] rec[-79]\n",
-      "DETECTOR rec[-75] rec[-92]\n",
+      "DETECTOR rec[-75] rec[-98]\n",
       "DETECTOR rec[-75] rec[-67]\n",
       "DETECTOR rec[-67] rec[-59]\n",
-      "DETECTOR rec[-74] rec[-97]\n",
+      "DETECTOR rec[-74] rec[-86]\n",
       "DETECTOR rec[-74] rec[-66]\n",
       "DETECTOR rec[-66] rec[-58]\n",
-      "DETECTOR rec[-73] rec[-88]\n",
+      "DETECTOR rec[-73] rec[-89]\n",
       "DETECTOR rec[-73] rec[-65]\n",
       "DETECTOR rec[-65] rec[-57]\n",
-      "DETECTOR rec[-72] rec[-86]\n",
+      "DETECTOR rec[-72] rec[-84]\n",
       "DETECTOR rec[-72] rec[-64]\n",
       "DETECTOR rec[-64] rec[-56]\n",
-      "DETECTOR rec[-71] rec[-96]\n",
+      "DETECTOR rec[-71] rec[-83]\n",
       "DETECTOR rec[-71] rec[-63]\n",
       "DETECTOR rec[-63] rec[-55]\n",
-      "DETECTOR rec[-70] rec[-94]\n",
+      "DETECTOR rec[-70] rec[-93]\n",
       "DETECTOR rec[-70] rec[-62]\n",
       "DETECTOR rec[-62] rec[-54]\n",
-      "DETECTOR rec[-69] rec[-93]\n",
+      "DETECTOR rec[-69] rec[-90]\n",
       "DETECTOR rec[-69] rec[-61]\n",
       "DETECTOR rec[-61] rec[-53]\n",
-      "DETECTOR rec[-68] rec[-79] rec[-78] rec[-77]\n",
+      "DETECTOR rec[-68] rec[-87] rec[-78] rec[-77]\n",
       "DETECTOR rec[-68] rec[-60]\n",
       "DETECTOR rec[-60] rec[-52]\n",
-      "DETECTOR rec[-51] rec[-91]\n",
+      "DETECTOR rec[-51] rec[-97]\n",
       "DETECTOR rec[-51] rec[-43]\n",
       "DETECTOR rec[-43] rec[-35]\n",
-      "DETECTOR rec[-50] rec[-89]\n",
+      "DETECTOR rec[-50] rec[-82]\n",
       "DETECTOR rec[-50] rec[-42]\n",
       "DETECTOR rec[-42] rec[-34]\n",
-      "DETECTOR rec[-49] rec[-80] rec[-77] rec[-76]\n",
+      "DETECTOR rec[-49] rec[-95]\n",
       "DETECTOR rec[-49] rec[-41]\n",
       "DETECTOR rec[-41] rec[-33]\n",
-      "DETECTOR rec[-48] rec[-98]\n",
+      "DETECTOR rec[-48] rec[-81]\n",
       "DETECTOR rec[-48] rec[-40]\n",
       "DETECTOR rec[-40] rec[-32]\n",
-      "DETECTOR rec[-47] rec[-87]\n",
+      "DETECTOR rec[-47] rec[-92]\n",
       "DETECTOR rec[-47] rec[-39]\n",
       "DETECTOR rec[-39] rec[-31]\n",
-      "DETECTOR rec[-46] rec[-82]\n",
+      "DETECTOR rec[-46] rec[-94]\n",
       "DETECTOR rec[-46] rec[-38]\n",
       "DETECTOR rec[-38] rec[-30]\n",
-      "DETECTOR rec[-45] rec[-81]\n",
+      "DETECTOR rec[-45] rec[-80] rec[-78] rec[-76]\n",
       "DETECTOR rec[-45] rec[-37]\n",
       "DETECTOR rec[-37] rec[-29]\n",
-      "DETECTOR rec[-44] rec[-85]\n",
+      "DETECTOR rec[-44] rec[-91]\n",
       "DETECTOR rec[-44] rec[-36]\n",
       "DETECTOR rec[-36] rec[-28]\n",
-      "DETECTOR rec[-26] rec[-27] rec[-24] rec[-21] rec[-170]\n",
-      "DETECTOR rec[-20] rec[-23] rec[-19] rec[-27] rec[-168]\n",
-      "DETECTOR rec[-26] rec[-25] rec[-166]\n",
-      "DETECTOR rec[-20] rec[-22] rec[-163]\n",
-      "DETECTOR rec[-17] rec[-16] rec[-14] rec[-11] rec[-56]\n",
-      "DETECTOR rec[-12] rec[-15] rec[-54]\n",
-      "DETECTOR rec[-17] rec[-12] rec[-13] rec[-18] rec[-53]\n",
-      "DETECTOR rec[-14] rec[-10] rec[-52]\n",
-      "DETECTOR rec[-8] rec[-4] rec[-1] rec[-6] rec[-34]\n",
-      "DETECTOR rec[-8] rec[-2] rec[-33]\n",
-      "DETECTOR rec[-9] rec[-5] rec[-6] rec[-3] rec[-31]\n",
-      "DETECTOR rec[-7] rec[-3] rec[-29]\n",
-      "OBSERVABLE_INCLUDE(0) rec[-24] rec[-22] rec[-21]\n",
-      "OBSERVABLE_INCLUDE(1) rec[-209] rec[-207] rec[-203] rec[-201] rec[-199] rec[-197] rec[-191] rec[-190] rec[-76] rec[-16] rec[-15] rec[-11] rec[-9] rec[-5] rec[-2]\n"
+      "DETECTOR rec[-25] rec[-19] rec[-22] rec[-23] rec[-169]\n",
+      "DETECTOR rec[-19] rec[-26] rec[-168]\n",
+      "DETECTOR rec[-21] rec[-20] rec[-164]\n",
+      "DETECTOR rec[-27] rec[-24] rec[-20] rec[-25] rec[-163]\n",
+      "DETECTOR rec[-11] rec[-14] rec[-15] rec[-12] rec[-59]\n",
+      "DETECTOR rec[-18] rec[-15] rec[-10] rec[-13] rec[-58]\n",
+      "DETECTOR rec[-16] rec[-10] rec[-56]\n",
+      "DETECTOR rec[-17] rec[-14] rec[-52]\n",
+      "DETECTOR rec[-2] rec[-8] rec[-5] rec[-1] rec[-31]\n",
+      "DETECTOR rec[-6] rec[-9] rec[-2] rec[-7] rec[-30]\n",
+      "DETECTOR rec[-6] rec[-4] rec[-29]\n",
+      "DETECTOR rec[-3] rec[-8] rec[-28]\n",
+      "OBSERVABLE_INCLUDE(0) rec[-23] rec[-22] rec[-21]\n",
+      "OBSERVABLE_INCLUDE(1) rec[-208] rec[-207] rec[-205] rec[-201] rec[-197] rec[-196] rec[-195] rec[-194] rec[-76] rec[-16] rec[-12] rec[-11] rec[-5] rec[-4] rec[-1]\n"
      ]
     }
    ],
    "source": [
     "from pathlib import Path\n",
     "\n",
-    "import stim\n",
-    "\n",
     "from epic import QECCompiler, StimLikeNoiseModel\n",
     "\n",
     "compiler = QECCompiler(config)\n",
@@ -613,7 +622,7 @@
     "# compiled_program = compiler.compile(program, visual_output_path=Path(\"visualizations/getting_started/comp_vis.pdf\"))\n",
     "compiled_program = compiler.compile(program)\n",
     "\n",
-    "noise = 0.1\n",
+    "noise = 0\n",
     "noise_model = StimLikeNoiseModel.from_stim_like_probabilities(\n",
     "    after_clifford_depolarization=noise,\n",
     "    after_reset_flip_probability=noise,\n",
@@ -637,7 +646,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 17,
    "id": "cc1797b2",
    "metadata": {},
    "outputs": [],
@@ -699,20 +708,18 @@
     "    stim_program = compiled_program.to_stim_program(stim_observables, noise_model)\n",
     "\n",
     "    stim_circuit = stim.Circuit(stim_program)\n",
-    "\n",
-    "    \n",
     "    return stim_circuit"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 18,
    "id": "050500c7",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 768x576 with 1 Axes>"
       ]
@@ -740,7 +747,7 @@
     "    num_workers=4,\n",
     "    tasks=tasks,\n",
     "    decoders=[\"pymatching\"],\n",
-    "    max_shots=100_000,\n",
+    "    max_shots=1_000_000,\n",
     "    max_errors=500,\n",
     ")\n",
     "fig, ax = plt.subplots(1, 1)\n",
@@ -750,7 +757,7 @@
     "    x_func=lambda stats: stats.json_metadata[\"p\"],\n",
     "    group_func=lambda stats: stats.json_metadata[\"d\"],\n",
     ")\n",
-    "ax.set_ylim(1e-5, 1e-0)\n",
+    "ax.set_ylim(1e-7, 1e-0)\n",
     "ax.set_xlim(1e-4, 1e-1)\n",
     "ax.loglog()\n",
     "ax.set_title(\"CNOT Code Error Rates\")\n",