diff --git a/src/clorco/_circuits_vs_chromobius_test.py b/src/clorco/_circuits_vs_chromobius_test.py index bb6c5b6..1797937 100644 --- a/src/clorco/_circuits_vs_chromobius_test.py +++ b/src/clorco/_circuits_vs_chromobius_test.py @@ -23,7 +23,12 @@ @pytest.mark.parametrize( - "style", [style for style in CONSTRUCTIONS.keys() if "mxyz_" not in style] + "style", + [ + style + for style in CONSTRUCTIONS.keys() + if ("mxyz_" not in style and "bell_flagged" not in style) + ], ) def test_constructions_are_decoded(style: str): r = 1 if style.startswith("transit") else 6 @@ -37,9 +42,7 @@ def test_constructions_are_decoded(style: str): convert_to_cz=True, editable_extras={}, ) - decoder = chromobius.compile_decoder_for_dem( - circuit.detector_error_model() - ) + decoder = chromobius.compile_decoder_for_dem(circuit.detector_error_model()) shots = 2048 assert 0 < circuit.num_observables <= 8 diff --git a/src/clorco/color_code/_bell_flagged_planar_color_code_circuits.py b/src/clorco/color_code/_bell_flagged_planar_color_code_circuits.py new file mode 100644 index 0000000..9c67d7b --- /dev/null +++ b/src/clorco/color_code/_bell_flagged_planar_color_code_circuits.py @@ -0,0 +1,363 @@ +# Copyright 2023 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Callable +from typing import Iterable +from typing import Literal, List +from functools import partial + +import stim + +import gen +from clorco.color_code._superdense_planar_color_code_circuits import ( + make_color_code_layout_for_superdense, +) +from gen._core._stabilizer_code import StabilizerCode + + +def builder_do_cxs( + builder: gen.Builder, + code: StabilizerCode, + centers: Iterable[complex], + d_control: complex, + d_target: complex, + inv: Callable[[complex], bool] = lambda _: False, +) -> None: + builder.append( + "CX", + [ + (c + d_control, c + d_target)[:: -1 if inv(c) else +1] + for c in centers + if c + d_control in code.patch.used_set + if c + d_target in code.patch.used_set + ], + ) + + +def make_bell_flagged_color_code_circuit_z_first_half_round_chunk( + *, + initialize: bool, + basis: Literal["X", "Z"], + base_data_width: int, +) -> gen.Chunk: + code = make_color_code_layout_for_superdense( + base_data_width=base_data_width, + ) + + x_ms = [tile.measurement_qubit for tile in code.patch.tiles if tile.basis == "X"] + z_ms = [tile.measurement_qubit for tile in code.patch.tiles if tile.basis == "Z"] + + builder = gen.Builder.for_qubits(code.patch.used_set) + + do_cxs = partial(builder_do_cxs, builder, code) + + def mf(*qs): + return builder.lookup_recs(q for q in qs if q in code.patch.measure_set) + + # Construct the first half of the cycle, responsible for the Z checks + builder.append("RX", x_ms) + if initialize: + builder.append(f"R{basis}", code.patch.data_set) + builder.append("RZ", z_ms) + builder.tick() + + do_cxs(x_ms, +0, +1) + builder.tick() + do_cxs(x_ms, +1j, +0) + do_cxs(z_ms, +1j, +0) + builder.tick() + do_cxs(x_ms, -1, +0) + do_cxs(z_ms, +1, +0) + builder.tick() + do_cxs(x_ms, -1j, +0) + do_cxs(z_ms, -1j, +0) + builder.tick() + do_cxs(x_ms, +0, +1) + builder.tick() + + builder.append("MX", x_ms) + builder.append("MZ", z_ms) + + flows = [] + for tile in code.patch.tiles: + m = tile.measurement_qubit + if tile.basis == "X": + # This flow is just for the flag qubit + # It starts and ends on the X ancilla + flows.append( + gen.Flow( + measurement_indices=mf(m), + center=m, + flags=tile.flags | frozenset({"is_flag=True"}), + ) + ) + if not initialize: + flows.append( + gen.Flow( + start=tile.to_data_pauli_string(), + end=tile.to_data_pauli_string(), + center=m, + flags=tile.flags, + ) + ) + elif basis == "X": + flows.append( + gen.Flow( + end=tile.to_data_pauli_string(), + center=m, + flags=tile.flags, + ) + ) + + elif tile.basis == "Z": + if not initialize: + flows.append( + gen.Flow( + start=tile.to_data_pauli_string(), + measurement_indices=mf(m), + center=m, + flags=tile.flags, + ) + ) + elif basis == "Z": + flows.append( + gen.Flow( + measurement_indices=mf(m), + center=m, + flags=tile.flags, + ) + ) + flows.append( + gen.Flow( + end=tile.to_data_pauli_string(), + measurement_indices=mf(m), + center=m, + flags=tile.flags, + ) + ) + + (obs_x,) = code.observables_x + (obs_z,) = code.observables_z + if basis == "X": + flows.append( + gen.Flow( + start=None if initialize else obs_x, + end=obs_x, + measurement_indices=[], + center=-1 - 1j, + obs_index=0, + ) + ) + elif basis == "Z": + flows.append( + gen.Flow( + start=None if initialize else obs_z, + end=obs_z, + measurement_indices=[], + center=-1 - 1j, + obs_index=0, + ) + ) + return gen.Chunk( + circuit=builder.circuit, + flows=flows, + q2i=builder.q2i, + ) + + +def make_bell_flagged_color_code_circuit_x_second_half_round_chunk( + *, + initialize: bool, + basis: Literal["X", "Z"], + base_data_width: int, +) -> gen.Chunk: + code = make_color_code_layout_for_superdense( + base_data_width=base_data_width, + ) + + x_ms = [tile.measurement_qubit for tile in code.patch.tiles if tile.basis == "X"] + z_ms = [tile.measurement_qubit for tile in code.patch.tiles if tile.basis == "Z"] + + builder = gen.Builder.for_qubits(code.patch.used_set) + + do_cxs = partial(builder_do_cxs, builder, code) + + def mf(*qs): + return builder.lookup_recs(q for q in qs if q in code.patch.measure_set) + + # Construct the second half of the cycle, responsible for the X checks + builder.append("RX", x_ms) + builder.append("RZ", z_ms) + builder.tick() + do_cxs(x_ms, +0, +1) + builder.tick() + do_cxs(x_ms, +0, +1j) + do_cxs(z_ms, +0, +1j) + builder.tick() + do_cxs(x_ms, +0, -1) + do_cxs(z_ms, +0, +1) + builder.tick() + do_cxs(x_ms, +0, -1j) + do_cxs(z_ms, +0, -1j) + builder.tick() + do_cxs(x_ms, +0, +1) + builder.tick() + builder.append("MX", x_ms) + builder.append("MZ", z_ms) + + flows = [] + for tile in code.patch.tiles: + m = tile.measurement_qubit + if tile.basis == "X": + if not initialize or basis == "X": + flows.append( + gen.Flow( + start=tile.to_data_pauli_string(), + measurement_indices=mf(m), + center=m, + flags=tile.flags, + ) + ) + flows.append( + gen.Flow( + end=tile.to_data_pauli_string(), + measurement_indices=mf(m), + center=m, + flags=tile.flags, + ) + ) + elif tile.basis == "Z": + # First flow is for the flag qubit + flows.append( + gen.Flow( + measurement_indices=mf(m), + center=m, + flags=tile.flags | frozenset({"is_flag=True"}), + ) + ) + flows.append( + gen.Flow( + start=tile.to_data_pauli_string(), + end=tile.to_data_pauli_string(), + measurement_indices=[], + center=m, + flags=tile.flags, + ) + ) + + (obs_x,) = code.observables_x + (obs_z,) = code.observables_z + if basis == "X": + flows.append( + gen.Flow( + start=obs_x, + end=obs_x, + measurement_indices=[], + center=-1 - 1j, + obs_index=0, + ) + ) + elif basis == "Z": + flows.append( + gen.Flow( + start=obs_z, + end=obs_z, + measurement_indices=[], + center=-1 - 1j, + obs_index=0, + ) + ) + return gen.Chunk( + circuit=builder.circuit, + flows=flows, + q2i=builder.q2i, + ) + + +def make_bell_flagged_color_code_circuit_round_chunks( + *, + initialize: bool, + basis: Literal["X", "Z"], + base_data_width: int, +) -> List[gen.Chunk]: + z_chunk = make_bell_flagged_color_code_circuit_z_first_half_round_chunk( + initialize=initialize, basis=basis, base_data_width=base_data_width + ) + + x_chunk = make_bell_flagged_color_code_circuit_x_second_half_round_chunk( + initialize=initialize, basis=basis, base_data_width=base_data_width + ) + + return [z_chunk, x_chunk] + + +def f2c(flow: gen.Flow) -> list[float]: + c = 0 + if "color=r" in flow.flags: + c += 0 + elif "color=g" in flow.flags: + c += 1 + elif "color=b" in flow.flags: + c += 2 + else: + raise NotImplementedError(f"{flow=}") + + if "is_flag=True" in flow.flags: + if "basis=X" in flow.flags: + c += 9 + elif "basis=Z" in flow.flags: + c += 6 + else: + raise NotImplementedError(f"{flow=}") + else: + if "basis=X" in flow.flags: + c += 0 + elif "basis=Z" in flow.flags: + c += 3 + else: + raise NotImplementedError(f"{flow=}") + return [c] + + +def make_bell_flagged_color_code_circuit( + *, + base_data_width: int, + basis: Literal["X", "Z"], + rounds: int, +) -> stim.Circuit: + assert rounds >= 2 + + first_round_chunks = make_bell_flagged_color_code_circuit_round_chunks( + initialize=True, + basis=basis, + base_data_width=base_data_width, + ) + mid_round_chunks = make_bell_flagged_color_code_circuit_round_chunks( + initialize=False, + basis=basis, + base_data_width=base_data_width, + ) + end_round_chunks = [ + first_round_chunks[1].time_reversed(), + first_round_chunks[0].time_reversed(), + ] + + return gen.compile_chunks_into_circuit( + [ + *first_round_chunks, + gen.ChunkLoop(mid_round_chunks, repetitions=rounds - 2), + *end_round_chunks, + ], + flow_to_extra_coords_func=f2c, + ) diff --git a/src/clorco/color_code/_bell_flagged_planar_color_code_circuits_test.py b/src/clorco/color_code/_bell_flagged_planar_color_code_circuits_test.py new file mode 100644 index 0000000..7165da9 --- /dev/null +++ b/src/clorco/color_code/_bell_flagged_planar_color_code_circuits_test.py @@ -0,0 +1,498 @@ +# Copyright 2023 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import itertools +from typing import Any + +import pytest +import stim + +import gen +from clorco.color_code._bell_flagged_planar_color_code_circuits import ( + make_bell_flagged_color_code_circuit, + make_bell_flagged_color_code_circuit_round_chunks, +) +from clorco._make_circuit import make_circuit + + +@pytest.mark.parametrize( + "d,b,i", + itertools.product( + [3, 5, 7], + ["X", "Z"], + [False, True], + ), +) +def test_make_bell_flagged_color_code_circuit_round_chunk(d: int, b: Any, i: bool): + chunks = make_bell_flagged_color_code_circuit_round_chunks( + base_data_width=d, + initialize=i, + basis=b, + ) + for chunk in chunks: + chunk.verify() + if d == 5: + if i: + assert len(chunks[0].flows) == 3 * 9 + 1 + assert len(chunks[1].flows) == (4 * 9 + 1 if b == "X" else 3 * 9 + 1) + else: + assert len(chunks[0].flows) == 4 * 9 + 1 + assert len(chunks[1].flows) == 4 * 9 + 1 + + +@pytest.mark.parametrize( + "d,b,r", + itertools.product( + [3, 5], + ["X", "Z"], + [2, 3, 5], + ), +) +def test_make_bell_flagged_color_code_circuit(d: int, b: Any, r: int): + circuit = make_bell_flagged_color_code_circuit( + base_data_width=d, + basis=b, + rounds=r, + ) + assert ( + circuit.count_determined_measurements() + == circuit.num_detectors + circuit.num_observables + ) + circuit = gen.NoiseModel.uniform_depolarizing(1e-3).noisy_circuit(circuit) + assert ( + len( + circuit.search_for_undetectable_logical_errors( + dont_explore_detection_event_sets_with_size_above=4, + dont_explore_edges_with_degree_above=3, + dont_explore_edges_increasing_symptom_degree=False, + ) + ) + == d + ) + + +def test_make_bell_flagged_color_code_circuit_exact(): + p = 0.001 + circuit = make_circuit( + style="bell_flagged_color_code_X", + noise_model=gen.NoiseModel.si1000(p), + noise_strength=p, + rounds=100, + diameter=5, + convert_to_cz=True, + editable_extras={}, + ) + assert circuit == stim.Circuit( + """QUBIT_COORDS(0, 0) 0 +QUBIT_COORDS(1, 0) 1 +QUBIT_COORDS(1, 1) 2 +QUBIT_COORDS(1, 2) 3 +QUBIT_COORDS(2, 0) 4 +QUBIT_COORDS(2, 1) 5 +QUBIT_COORDS(2, 2) 6 +QUBIT_COORDS(2, 3) 7 +QUBIT_COORDS(3, 0) 8 +QUBIT_COORDS(3, 1) 9 +QUBIT_COORDS(3, 2) 10 +QUBIT_COORDS(3, 3) 11 +QUBIT_COORDS(3, 4) 12 +QUBIT_COORDS(3, 5) 13 +QUBIT_COORDS(4, 0) 14 +QUBIT_COORDS(4, 1) 15 +QUBIT_COORDS(4, 2) 16 +QUBIT_COORDS(4, 3) 17 +QUBIT_COORDS(4, 4) 18 +QUBIT_COORDS(4, 5) 19 +QUBIT_COORDS(4, 6) 20 +QUBIT_COORDS(5, 0) 21 +QUBIT_COORDS(5, 1) 22 +QUBIT_COORDS(5, 2) 23 +QUBIT_COORDS(5, 3) 24 +QUBIT_COORDS(5, 4) 25 +QUBIT_COORDS(5, 5) 26 +QUBIT_COORDS(6, 0) 27 +QUBIT_COORDS(6, 1) 28 +QUBIT_COORDS(6, 2) 29 +QUBIT_COORDS(6, 3) 30 +QUBIT_COORDS(6, 4) 31 +QUBIT_COORDS(7, 0) 32 +QUBIT_COORDS(7, 1) 33 +QUBIT_COORDS(7, 2) 34 +QUBIT_COORDS(8, 0) 35 +QUBIT_COORDS(8, 1) 36 +R 1 3 9 11 13 21 23 25 33 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 4 6 15 17 19 27 29 31 36 +X_ERROR(0.002) 1 3 9 11 13 21 23 25 33 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 4 6 15 17 19 27 29 31 36 +TICK +H 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 +DEPOLARIZE1(0.0001) 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 +TICK +CZ 1 4 3 6 9 15 11 17 13 19 21 27 23 29 25 31 33 36 +DEPOLARIZE2(0.001) 1 4 3 6 9 15 11 17 13 19 21 27 23 29 25 31 33 36 +DEPOLARIZE1(0.0001) 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 +TICK +H 1 3 9 11 13 21 23 25 33 +DEPOLARIZE1(0.0001) 1 3 9 11 13 21 23 25 33 0 2 4 5 6 7 8 10 12 14 15 16 17 18 19 20 22 24 26 27 28 29 30 31 32 34 35 36 +TICK +CZ 1 2 4 5 6 7 9 10 11 12 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 33 34 +DEPOLARIZE2(0.001) 1 2 4 5 6 7 9 10 11 12 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 33 34 +DEPOLARIZE1(0.0001) 0 3 8 13 14 31 32 35 36 +TICK +CZ 0 1 4 8 5 9 6 10 7 11 14 21 15 22 16 23 17 24 18 25 19 26 27 32 28 33 29 34 +DEPOLARIZE2(0.001) 0 1 4 8 5 9 6 10 7 11 14 21 15 22 16 23 17 24 18 25 19 26 27 32 28 33 29 34 +DEPOLARIZE1(0.0001) 2 3 12 13 20 30 31 35 36 +TICK +CZ 2 3 5 6 8 9 10 11 12 13 14 15 16 17 18 19 22 23 24 25 28 29 30 31 32 33 35 36 +DEPOLARIZE2(0.001) 2 3 5 6 8 9 10 11 12 13 14 15 16 17 18 19 22 23 24 25 28 29 30 31 32 33 35 36 +DEPOLARIZE1(0.0001) 0 1 4 7 20 21 26 27 34 +TICK +H 1 2 3 5 8 9 10 11 12 13 14 16 18 21 22 23 24 25 28 30 32 33 35 +DEPOLARIZE1(0.0001) 1 2 3 5 8 9 10 11 12 13 14 16 18 21 22 23 24 25 28 30 32 33 35 0 4 6 7 15 17 19 20 26 27 29 31 34 36 +TICK +CZ 1 4 3 6 9 15 11 17 13 19 21 27 23 29 25 31 33 36 +DEPOLARIZE2(0.001) 1 4 3 6 9 15 11 17 13 19 21 27 23 29 25 31 33 36 +DEPOLARIZE1(0.0001) 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 +TICK +H 1 3 4 6 9 11 13 15 17 19 21 23 25 27 29 31 33 36 +DEPOLARIZE1(0.0001) 1 3 4 6 9 11 13 15 17 19 21 23 25 27 29 31 33 36 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 +TICK +M(0.005) 1 3 9 11 13 21 23 25 33 4 6 15 17 19 27 29 31 36 +DETECTOR(1, 0, 0, 9) rec[-18] +DETECTOR(1, 2, 0, 11) rec[-17] +DETECTOR(3, 1, 0, 10) rec[-16] +DETECTOR(3, 3, 0, 9) rec[-15] +DETECTOR(3, 5, 0, 11) rec[-14] +DETECTOR(5, 0, 0, 9) rec[-13] +DETECTOR(5, 2, 0, 11) rec[-12] +DETECTOR(5, 4, 0, 10) rec[-11] +DETECTOR(7, 1, 0, 10) rec[-10] +SHIFT_COORDS(0, 0, 1) +DEPOLARIZE1(0.001) 1 3 9 11 13 21 23 25 33 4 6 15 17 19 27 29 31 36 +DEPOLARIZE1(0.0001) 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 +DEPOLARIZE1(0.002) 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 +TICK +R 1 3 9 11 13 21 23 25 33 4 6 15 17 19 27 29 31 36 +X_ERROR(0.002) 1 3 9 11 13 21 23 25 33 4 6 15 17 19 27 29 31 36 +DEPOLARIZE1(0.0001) 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 +DEPOLARIZE1(0.002) 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 +TICK +H 1 3 4 6 9 11 13 15 17 19 21 23 25 27 29 31 33 36 +DEPOLARIZE1(0.0001) 1 3 4 6 9 11 13 15 17 19 21 23 25 27 29 31 33 36 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 +TICK +CZ 1 4 3 6 9 15 11 17 13 19 21 27 23 29 25 31 33 36 +DEPOLARIZE2(0.001) 1 4 3 6 9 15 11 17 13 19 21 27 23 29 25 31 33 36 +DEPOLARIZE1(0.0001) 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 +TICK +H 0 4 6 7 15 17 19 20 26 27 29 31 34 36 +DEPOLARIZE1(0.0001) 0 4 6 7 15 17 19 20 26 27 29 31 34 36 1 2 3 5 8 9 10 11 12 13 14 16 18 21 22 23 24 25 28 30 32 33 35 +TICK +CZ 1 2 4 5 6 7 9 10 11 12 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 33 34 +DEPOLARIZE2(0.001) 1 2 4 5 6 7 9 10 11 12 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 33 34 +DEPOLARIZE1(0.0001) 0 3 8 13 14 31 32 35 36 +TICK +CZ 0 1 4 8 5 9 6 10 7 11 14 21 15 22 16 23 17 24 18 25 19 26 27 32 28 33 29 34 +DEPOLARIZE2(0.001) 0 1 4 8 5 9 6 10 7 11 14 21 15 22 16 23 17 24 18 25 19 26 27 32 28 33 29 34 +DEPOLARIZE1(0.0001) 2 3 12 13 20 30 31 35 36 +TICK +CZ 2 3 5 6 8 9 10 11 12 13 14 15 16 17 18 19 22 23 24 25 28 29 30 31 32 33 35 36 +DEPOLARIZE2(0.001) 2 3 5 6 8 9 10 11 12 13 14 15 16 17 18 19 22 23 24 25 28 29 30 31 32 33 35 36 +DEPOLARIZE1(0.0001) 0 1 4 7 20 21 26 27 34 +TICK +H 0 2 4 5 6 7 8 10 12 14 15 16 17 18 19 20 22 24 26 27 28 29 30 31 32 34 35 36 +DEPOLARIZE1(0.0001) 0 2 4 5 6 7 8 10 12 14 15 16 17 18 19 20 22 24 26 27 28 29 30 31 32 34 35 36 1 3 9 11 13 21 23 25 33 +TICK +CZ 1 4 3 6 9 15 11 17 13 19 21 27 23 29 25 31 33 36 +DEPOLARIZE2(0.001) 1 4 3 6 9 15 11 17 13 19 21 27 23 29 25 31 33 36 +DEPOLARIZE1(0.0001) 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 +TICK +H 1 3 4 6 9 11 13 15 17 19 21 23 25 27 29 31 33 36 +DEPOLARIZE1(0.0001) 1 3 4 6 9 11 13 15 17 19 21 23 25 27 29 31 33 36 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 +TICK +M(0.005) 1 3 9 11 13 21 23 25 33 4 6 15 17 19 27 29 31 36 +DETECTOR(1, 0, 0, 0) rec[-18] +DETECTOR(1, 2, 0, 2) rec[-17] +DETECTOR(2, 0, 0, 6) rec[-9] +DETECTOR(2, 2, 0, 8) rec[-8] +DETECTOR(3, 1, 0, 1) rec[-16] +DETECTOR(3, 3, 0, 0) rec[-15] +DETECTOR(3, 5, 0, 2) rec[-14] +DETECTOR(4, 1, 0, 7) rec[-7] +DETECTOR(4, 3, 0, 6) rec[-6] +DETECTOR(4, 5, 0, 8) rec[-5] +DETECTOR(5, 0, 0, 0) rec[-13] +DETECTOR(5, 2, 0, 2) rec[-12] +DETECTOR(5, 4, 0, 1) rec[-11] +DETECTOR(6, 0, 0, 6) rec[-4] +DETECTOR(6, 2, 0, 8) rec[-3] +DETECTOR(6, 4, 0, 7) rec[-2] +DETECTOR(7, 1, 0, 1) rec[-10] +DETECTOR(8, 1, 0, 7) rec[-1] +SHIFT_COORDS(0, 0, 1) +DEPOLARIZE1(0.001) 1 3 9 11 13 21 23 25 33 4 6 15 17 19 27 29 31 36 +DEPOLARIZE1(0.0001) 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 +DEPOLARIZE1(0.002) 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 +TICK +REPEAT 98 { + R 1 3 9 11 13 21 23 25 33 4 6 15 17 19 27 29 31 36 + X_ERROR(0.002) 1 3 9 11 13 21 23 25 33 4 6 15 17 19 27 29 31 36 + DEPOLARIZE1(0.0001) 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 + DEPOLARIZE1(0.002) 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 + TICK + H 1 3 4 6 9 11 13 15 17 19 21 23 25 27 29 31 33 36 + DEPOLARIZE1(0.0001) 1 3 4 6 9 11 13 15 17 19 21 23 25 27 29 31 33 36 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 + TICK + CZ 1 4 3 6 9 15 11 17 13 19 21 27 23 29 25 31 33 36 + DEPOLARIZE2(0.001) 1 4 3 6 9 15 11 17 13 19 21 27 23 29 25 31 33 36 + DEPOLARIZE1(0.0001) 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 + TICK + H 1 3 9 11 13 21 23 25 33 + DEPOLARIZE1(0.0001) 1 3 9 11 13 21 23 25 33 0 2 4 5 6 7 8 10 12 14 15 16 17 18 19 20 22 24 26 27 28 29 30 31 32 34 35 36 + TICK + CZ 1 2 4 5 6 7 9 10 11 12 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 33 34 + DEPOLARIZE2(0.001) 1 2 4 5 6 7 9 10 11 12 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 33 34 + DEPOLARIZE1(0.0001) 0 3 8 13 14 31 32 35 36 + TICK + CZ 0 1 4 8 5 9 6 10 7 11 14 21 15 22 16 23 17 24 18 25 19 26 27 32 28 33 29 34 + DEPOLARIZE2(0.001) 0 1 4 8 5 9 6 10 7 11 14 21 15 22 16 23 17 24 18 25 19 26 27 32 28 33 29 34 + DEPOLARIZE1(0.0001) 2 3 12 13 20 30 31 35 36 + TICK + CZ 2 3 5 6 8 9 10 11 12 13 14 15 16 17 18 19 22 23 24 25 28 29 30 31 32 33 35 36 + DEPOLARIZE2(0.001) 2 3 5 6 8 9 10 11 12 13 14 15 16 17 18 19 22 23 24 25 28 29 30 31 32 33 35 36 + DEPOLARIZE1(0.0001) 0 1 4 7 20 21 26 27 34 + TICK + H 1 2 3 5 8 9 10 11 12 13 14 16 18 21 22 23 24 25 28 30 32 33 35 + DEPOLARIZE1(0.0001) 1 2 3 5 8 9 10 11 12 13 14 16 18 21 22 23 24 25 28 30 32 33 35 0 4 6 7 15 17 19 20 26 27 29 31 34 36 + TICK + CZ 1 4 3 6 9 15 11 17 13 19 21 27 23 29 25 31 33 36 + DEPOLARIZE2(0.001) 1 4 3 6 9 15 11 17 13 19 21 27 23 29 25 31 33 36 + DEPOLARIZE1(0.0001) 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 + TICK + H 1 3 4 6 9 11 13 15 17 19 21 23 25 27 29 31 33 36 + DEPOLARIZE1(0.0001) 1 3 4 6 9 11 13 15 17 19 21 23 25 27 29 31 33 36 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 + TICK + M(0.005) 1 3 9 11 13 21 23 25 33 4 6 15 17 19 27 29 31 36 + DETECTOR(1, 0, 0, 9) rec[-18] + DETECTOR(1, 2, 0, 11) rec[-17] + DETECTOR(2, 0, 0, 3) rec[-45] rec[-9] + DETECTOR(2, 2, 0, 5) rec[-44] rec[-8] + DETECTOR(3, 1, 0, 10) rec[-16] + DETECTOR(3, 3, 0, 9) rec[-15] + DETECTOR(3, 5, 0, 11) rec[-14] + DETECTOR(4, 1, 0, 4) rec[-43] rec[-7] + DETECTOR(4, 3, 0, 3) rec[-42] rec[-6] + DETECTOR(4, 5, 0, 5) rec[-41] rec[-5] + DETECTOR(5, 0, 0, 9) rec[-13] + DETECTOR(5, 2, 0, 11) rec[-12] + DETECTOR(5, 4, 0, 10) rec[-11] + DETECTOR(6, 0, 0, 3) rec[-40] rec[-4] + DETECTOR(6, 2, 0, 5) rec[-39] rec[-3] + DETECTOR(6, 4, 0, 4) rec[-38] rec[-2] + DETECTOR(7, 1, 0, 10) rec[-10] + DETECTOR(8, 1, 0, 4) rec[-37] rec[-1] + SHIFT_COORDS(0, 0, 1) + DEPOLARIZE1(0.001) 1 3 9 11 13 21 23 25 33 4 6 15 17 19 27 29 31 36 + DEPOLARIZE1(0.0001) 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 + DEPOLARIZE1(0.002) 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 + TICK + R 1 3 9 11 13 21 23 25 33 4 6 15 17 19 27 29 31 36 + X_ERROR(0.002) 1 3 9 11 13 21 23 25 33 4 6 15 17 19 27 29 31 36 + DEPOLARIZE1(0.0001) 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 + DEPOLARIZE1(0.002) 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 + TICK + H 1 3 4 6 9 11 13 15 17 19 21 23 25 27 29 31 33 36 + DEPOLARIZE1(0.0001) 1 3 4 6 9 11 13 15 17 19 21 23 25 27 29 31 33 36 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 + TICK + CZ 1 4 3 6 9 15 11 17 13 19 21 27 23 29 25 31 33 36 + DEPOLARIZE2(0.001) 1 4 3 6 9 15 11 17 13 19 21 27 23 29 25 31 33 36 + DEPOLARIZE1(0.0001) 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 + TICK + H 0 4 6 7 15 17 19 20 26 27 29 31 34 36 + DEPOLARIZE1(0.0001) 0 4 6 7 15 17 19 20 26 27 29 31 34 36 1 2 3 5 8 9 10 11 12 13 14 16 18 21 22 23 24 25 28 30 32 33 35 + TICK + CZ 1 2 4 5 6 7 9 10 11 12 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 33 34 + DEPOLARIZE2(0.001) 1 2 4 5 6 7 9 10 11 12 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 33 34 + DEPOLARIZE1(0.0001) 0 3 8 13 14 31 32 35 36 + TICK + CZ 0 1 4 8 5 9 6 10 7 11 14 21 15 22 16 23 17 24 18 25 19 26 27 32 28 33 29 34 + DEPOLARIZE2(0.001) 0 1 4 8 5 9 6 10 7 11 14 21 15 22 16 23 17 24 18 25 19 26 27 32 28 33 29 34 + DEPOLARIZE1(0.0001) 2 3 12 13 20 30 31 35 36 + TICK + CZ 2 3 5 6 8 9 10 11 12 13 14 15 16 17 18 19 22 23 24 25 28 29 30 31 32 33 35 36 + DEPOLARIZE2(0.001) 2 3 5 6 8 9 10 11 12 13 14 15 16 17 18 19 22 23 24 25 28 29 30 31 32 33 35 36 + DEPOLARIZE1(0.0001) 0 1 4 7 20 21 26 27 34 + TICK + H 0 2 4 5 6 7 8 10 12 14 15 16 17 18 19 20 22 24 26 27 28 29 30 31 32 34 35 36 + DEPOLARIZE1(0.0001) 0 2 4 5 6 7 8 10 12 14 15 16 17 18 19 20 22 24 26 27 28 29 30 31 32 34 35 36 1 3 9 11 13 21 23 25 33 + TICK + CZ 1 4 3 6 9 15 11 17 13 19 21 27 23 29 25 31 33 36 + DEPOLARIZE2(0.001) 1 4 3 6 9 15 11 17 13 19 21 27 23 29 25 31 33 36 + DEPOLARIZE1(0.0001) 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 + TICK + H 1 3 4 6 9 11 13 15 17 19 21 23 25 27 29 31 33 36 + DEPOLARIZE1(0.0001) 1 3 4 6 9 11 13 15 17 19 21 23 25 27 29 31 33 36 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 + TICK + M(0.005) 1 3 9 11 13 21 23 25 33 4 6 15 17 19 27 29 31 36 + DETECTOR(1, 0, 0, 0) rec[-54] rec[-18] + DETECTOR(1, 2, 0, 2) rec[-53] rec[-17] + DETECTOR(2, 0, 0, 6) rec[-9] + DETECTOR(2, 2, 0, 8) rec[-8] + DETECTOR(3, 1, 0, 1) rec[-52] rec[-16] + DETECTOR(3, 3, 0, 0) rec[-51] rec[-15] + DETECTOR(3, 5, 0, 2) rec[-50] rec[-14] + DETECTOR(4, 1, 0, 7) rec[-7] + DETECTOR(4, 3, 0, 6) rec[-6] + DETECTOR(4, 5, 0, 8) rec[-5] + DETECTOR(5, 0, 0, 0) rec[-49] rec[-13] + DETECTOR(5, 2, 0, 2) rec[-48] rec[-12] + DETECTOR(5, 4, 0, 1) rec[-47] rec[-11] + DETECTOR(6, 0, 0, 6) rec[-4] + DETECTOR(6, 2, 0, 8) rec[-3] + DETECTOR(6, 4, 0, 7) rec[-2] + DETECTOR(7, 1, 0, 1) rec[-46] rec[-10] + DETECTOR(8, 1, 0, 7) rec[-1] + SHIFT_COORDS(0, 0, 1) + DEPOLARIZE1(0.001) 1 3 9 11 13 21 23 25 33 4 6 15 17 19 27 29 31 36 + DEPOLARIZE1(0.0001) 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 + DEPOLARIZE1(0.002) 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 + TICK +} +R 36 31 29 27 19 17 15 6 4 33 25 23 21 13 11 9 3 1 +X_ERROR(0.002) 36 31 29 27 19 17 15 6 4 33 25 23 21 13 11 9 3 1 +DEPOLARIZE1(0.0001) 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 +DEPOLARIZE1(0.002) 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 +TICK +H 1 3 4 6 9 11 13 15 17 19 21 23 25 27 29 31 33 36 +DEPOLARIZE1(0.0001) 1 3 4 6 9 11 13 15 17 19 21 23 25 27 29 31 33 36 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 +TICK +CZ 1 4 3 6 9 15 11 17 13 19 21 27 23 29 25 31 33 36 +DEPOLARIZE2(0.001) 1 4 3 6 9 15 11 17 13 19 21 27 23 29 25 31 33 36 +DEPOLARIZE1(0.0001) 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 +TICK +H 0 2 4 5 6 7 8 10 12 14 15 16 17 18 19 20 22 24 26 27 28 29 30 31 32 34 35 36 +DEPOLARIZE1(0.0001) 0 2 4 5 6 7 8 10 12 14 15 16 17 18 19 20 22 24 26 27 28 29 30 31 32 34 35 36 1 3 9 11 13 21 23 25 33 +TICK +CZ 2 3 5 6 8 9 10 11 12 13 14 15 16 17 18 19 22 23 24 25 28 29 30 31 32 33 35 36 +DEPOLARIZE2(0.001) 2 3 5 6 8 9 10 11 12 13 14 15 16 17 18 19 22 23 24 25 28 29 30 31 32 33 35 36 +DEPOLARIZE1(0.0001) 0 1 4 7 20 21 26 27 34 +TICK +CZ 0 1 4 8 5 9 6 10 7 11 14 21 15 22 16 23 17 24 18 25 19 26 27 32 28 33 29 34 +DEPOLARIZE2(0.001) 0 1 4 8 5 9 6 10 7 11 14 21 15 22 16 23 17 24 18 25 19 26 27 32 28 33 29 34 +DEPOLARIZE1(0.0001) 2 3 12 13 20 30 31 35 36 +TICK +CZ 1 2 4 5 6 7 9 10 11 12 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 33 34 +DEPOLARIZE2(0.001) 1 2 4 5 6 7 9 10 11 12 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 33 34 +DEPOLARIZE1(0.0001) 0 3 8 13 14 31 32 35 36 +TICK +H 0 2 4 5 6 7 8 10 12 14 15 16 17 18 19 20 22 24 26 27 28 29 30 31 32 34 35 36 +DEPOLARIZE1(0.0001) 0 2 4 5 6 7 8 10 12 14 15 16 17 18 19 20 22 24 26 27 28 29 30 31 32 34 35 36 1 3 9 11 13 21 23 25 33 +TICK +CZ 1 4 3 6 9 15 11 17 13 19 21 27 23 29 25 31 33 36 +DEPOLARIZE2(0.001) 1 4 3 6 9 15 11 17 13 19 21 27 23 29 25 31 33 36 +DEPOLARIZE1(0.0001) 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 +TICK +H 1 3 4 6 9 11 13 15 17 19 21 23 25 27 29 31 33 36 +DEPOLARIZE1(0.0001) 1 3 4 6 9 11 13 15 17 19 21 23 25 27 29 31 33 36 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 +TICK +M(0.005) 36 31 29 27 19 17 15 6 4 33 25 23 21 13 11 9 3 1 +DETECTOR(1, 0, 0, 0) rec[-36] rec[-1] +DETECTOR(1, 2, 0, 2) rec[-35] rec[-2] +DETECTOR(2, 0, 0, 6) rec[-10] +DETECTOR(2, 2, 0, 8) rec[-11] +DETECTOR(3, 1, 0, 1) rec[-34] rec[-3] +DETECTOR(3, 3, 0, 0) rec[-33] rec[-4] +DETECTOR(3, 5, 0, 2) rec[-32] rec[-5] +DETECTOR(4, 1, 0, 7) rec[-12] +DETECTOR(4, 3, 0, 6) rec[-13] +DETECTOR(4, 5, 0, 8) rec[-14] +DETECTOR(5, 0, 0, 0) rec[-31] rec[-6] +DETECTOR(5, 2, 0, 2) rec[-30] rec[-7] +DETECTOR(5, 4, 0, 1) rec[-29] rec[-8] +DETECTOR(6, 0, 0, 6) rec[-15] +DETECTOR(6, 2, 0, 8) rec[-16] +DETECTOR(6, 4, 0, 7) rec[-17] +DETECTOR(7, 1, 0, 1) rec[-28] rec[-9] +DETECTOR(8, 1, 0, 7) rec[-18] +SHIFT_COORDS(0, 0, 1) +DEPOLARIZE1(0.001) 36 31 29 27 19 17 15 6 4 33 25 23 21 13 11 9 3 1 +DEPOLARIZE1(0.0001) 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 +DEPOLARIZE1(0.002) 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 +TICK +R 36 31 29 27 19 17 15 6 4 33 25 23 21 13 11 9 3 1 +X_ERROR(0.002) 36 31 29 27 19 17 15 6 4 33 25 23 21 13 11 9 3 1 +DEPOLARIZE1(0.0001) 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 +DEPOLARIZE1(0.002) 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 +TICK +H 1 3 4 6 9 11 13 15 17 19 21 23 25 27 29 31 33 36 +DEPOLARIZE1(0.0001) 1 3 4 6 9 11 13 15 17 19 21 23 25 27 29 31 33 36 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 +TICK +CZ 1 4 3 6 9 15 11 17 13 19 21 27 23 29 25 31 33 36 +DEPOLARIZE2(0.001) 1 4 3 6 9 15 11 17 13 19 21 27 23 29 25 31 33 36 +DEPOLARIZE1(0.0001) 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 +TICK +H 1 3 9 11 13 21 23 25 33 +DEPOLARIZE1(0.0001) 1 3 9 11 13 21 23 25 33 0 2 4 5 6 7 8 10 12 14 15 16 17 18 19 20 22 24 26 27 28 29 30 31 32 34 35 36 +TICK +CZ 2 3 5 6 8 9 10 11 12 13 14 15 16 17 18 19 22 23 24 25 28 29 30 31 32 33 35 36 +DEPOLARIZE2(0.001) 2 3 5 6 8 9 10 11 12 13 14 15 16 17 18 19 22 23 24 25 28 29 30 31 32 33 35 36 +DEPOLARIZE1(0.0001) 0 1 4 7 20 21 26 27 34 +TICK +CZ 0 1 4 8 5 9 6 10 7 11 14 21 15 22 16 23 17 24 18 25 19 26 27 32 28 33 29 34 +DEPOLARIZE2(0.001) 0 1 4 8 5 9 6 10 7 11 14 21 15 22 16 23 17 24 18 25 19 26 27 32 28 33 29 34 +DEPOLARIZE1(0.0001) 2 3 12 13 20 30 31 35 36 +TICK +CZ 1 2 4 5 6 7 9 10 11 12 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 33 34 +DEPOLARIZE2(0.001) 1 2 4 5 6 7 9 10 11 12 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 33 34 +DEPOLARIZE1(0.0001) 0 3 8 13 14 31 32 35 36 +TICK +H 1 2 3 5 7 9 10 11 12 13 16 18 20 21 22 23 24 25 26 28 30 33 34 +DEPOLARIZE1(0.0001) 1 2 3 5 7 9 10 11 12 13 16 18 20 21 22 23 24 25 26 28 30 33 34 0 4 6 8 14 15 17 19 27 29 31 32 35 36 +TICK +CZ 1 4 3 6 9 15 11 17 13 19 21 27 23 29 25 31 33 36 +DEPOLARIZE2(0.001) 1 4 3 6 9 15 11 17 13 19 21 27 23 29 25 31 33 36 +DEPOLARIZE1(0.0001) 0 2 5 7 8 10 12 14 16 18 20 22 24 26 28 30 32 34 35 +TICK +H 0 1 3 4 6 8 9 11 13 14 15 17 19 21 23 25 27 29 31 32 33 35 36 +DEPOLARIZE1(0.0001) 0 1 3 4 6 8 9 11 13 14 15 17 19 21 23 25 27 29 31 32 33 35 36 2 5 7 10 12 16 18 20 22 24 26 28 30 34 +TICK +M(0.005) 36 31 29 27 19 17 15 6 4 35 34 32 30 28 26 24 22 20 18 16 14 12 10 8 7 5 2 0 33 25 23 21 13 11 9 3 1 +DETECTOR(1, 0, 0, 9) rec[-1] +DETECTOR(1, 0, 1, 0) rec[-38] rec[-14] rec[-12] rec[-11] rec[-10] rec[-2] +DETECTOR(1, 2, 0, 11) rec[-2] +DETECTOR(1, 2, 1, 2) rec[-39] rec[-15] rec[-13] rec[-12] rec[-11] rec[-2] rec[-1] +DETECTOR(2, 0, 0, 3) rec[-82] rec[-48] rec[-29] +DETECTOR(2, 2, 0, 5) rec[-81] rec[-48] rec[-47] rec[-30] +DETECTOR(3, 1, 0, 10) rec[-3] +DETECTOR(3, 1, 1, 1) rec[-40] rec[-21] rec[-18] rec[-17] rec[-15] rec[-14] rec[-12] rec[-4] rec[-3] +DETECTOR(3, 3, 0, 9) rec[-4] +DETECTOR(3, 3, 1, 0) rec[-41] rec[-22] rec[-19] rec[-18] rec[-16] rec[-15] rec[-13] rec[-5] rec[-4] rec[-3] +DETECTOR(3, 5, 0, 11) rec[-5] +DETECTOR(3, 5, 1, 2) rec[-42] rec[-23] rec[-20] rec[-19] rec[-16] rec[-5] rec[-4] +DETECTOR(4, 1, 0, 4) rec[-80] rec[-50] rec[-49] rec[-31] +DETECTOR(4, 3, 0, 3) rec[-79] rec[-51] rec[-50] rec[-49] rec[-32] +DETECTOR(4, 5, 0, 5) rec[-78] rec[-51] rec[-50] rec[-33] +DETECTOR(5, 0, 0, 9) rec[-6] +DETECTOR(5, 0, 1, 0) rec[-43] rec[-26] rec[-24] rec[-21] rec[-17] rec[-7] +DETECTOR(5, 2, 0, 11) rec[-7] +DETECTOR(5, 2, 1, 2) rec[-44] rec[-27] rec[-25] rec[-24] rec[-22] rec[-21] rec[-18] rec[-8] rec[-7] rec[-6] +DETECTOR(5, 4, 0, 10) rec[-8] +DETECTOR(5, 4, 1, 1) rec[-45] rec[-25] rec[-23] rec[-22] rec[-19] rec[-8] rec[-7] +DETECTOR(6, 0, 0, 3) rec[-77] rec[-53] rec[-34] +DETECTOR(6, 2, 0, 5) rec[-76] rec[-54] rec[-53] rec[-52] rec[-35] +DETECTOR(6, 4, 0, 4) rec[-75] rec[-54] rec[-53] rec[-36] +DETECTOR(7, 1, 0, 10) rec[-9] +DETECTOR(7, 1, 1, 1) rec[-46] rec[-28] rec[-27] rec[-26] rec[-24] rec[-9] +DETECTOR(8, 1, 0, 4) rec[-74] rec[-55] rec[-37] +OBSERVABLE_INCLUDE(0) rec[-28] rec[-27] rec[-26] rec[-25] rec[-24] rec[-23] rec[-22] rec[-21] rec[-20] rec[-19] rec[-18] rec[-17] rec[-16] rec[-15] rec[-14] rec[-13] rec[-12] rec[-11] rec[-10] rec[-9] rec[-8] rec[-7] rec[-5] rec[-4] rec[-3] rec[-2] +SHIFT_COORDS(0, 0, 2) +DEPOLARIZE1(0.001) 36 31 29 27 19 17 15 6 4 35 34 32 30 28 26 24 22 20 18 16 14 12 10 8 7 5 2 0 33 25 23 21 13 11 9 3 1""" + ) diff --git a/src/clorco/color_code/_keyed_constructions.py b/src/clorco/color_code/_keyed_constructions.py index b212bd5..9faed6a 100644 --- a/src/clorco/color_code/_keyed_constructions.py +++ b/src/clorco/color_code/_keyed_constructions.py @@ -40,6 +40,9 @@ from clorco.color_code._toric_color_code_circuits import ( make_toric_color_code_circuit_with_magic_time_boundaries, ) +from clorco.color_code._bell_flagged_planar_color_code_circuits import ( + make_bell_flagged_color_code_circuit, +) def make_named_color_code_constructions() -> ( @@ -50,25 +53,26 @@ def make_named_color_code_constructions() -> ( **_simplified_noise_color_code_constructions(), **_toric_color_code_constructions(), **_superdense_color_code_circuit_constructions(), + **_bell_flagged_color_code_circuit_constructions(), } def f2c(flow: gen.Flow) -> list[float]: c = 0 - if 'color=r' in flow.flags: + if "color=r" in flow.flags: c += 0 - elif 'color=g' in flow.flags: + elif "color=g" in flow.flags: c += 1 - elif 'color=b' in flow.flags: + elif "color=b" in flow.flags: c += 2 else: - raise NotImplementedError(f'{flow=}') - if 'basis=X' in flow.flags: + raise NotImplementedError(f"{flow=}") + if "basis=X" in flow.flags: c += 0 - elif 'basis=Z' in flow.flags: + elif "basis=Z" in flow.flags: c += 3 else: - raise NotImplementedError(f'{flow=}') + raise NotImplementedError(f"{flow=}") return [c] @@ -81,7 +85,11 @@ def _chunks_to_circuit(params: Params, chunks: list[gen.Chunk]) -> stim.Circuit: circuit = gen.compile_chunks_into_circuit(chunks, flow_to_extra_coords_func=f2c) if params.debug_out_dir is not None: - make_layout = make_color_code_layout_488 if '488' in params.style else make_color_code_layout + make_layout = ( + make_color_code_layout_488 + if "488" in params.style + else make_color_code_layout + ) rgb_patch = make_layout( base_width=params.diameter, spurs="midout", @@ -89,7 +97,7 @@ def _chunks_to_circuit(params: Params, chunks: list[gen.Chunk]) -> stim.Circuit: single_rgb_layer_instead_of_actual_code=True, ).patch gen.write_file( - params.debug_out_dir / 'ideal_circuit.html', + params.debug_out_dir / "ideal_circuit.html", gen.stim_circuit_html_viewer(circuit, patch=rgb_patch), ) @@ -100,7 +108,11 @@ def _chunks_to_circuit(params: Params, chunks: list[gen.Chunk]) -> stim.Circuit: circuit = params.noise_model.noisy_circuit(circuit) if params.debug_out_dir is not None: - make_layout = make_color_code_layout_488 if '488' in params.style else make_color_code_layout + make_layout = ( + make_color_code_layout_488 + if "488" in params.style + else make_color_code_layout + ) make_layout( base_width=params.diameter, spurs="smooth", @@ -115,7 +127,7 @@ def _chunks_to_circuit(params: Params, chunks: list[gen.Chunk]) -> stim.Circuit: make_layout( base_width=params.diameter, spurs="smooth", - coord_style=cast(Any, "oct" if '488' in params.style else "hex"), + coord_style=cast(Any, "oct" if "488" in params.style else "hex"), single_rgb_layer_instead_of_actual_code=True, ).patch.write_svg( params.debug_out_dir / "rgb_patch_hex_smooth.svg", @@ -126,7 +138,7 @@ def _chunks_to_circuit(params: Params, chunks: list[gen.Chunk]) -> stim.Circuit: make_layout( base_width=params.diameter, spurs="midout", - coord_style=cast(Any, "oct" if '488' in params.style else "hex"), + coord_style=cast(Any, "oct" if "488" in params.style else "hex"), single_rgb_layer_instead_of_actual_code=True, ).patch.write_svg( params.debug_out_dir / "rgb_patch_hex.svg", @@ -158,26 +170,26 @@ def _chunks_to_circuit(params: Params, chunks: list[gen.Chunk]) -> stim.Circuit: show_measure_qubits=False, ) gen.write_file( - params.debug_out_dir / 'circuit.html', + params.debug_out_dir / "circuit.html", gen.stim_circuit_html_viewer(circuit, patch=rgb_patch), ) return circuit - constructions[ - "mxyz_color_code" - ] = lambda params: make_mxyz_color_code_from_stim_gen( - distance=params.diameter, - rounds=params.rounds, - noise=params.noise_model, - convert_to_cz=params.convert_to_cz, + constructions["mxyz_color_code"] = ( + lambda params: make_mxyz_color_code_from_stim_gen( + distance=params.diameter, + rounds=params.rounds, + noise=params.noise_model, + convert_to_cz=params.convert_to_cz, + ) ) - constructions[ - "phenom_mxyz_color_code" - ] = lambda params: make_mxyz_phenom_color_code( - base_width=params.diameter, - rounds=params.rounds, - noise=params.noise_strength, + constructions["phenom_mxyz_color_code"] = ( + lambda params: make_mxyz_phenom_color_code( + base_width=params.diameter, + rounds=params.rounds, + noise=params.noise_strength, + ) ) constructions["midout_color_code_Z"] = lambda params: _chunks_to_circuit( @@ -253,7 +265,7 @@ def _chunks_to_circuit(params: Params) -> stim.Circuit: ) rgb_patch = make_color_code_layout_for_superdense( base_data_width=params.diameter, - single_rgb_layer_instead_of_actual_code='double_measure_qubit', + single_rgb_layer_instead_of_actual_code="double_measure_qubit", ).patch rgb_patch.write_svg( params.debug_out_dir / "rgb_patch.svg", @@ -282,6 +294,60 @@ def _chunks_to_circuit(params: Params) -> stim.Circuit: return constructions +def _bell_flagged_color_code_circuit_constructions() -> ( + dict[str, Callable[[Params], stim.Circuit]] +): + constructions: dict[str, Callable[[Params], stim.Circuit]] = {} + + def _chunks_to_circuit(params: Params) -> stim.Circuit: + basis = params.style[-1] + assert basis == "X" or basis == "Z" + circuit = make_bell_flagged_color_code_circuit( + base_data_width=params.diameter, + basis=cast(Literal["X", "Z"], basis), + rounds=params.rounds, + ) + + if params.debug_out_dir is not None: + rgb_patch = make_color_code_layout_for_superdense( + base_data_width=params.diameter, + single_rgb_layer_instead_of_actual_code=True, + ).patch + gen.write_file( + params.debug_out_dir / "ideal_circuit.html", + gen.stim_circuit_html_viewer(circuit, patch=rgb_patch), + ) + rgb_patch = make_color_code_layout_for_superdense( + base_data_width=params.diameter, + single_rgb_layer_instead_of_actual_code="double_measure_qubit", + ).patch + rgb_patch.write_svg( + params.debug_out_dir / "rgb_patch.svg", + show_order=False, + show_measure_qubits=False, + ) + rgb_patch.write_svg( + params.debug_out_dir / "rgb_patch_qubits.svg", + show_order=False, + show_measure_qubits=True, + show_data_qubits=True, + ) + make_color_code_layout_for_superdense( + base_data_width=params.diameter, + single_rgb_layer_instead_of_actual_code=False, + ).write_svg(params.debug_out_dir / "code.svg", show_measure_qubits=True) + + if params.convert_to_cz: + circuit = gen.transpile_to_z_basis_interaction_circuit(circuit) + if params.noise_model is not None: + circuit = params.noise_model.noisy_circuit(circuit) + return circuit + + constructions["bell_flagged_color_code_X"] = _chunks_to_circuit + constructions["bell_flagged_color_code_Z"] = _chunks_to_circuit + return constructions + + def _simplified_noise_color_code_constructions() -> ( dict[str, Callable[[Params], stim.Circuit]] ): @@ -417,11 +483,15 @@ def _make_simple_circuit( ) if phenom: circuit = code.make_phenom_circuit( - noise=params.noise_strength, rounds=params.rounds, extra_coords_func=f2c, + noise=params.noise_strength, + rounds=params.rounds, + extra_coords_func=f2c, ) else: assert params.rounds == 1 - circuit = code.make_code_capacity_circuit(noise=params.noise_strength, extra_coords_func=f2c) + circuit = code.make_code_capacity_circuit( + noise=params.noise_strength, extra_coords_func=f2c + ) if params.debug_out_dir is not None: gen.write_file( params.debug_out_dir / "detslice.svg", circuit.diagram("detslice-svg")