From b1f19b00dd24ca8cafdde20fc6ebfd74a1425ecb Mon Sep 17 00:00:00 2001 From: Rafael Haenel Date: Wed, 18 Nov 2026 14:54:26 -0700 Subject: [PATCH 1/6] feat(experimental): determined measurements of non-Clifford circuits Add tsim.experimental.count_determined_measurements and missing_detectors, the non-Clifford counterparts of Stim's methods, and nondeterministic_detectors, which lists the declared detectors and observables that are random without noise. A parity is determined when every noiseless record gives it the same value, so the determined parities annihilate the directions of the records' affine span. The exact path compiles the noiseless circuit and walks each tape's branches (Branches.support), adding unread fair coins as directions; unknown inputs enumerate their independent rotation signs, one walk per distinct signs of each tape. The sampled path spans the shots' differences. missing_detectors puts determined parities of random detectors first, which heals circuits whose S gates became T gates. Branches now drops an outcome by its probability given the lane, not by the lane's absolute weight, and gains support() and coin_rows. Integration tests reproduce published cultivation circuits: Chan et al.'s uncorrected and corrected d=5 circuits, each rule of Clifft's S-to-T converter, and Wan & Zapirain's d=3 and d=5 inputs. Co-Authored-By: Claude Opus 5.5 --- CHANGELOG.md | 10 + src/tsim/determined.py | 410 ++++++++++++++++++ src/tsim/experimental.py | 12 + src/tsim/statevector/branches.py | 94 +++- src/tsim/utils/gf2_span.py | 171 ++++++++ test/data/determined/README.md | 10 + .../integration/test_determined_literature.py | 142 ++++++ test/unit/statevector/test_branches.py | 31 ++ test/unit/test_determined.py | 291 +++++++++++++ test/unit/test_public_api.py | 13 + test/unit/utils/test_gf2_span.py | 60 +++ 11 files changed, 1221 insertions(+), 23 deletions(-) create mode 100644 src/tsim/determined.py create mode 100644 src/tsim/utils/gf2_span.py create mode 100644 test/data/determined/README.md create mode 100644 test/integration/test_determined_literature.py create mode 100644 test/unit/test_determined.py create mode 100644 test/unit/utils/test_gf2_span.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 37cf0ce3..8a1240c9 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -18,6 +18,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 The fault distance of d=5 T-state cultivation (3, as found by [Chan et al.](https://arxiv.org/abs/2609.17706)) takes under a second, and that of its Z-flagged version (4) takes 5 s. +- **Determined measurements of non-Clifford circuits (experimental).** + `tsim.experimental.count_determined_measurements` and `missing_detectors` + work like Stim's methods of those names for circuits with T gates, either + exactly or from `shots` noiseless samples. `nondeterministic_detectors` lists + the declared detectors and observables that are random without noise, and + `missing_detectors` returns the parities of random detectors that stay + determined first, which repairs a circuit whose S gates became T gates. On + the d=5 cultivation circuits of [Chan et al.](https://arxiv.org/abs/2609.17706), + they find the 4 random detectors of the uncorrected circuit and none in the + corrected ones. ### Changed - The stabilizer-rank strategies compile components of the same shape once, and diff --git a/src/tsim/determined.py b/src/tsim/determined.py new file mode 100644 index 00000000..142afeee --- /dev/null +++ b/src/tsim/determined.py @@ -0,0 +1,410 @@ +"""Parities of measurements that every noiseless shot gives the same value. + +These are the parities that can be detectors or observables. Stim finds them +for Clifford circuits with a tableau (``stim.Circuit.count_determined_measurements`` +and ``stim.Circuit.missing_detectors``); this module finds them for any circuit +that Tsim samples, in two ways. + +A parity ``c`` is determined when ``c · m`` is the same for every record ``m`` +that a noiseless shot can give, that is when ``c`` is orthogonal to the +directions ``m + m₀`` of the affine span of those records. The determined +parities are therefore a linear space, of dimension the number of measurements +minus that of the directions. + +- Exactly (``shots=None``): Tsim compiles the noiseless circuit to direct + outputs, which are constants, and statevector tapes, which are independent. + ``Branches.support`` walks both outcomes of each measurement of a tape, but + for fair coins that no rotation reads, which only add their output flips as + directions. A measurement outcome less likely than ``IMPOSSIBLE`` (1e-12) + given the ones before counts as impossible. +- From samples (``shots=n``): the directions of ``n`` noiseless shots. A parity + that flips in a fraction ``q`` of shots survives ``n`` shots with probability + ``(1 - q)^n``, so this is right with high confidence when ``n ≫ 1/q``, and it + needs no walk. + +With ``unknown_input=True`` the qubits start maximally mixed, which is a random +computational basis state: an ``X_ERROR(0.5)`` on every qubit at the start. +Its f-bits flip outputs (``A``) and rotation signs (``B``). Those in the kernel +of ``B`` only add their columns of ``A``; the exact path tries every +combination of the others and walks each tape once per distinct signs. +""" + +from __future__ import annotations + +import warnings +from itertools import product +from typing import TYPE_CHECKING + +import numba +import numpy as np +import stim + +from tsim.compile.pipeline import compile_program +from tsim.core.graph import prepare_graph +from tsim.statevector.branches import Branches, gf2_product +from tsim.statevector.program import StatevectorComponent +from tsim.utils.gf2_span import Span, num_words, pack, pack_bytes, unpack + +if TYPE_CHECKING: + from tsim.circuit import Circuit + +MAX_SIGN_BITS = 16 +"""Most independent rotation signs that unknown inputs may set, exactly.""" + +BATCH = 1 << 16 +"""Shots drawn, or combinations of unknown inputs tried, at a time.""" + + +def count_determined_measurements( + circuit: Circuit, + *, + unknown_input: bool = False, + shots: int | None = None, + seed: int | None = None, +) -> int: + """Count the measurements that earlier measurements predict, without noise. + + As ``stim.Circuit.count_determined_measurements``, for any circuit: the + number of independent parities of measurements that every noiseless shot + gives the same value. In a Clifford circuit that is the number of + measurements that are a parity of earlier ones, as in Stim. With + non-Clifford gates a measurement can also be a nonlinear function of + earlier ones, which this does not count, since no detector can use it. + + If ``circuit.num_detectors + circuit.num_observables`` is below the count, + some detectors may be missing (``missing_detectors``); if some declared + detectors are random, ``nondeterministic_detectors`` lists them. + + Args: + circuit: The circuit. Its noise is ignored. + unknown_input: If True, the qubits start in unknown random states + rather than in ``|0⟩``. + shots: If given, estimate from this many noiseless shots instead of + exactly; see the module docstring. + seed: The seed of the shots, if any. + + Returns: + The number of determined measurements. + + Raises: + ValueError: If the exact walk follows more than + ``Branches.MAX_BRANCHES`` branches per combination of inputs, or + unknown inputs set more than ``MAX_SIGN_BITS`` independent + rotation signs. Sampling avoids both. + + """ + directions = _directions(circuit, unknown_input, shots, seed) + return circuit.num_measurements - directions.rank + + +def missing_detectors( + circuit: Circuit, + *, + unknown_input: bool = False, + shots: int | None = None, + seed: int | None = None, +) -> stim.Circuit: + """Return detectors for the determined parities that no declaration covers. + + As ``stim.Circuit.missing_detectors``, for any circuit: the returned + ``DETECTOR`` instructions can be appended to ``circuit``, and then every + determined parity (``count_determined_measurements``) is a parity of its + determined detectors and observables. A random declared detector + (``nondeterministic_detectors``) covers nothing, but parities of random + detectors that are determined come first in the result, so it heals them: + if S gates became T gates and randomized detectors ``D1`` and ``D2`` while + ``D1 ⊕ D2`` stayed determined, that is a returned detector. Like Stim's, the + result is no particularly good basis otherwise. + + A Tsim detector is its raw parity, so a returned one whose noiseless value + is 1 fires in every shot unless the sampler XORs in a reference sample + (``use_detector_reference_sample=True``). + + Args: + circuit: The circuit. Its noise is ignored. + unknown_input: As in ``count_determined_measurements``. + shots: As in ``count_determined_measurements``. + seed: As in ``count_determined_measurements``. + + Returns: + A circuit of ``DETECTOR`` instructions. + + """ + num_m = circuit.num_measurements + directions = _directions(circuit, unknown_input, shots, seed) + declared = _Declared(circuit.stim_circuit) + overlaps = declared.overlaps(directions.basis()) + random = np.flatnonzero(overlaps.any(axis=1)) + covered = Span(num_m) + covered.insert(np.delete(declared.words, random, axis=0)) + # NOTE: a parity of random declarations is determined when it overlaps no + # direction; the kernel's rows end at distinct declarations, so they pair + # each random one with earlier ones where they can. + kernel = Span(len(random)) + kernel.insert_bits(unpack(overlaps[random], directions.rank).T) + combinations = unpack(kernel.annihilator(), len(random)).astype(bool) + healed = np.zeros((len(combinations), num_words(num_m)), dtype=np.uint64) + for i, combination in enumerate(combinations): + healed[i] = np.bitwise_xor.reduce(declared.words[random[combination]], axis=0) + candidates = np.concatenate([healed, directions.annihilator()]) + result = stim.Circuit() + for words in candidates[covered.insert(candidates)]: + records = np.flatnonzero(unpack(words[None], num_m)[0]) + result.append("DETECTOR", [stim.target_rec(int(m) - num_m) for m in records]) + return result + + +def nondeterministic_detectors( + circuit: Circuit, + *, + unknown_input: bool = False, + shots: int | None = None, + seed: int | None = None, +) -> list[stim.DemTarget]: + """Return the declared detectors and observables that are random without noise. + + Stim refuses such a circuit when it makes a detector error model. With + non-Clifford gates they are common: replacing the S gates of a Clifford + proxy by T gates randomizes some of its detectors. A declared parity is + random when it is not a determined parity (``count_determined_measurements``). + + Args: + circuit: The circuit. Its noise is ignored. + unknown_input: As in ``count_determined_measurements``. + shots: As in ``count_determined_measurements``; then a listed detector + is certainly random, but an unlisted one may be random rarely. + seed: As in ``count_determined_measurements``. + + Returns: + The random detectors (``stim.target_relative_detector_id``) and then + the random observables (``stim.target_logical_observable_id``). + + """ + directions = _directions(circuit, unknown_input, shots, seed) + overlaps = _Declared(circuit.stim_circuit).overlaps(directions.basis()) + num_detectors = circuit.num_detectors + return [ + ( + stim.target_relative_detector_id(index) + if index < num_detectors + else stim.target_logical_observable_id(index - num_detectors) + ) + for index in np.flatnonzero(overlaps.any(axis=1)).tolist() + ] + + +class _Declared: + """The measurements of each detector and then each observable. + + Attributes: + starts: Where each declaration's measurements start in ``records``, + and the end. + records: The measurements of each declaration, sorted. + words: Each declaration as a packed vector over the measurements. + + """ + + def __init__(self, circuit: stim.Circuit) -> None: + num_m = circuit.num_measurements + num_detectors = circuit.num_detectors + rows, records = [], [] + measured = detector = 0 + for instruction in circuit.flattened(): + assert isinstance(instruction, stim.CircuitInstruction) + if instruction.name == "DETECTOR": + row = detector + detector += 1 + elif instruction.name == "OBSERVABLE_INCLUDE": + row = num_detectors + int(instruction.gate_args_copy()[0]) + else: + measured += instruction.num_measurements + continue + for target in instruction.targets_copy(): + if not target.is_measurement_record_target: + raise ValueError( + f"{instruction.name} with a non-record target ({target}) " + "is not supported" + ) + rows.append(row) + records.append(measured + target.value) + # NOTE: a measurement that a declaration names twice cancels. + keys, counts = np.unique( + np.array(rows, dtype=np.int64) * num_m + np.array(records, dtype=np.int64), + return_counts=True, + ) + keys = keys[counts % 2 == 1] + row, self.records = np.divmod(keys, max(num_m, 1)) + count = num_detectors + circuit.num_observables + self.starts = np.searchsorted(row, np.arange(count + 1)) + self.words = np.zeros((count, num_words(num_m)), dtype=np.uint64) + np.bitwise_or.at( + self.words, + (row, self.records // 64), + np.uint64(1) << (self.records % 64).astype(np.uint64), + ) + + def overlaps(self, directions: np.ndarray) -> np.ndarray: + """Return, packed, which of the packed ``directions`` each declaration flips.""" + return _overlaps(np.ascontiguousarray(directions), self.starts, self.records) + + +@numba.njit(cache=True) +def _overlaps( + directions: np.ndarray, starts: np.ndarray, records: np.ndarray +) -> np.ndarray: + result = np.zeros((len(starts) - 1, max(1, -(-len(directions) // 64))), np.uint64) + for d in range(len(directions)): + word, bit = d // 64, np.uint64(1) << np.uint64(d % 64) + for k in range(len(starts) - 1): + parity = np.uint64(0) + for m in records[starts[k] : starts[k + 1]]: + parity ^= directions[d, m // 64] >> np.uint64(m % 64) + if parity & np.uint64(1): + result[k, word] |= bit + return result + + +def _directions( + circuit: Circuit, unknown_input: bool, shots: int | None, seed: int | None +) -> Span: + """Return the span of ``m + m₀`` over the noiseless records ``m``.""" + from tsim.circuit import Circuit + + noiseless = circuit.without_noise().without_annotations() + if unknown_input and noiseless.num_qubits: + mixed = stim.Circuit() + mixed.append("X_ERROR", range(noiseless.num_qubits), 0.5) + noiseless = Circuit.from_stim_program(mixed) + noiseless + if shots is None: + return _exact_directions(noiseless) + if shots < 1: + raise ValueError(f"shots must be at least 1, not {shots}") + return _sampled_directions(noiseless, shots, seed) + + +def _sampled_directions(circuit: Circuit, shots: int, seed: int | None) -> Span: + """Return the span of ``m + m₀`` over ``shots`` noiseless shots ``m``.""" + num_m = circuit.num_measurements + span = Span(num_m) + sampler = circuit.compile_sampler(seed=seed) + reference = None + last_growth = 0 + for done in range(0, shots, BATCH): + count = min(BATCH, shots - done) + words = pack_bytes(sampler.sample(count, bit_packed=True), num_m) + if reference is None: + reference = words[0].copy() + rows, first = np.unique(words ^ reference, axis=0, return_index=True) + # NOTE: in shot order, so that ``last_growth`` is the last shot that grew it. + order = np.argsort(first) + grew = span.insert(rows[order]) + if grew.any(): + last_growth = done + int(first[order][grew].max()) + 1 + if last_growth > shots // 2: + warnings.warn( + f"shot {last_growth} of {shots} still found a new direction, so some " + "parities that look determined may be random; use more shots", + stacklevel=4, + ) + return span + + +def _exact_directions(circuit: Circuit) -> Span: + """Return the span of ``m + m₀`` over every noiseless record ``m``.""" + prepared = prepare_graph(circuit, sample_detectors=False) + program = compile_program( + prepared, mode="sequential", strategy="active_statevector" + ) + num_m = prepared.num_outputs + num_f = prepared.error_transform.shape[0] + span = Span(num_m) + + # NOTE: the f-bits, set only by unknown inputs, are fair and independent. + output_map = np.zeros((num_m, num_f), dtype=np.uint8) + constant = np.zeros(num_m, dtype=np.uint8) + direct = program.output_order[: len(program.direct_f_indices)] + constant[direct] = program.direct_flips + reads = program.direct_f_indices >= 0 + output_map[direct[reads], program.direct_f_indices[reads]] = 1 + tapes: list[tuple[Branches, np.ndarray]] = [] + sign_maps = [np.zeros((0, num_f), dtype=np.uint8)] + for component in program.components: + assert isinstance(component, StatevectorComponent) + branches = Branches(component, num_detectors=0) + outputs = np.asarray(component.output_indices, dtype=np.int64) + tapes.append((branches, outputs)) + output_map[np.ix_(outputs, branches.f_selection)] ^= branches.output_rows + sign_map = np.zeros((len(branches.sign_rows), num_f), dtype=np.uint8) + sign_map[:, branches.f_selection] = branches.sign_rows + sign_maps.append(sign_map) + span.insert_bits(_embed(branches.coin_rows, outputs, num_m)) + sign_map = np.concatenate(sign_maps) + span.insert_bits(gf2_product(_kernel(sign_map), output_map)) + + choices = _independent_columns(sign_map) + if len(choices) > MAX_SIGN_BITS: + raise ValueError( + f"unknown inputs set {len(choices)} independent rotation signs, more " + f"than {MAX_SIGN_BITS}; pass shots to sample instead" + ) + f = np.zeros((1 << len(choices), num_f), dtype=np.uint8) + f[:, choices] = list(product((0, 1), repeat=len(choices))) + + # NOTE: a tape's outputs are its f-bits' flips XOR a value that depends + # only on its rotation signs: walk each distinct signs once. + bases = [] + for branches, outputs in tapes: + local = f[:, branches.f_selection] + first, inverse = _groups(gf2_product(local, branches.sign_rows)) + row, values = branches.support(local[first]) + firsts = values[np.searchsorted(row, np.arange(len(first)))] + within = Span(len(outputs)) + within.insert_bits(values ^ firsts[row]) + span.insert_bits(_embed(unpack(within.basis(), len(outputs)), outputs, num_m)) + base = firsts ^ gf2_product(local[first], branches.output_rows) + bases.append((inverse, base, outputs)) + reference = None + for start in range(0, len(f), BATCH): + chunk = slice(start, start + BATCH) + points = gf2_product(f[chunk], output_map) ^ constant + for inverse, base, outputs in bases: + points[:, outputs] ^= base[inverse[chunk]] + if reference is None: + reference = points[0].copy() + span.insert_bits(points ^ reference) + return span + + +def _groups(rows: np.ndarray) -> tuple[np.ndarray, np.ndarray]: + """Return the first index of each distinct row, and each row's group.""" + if rows.shape[1] == 0: + return np.zeros(1, dtype=np.int64), np.zeros(len(rows), dtype=np.int64) + _, first, inverse = np.unique(rows, axis=0, return_index=True, return_inverse=True) + return first, inverse.ravel() + + +def _embed(local: np.ndarray, outputs: np.ndarray, num_m: int) -> np.ndarray: + """Return rows over a tape's outputs as rows over all ``num_m`` measurements.""" + rows = np.zeros((len(local), num_m), dtype=np.uint8) + rows[:, outputs] = local + return rows + + +def _kernel(matrix: np.ndarray) -> np.ndarray: + """Return a basis of the vectors ``v`` with ``matrix @ v = 0``, as 0/1 rows.""" + span = Span(matrix.shape[1]) + span.insert_bits(matrix) + return unpack(span.annihilator(), matrix.shape[1]) + + +def _independent_columns(matrix: np.ndarray) -> np.ndarray: + """Return columns of ``matrix`` that form a basis of its column space.""" + span = Span(matrix.shape[0]) + return np.flatnonzero(span.insert(pack(matrix.T))) + + +__all__ = [ + "count_determined_measurements", + "missing_detectors", + "nondeterministic_detectors", +] diff --git a/src/tsim/experimental.py b/src/tsim/experimental.py index 1da6fef2..61eb335f 100644 --- a/src/tsim/experimental.py +++ b/src/tsim/experimental.py @@ -10,8 +10,17 @@ - `shortest_errors` finds a circuit's fault distance: every smallest set of faults that flips an observable without flipping a detector, as `LogicalError`s of `Fault`s. +- `count_determined_measurements`, `missing_detectors` and + `nondeterministic_detectors` find the parities of measurements that every + noiseless shot gives the same value, as Stim's methods of those names do for + Clifford circuits, and the declared detectors that are random. """ +from tsim.determined import ( + count_determined_measurements as count_determined_measurements, + missing_detectors as missing_detectors, + nondeterministic_detectors as nondeterministic_detectors, +) from tsim.noise.faults import ( Fault as Fault, LogicalError as LogicalError, @@ -29,5 +38,8 @@ "Fault", "LogicalError", "SteaneEncoder", + "count_determined_measurements", + "missing_detectors", + "nondeterministic_detectors", "shortest_errors", ] diff --git a/src/tsim/statevector/branches.py b/src/tsim/statevector/branches.py index 621e9b28..9b3db051 100644 --- a/src/tsim/statevector/branches.py +++ b/src/tsim/statevector/branches.py @@ -27,7 +27,7 @@ """Most measurement branches that one row of f-bits may have.""" IMPOSSIBLE = 1e-12 -"""Weight below which a measurement outcome cannot happen.""" +"""Probability below which a measurement outcome cannot happen.""" _I_POWERS = (1, 1j, -1, -1j) @@ -66,6 +66,9 @@ class Branches: sign_rows: The component f-bits that each rotation's sign reads. output_rows: The component f-bits that each output slot reads. observable: Whether each output slot is an observable. + coin_rows: The output slots that each fair coin flips, for the coins + that ``support`` fixes at 0: dormant measurements that no + rotation reads. """ @@ -88,6 +91,13 @@ def __init__(self, component: StatevectorComponent, num_detectors: int) -> None: self._outputs = np.asarray(component.output_indices, dtype=np.int64) self._num_detectors = num_detectors self.observable = self._outputs >= num_detectors + # NOTE: a dormant measurement leaves the amplitudes alone; if no rotation + # reads it either, it only flips outputs, independently of the rest. + dormant = np.flatnonzero(tape.kind == MEASURE_DORMANT) + unread = ~np.asarray(self._sign_b.any(axis=0))[self._branch[dormant]] + self._coins = np.zeros(len(tape.kind), dtype=bool) + self._coins[dormant[unread]] = True + self.coin_rows = self._out_b[:, self._branch[dormant[unread]]].T @cached_property def reference(self) -> np.ndarray: @@ -136,39 +146,72 @@ def outcomes(self, f: np.ndarray) -> list[tuple[np.ndarray, np.ndarray]]: """ f = np.asarray(f, dtype=np.uint8) flips = gf2_product(f, self.output_rows) ^ self.reference - rows, weights, deviations = [], [], [] + row, weight, outputs = self._collect(f, skip_coins=False) + deviation = outputs ^ flips[row] + bounds = np.searchsorted(row, np.arange(len(f) + 1)) + result = [] + for r in range(len(f)): + mine = slice(bounds[r], bounds[r + 1]) + values, group = np.unique(deviation[mine], axis=0, return_inverse=True) + probability = np.zeros(len(values)) + np.add.at(probability, group.ravel(), weight[mine]) + result.append((values, probability)) + return result + + def support(self, f: np.ndarray) -> tuple[np.ndarray, np.ndarray]: + """Return the output values that each row of f-bits can give. + + The walk fixes the coins of ``coin_rows`` at 0: each of them flips the + outputs by its row of ``coin_rows`` with probability 1/2, whatever + else happens. + + Args: + f: The component's f-bits, shape ``(rows, len(f_selection))``. + + Returns: + The row of ``f`` of each possible outcome, in increasing order, + and its output values, shape ``(outcomes, output slots)``. + + Raises: + ValueError: If the walk has more than ``MAX_BRANCHES`` branches + per row. + + """ + row, _, outputs = self._collect(np.asarray(f, dtype=np.uint8), skip_coins=True) + return row, outputs + + def _collect( + self, f: np.ndarray, *, skip_coins: bool + ) -> tuple[np.ndarray, np.ndarray, np.ndarray]: + """Return every branch's row, probability and outputs, sorted by row.""" + rows, weights, outputs = [], [], [] leaves = 0 - for row, weight, outputs in self._leaves(f): + for row, weight, out in self._leaves(f, skip_coins=skip_coins): + rows.append(row) + weights.append(weight) + outputs.append(out) leaves += len(row) if leaves > MAX_BRANCHES * len(f): raise ValueError( f"the tape has more than {MAX_BRANCHES} measurement branches" ) - rows.append(row) - weights.append(weight) - deviations.append(outputs ^ flips[row]) row = np.concatenate(rows) - weight = np.concatenate(weights) - deviation = np.concatenate(deviations) order = np.argsort(row, kind="stable") - bounds = np.searchsorted(row[order], np.arange(len(f) + 1)) - result = [] - for r in range(len(f)): - mine = order[bounds[r] : bounds[r + 1]] - values, group = np.unique(deviation[mine], axis=0, return_inverse=True) - probability = np.zeros(len(values)) - np.add.at(probability, group.ravel(), weight[mine]) - result.append((values, probability)) - return result + return ( + row[order], + np.concatenate(weights)[order], + np.concatenate(outputs)[order], + ) def _leaves( - self, f: np.ndarray + self, f: np.ndarray, *, skip_coins: bool = False ) -> Iterator[tuple[np.ndarray, np.ndarray, np.ndarray]]: """Yield the branches that reach the end of the tape, in batches. A batch is the row of ``f`` of each branch, its probability and its - output values. + output values. With ``skip_coins``, the coins of ``coin_rows`` land 0. """ + skip = self._coins if skip_coins else np.zeros_like(self._coins) tape = self._tape sign = np.zeros((len(f), len(tape.kind)), dtype=np.uint8) sign[:, self._rotations] = gf2_product(f, self.sign_rows) @@ -180,7 +223,7 @@ def _leaves( amps = np.zeros((len(row), self._size), dtype=np.complex128) amps[:, 0] = 1.0 bits = np.zeros((len(row), self._out_b.shape[1]), dtype=np.uint8) - yield from self._walk(0, amps, row, bits, sign, out) + yield from self._walk(0, amps, row, bits, sign, out, skip) def _walk( self, @@ -190,16 +233,19 @@ def _walk( bits: np.ndarray, sign: np.ndarray, out: np.ndarray, + skip: np.ndarray, ) -> Iterator[tuple[np.ndarray, np.ndarray, np.ndarray]]: """Run the actions from ``start`` on lanes and yield those that finish. Lane ``i`` has amplitudes ``amps[i]``, whose squared norm is its probability, belongs to row ``row[i]`` and has branch bits ``bits[i]``. ``sign`` and ``out`` hold the rows' f-bit parts of the action signs and - of the outputs. + of the outputs. The actions of ``skip`` do not run. """ tape = self._tape for a in range(start, len(tape.kind)): + if skip[a]: + continue x, z = int(tape.x_mask[a]), int(tape.z_mask[a]) # NOTE: the Pauli P = i^|x&z| X^x Z^z takes amplitudes ``amps`` to # ``amps[:, source] * phase``. @@ -219,7 +265,9 @@ def _walk( else: moved = amps[:, source] * phase projected = (amps - moved if outcome else amps + moved) / 2 - kept = np.flatnonzero(_weights(projected) > IMPOSSIBLE) + # NOTE: relative to the lane's weight, as ``shared._cut``. + possible = _weights(projected) > IMPOSSIBLE * _weights(amps) + kept = np.flatnonzero(possible) projected = projected[kept] # NOTE: the planner moved the measured Pauli onto the pivot, # which ends in |0>, as in ``shared._project_range``. @@ -240,7 +288,7 @@ def _walk( half = len(row) // 2 for part in (slice(0, half), slice(half, None)): yield from self._walk( - a + 1, amps[part], row[part], bits[part], sign, out + a + 1, amps[part], row[part], bits[part], sign, out, skip ) return yield row, _weights(amps), out[row] ^ _bit_parity(bits, self._out_b) diff --git a/src/tsim/utils/gf2_span.py b/src/tsim/utils/gf2_span.py new file mode 100644 index 00000000..905db77c --- /dev/null +++ b/src/tsim/utils/gf2_span.py @@ -0,0 +1,171 @@ +"""A growing span of GF(2) vectors, packed into 64-bit words. + +``Span`` keeps one basis vector per pivot, the lowest set bit of that vector, +so inserting a vector reduces it by at most one basis vector per pivot, as +``linalg.find_basis`` does with Python integers. Its annihilator, the vectors +orthogonal to the whole span, then has one basis vector per column that is no +pivot: that column plus the pivots before it. +""" + +from __future__ import annotations + +import numba +import numpy as np + + +def num_words(width: int) -> int: + """Return the 64-bit words of a packed vector of ``width`` bits.""" + return max(1, -(-width // 64)) + + +def pack(bits: np.ndarray) -> np.ndarray: + """Return rows of 0/1 entries as rows of little-endian 64-bit words.""" + bits = np.asarray(bits, dtype=np.uint8) + rows, width = bits.shape + padded = np.zeros((rows, num_words(width) * 64), dtype=np.uint8) + padded[:, :width] = bits + packed = np.packbits(padded, axis=1, bitorder="little") + return packed.view(" np.ndarray: + """Return little-endian bit-packed bytes, ``width`` bits a row, as 64-bit words.""" + padded = np.zeros((len(rows), num_words(width) * 8), dtype=np.uint8) + padded[:, : rows.shape[1]] = rows + return padded.view(" np.ndarray: + """Return rows of 64-bit words as rows of ``width`` 0/1 entries.""" + as_bytes = np.ascontiguousarray(words).view(np.uint8) + return np.unpackbits(as_bytes, axis=1, bitorder="little")[:, :width] + + +@numba.njit(cache=True) +def _lowest(row: np.ndarray) -> int: + for w in range(len(row)): + word = row[w] + if word: + bit = 0 + while not (word >> np.uint64(bit)) & np.uint64(1): + bit += 1 + return 64 * w + bit + return -1 + + +@numba.njit(cache=True) +def _has_bit(row: np.ndarray, column: int) -> bool: + return bool((row[column // 64] >> np.uint64(column % 64)) & np.uint64(1)) + + +@numba.njit(cache=True) +def _insert(basis: np.ndarray, has: np.ndarray, rows: np.ndarray) -> np.ndarray: + """Insert ``rows`` and return, for each, whether it grew the span.""" + grew = np.zeros(len(rows), dtype=np.bool_) + v = np.empty(basis.shape[1], dtype=np.uint64) + for i in range(len(rows)): + v[:] = rows[i] + while True: + p = _lowest(v) + if p < 0: + break + if has[p]: + v ^= basis[p] + else: + basis[p] = v + has[p] = True + grew[i] = True + break + return grew + + +@numba.njit(cache=True) +def _contains(basis: np.ndarray, has: np.ndarray, rows: np.ndarray) -> np.ndarray: + """Return, for each of ``rows``, whether it is in the span.""" + inside = np.ones(len(rows), dtype=np.bool_) + v = np.empty(basis.shape[1], dtype=np.uint64) + for i in range(len(rows)): + v[:] = rows[i] + while True: + p = _lowest(v) + if p < 0: + break + if not has[p]: + inside[i] = False + break + v ^= basis[p] + return inside + + +@numba.njit(cache=True) +def _annihilator(basis: np.ndarray, has: np.ndarray) -> np.ndarray: + """Return, per column j that is no pivot, e_j plus the pivots before it, packed.""" + width = len(has) + reduced = basis.copy() + # NOTE: clearing each pivot column from the other basis vectors, from the + # last pivot down, leaves each with its pivot and columns that are none. + for p in range(width - 1, -1, -1): + if has[p]: + for q in range(p): + if has[q] and _has_bit(reduced[q], p): + reduced[q] ^= reduced[p] + slot = np.full(width, -1, dtype=np.int64) + count = 0 + for j in range(width): + if not has[j]: + slot[j] = count + count += 1 + result = np.zeros((count, basis.shape[1]), dtype=np.uint64) + for j in range(width): + if slot[j] >= 0: + result[slot[j], j // 64] |= np.uint64(1) << np.uint64(j % 64) + for p in range(width): + if has[p]: + for j in range(p + 1, width): + if slot[j] >= 0 and _has_bit(reduced[p], j): + result[slot[j], p // 64] |= np.uint64(1) << np.uint64(p % 64) + return result + + +class Span: + """The span of the vectors inserted so far, in ``GF(2)^width``.""" + + def __init__(self, width: int) -> None: + """Start with the zero span.""" + self.width = width + self._basis = np.zeros((width, num_words(width)), dtype=np.uint64) + self._has = np.zeros(width, dtype=np.bool_) + + @property + def rank(self) -> int: + """Return the dimension of the span.""" + return int(self._has.sum()) + + def basis(self) -> np.ndarray: + """Return a basis of the span, packed.""" + return self._basis[self._has] + + def insert(self, words: np.ndarray) -> np.ndarray: + """Insert packed vectors and return, for each, whether it grew the span.""" + return _insert(self._basis, self._has, self._rows(words)) + + def insert_bits(self, bits: np.ndarray) -> np.ndarray: + """Insert vectors of 0/1 entries; see ``insert``.""" + bits = np.asarray(bits, dtype=np.uint8) + return self.insert(pack(bits[None] if bits.ndim == 1 else bits)) + + def contains(self, words: np.ndarray) -> np.ndarray: + """Return, for each packed vector, whether it is in the span.""" + return _contains(self._basis, self._has, self._rows(words)) + + def annihilator(self) -> np.ndarray: + """Return a basis of the vectors orthogonal to the span, packed. + + Row ``i`` is a column ``j`` that is no pivot plus pivots before ``j``, + so the rows end at distinct columns, in increasing order. + """ + return _annihilator(self._basis, self._has) + + def _rows(self, words: np.ndarray) -> np.ndarray: + words = np.ascontiguousarray(words, dtype=np.uint64) + return words.reshape(-1, num_words(self.width)) diff --git a/test/data/determined/README.md b/test/data/determined/README.md new file mode 100644 index 00000000..1ed692c4 --- /dev/null +++ b/test/data/determined/README.md @@ -0,0 +1,10 @@ +# Cultivation circuits with T gates + +Noiseless copies of published magic state cultivation circuits, for the +integration tests in `test/integration/test_determined_literature.py`. + +| file | source | +|---|---| +| `chan_d5a19[f13][_uncorrected]_T.stim` | Chan, Strikis, Sun, Cai, arXiv:2609.17706, [timchan0/cliffordea](https://github.com/timchan0/cliffordea) `sim/stim_files/` at `27385c6` (MIT). S proxies, with S/S_DAG swapped for T/T_DAG as in `circuit_text.swap_t_and_s_gates`. The `_uncorrected` ones are the inputs of the paper's d=5 correction (`sim/d5-correction.md`). | +| `clifft_d5_sproxy.stim`, `clifft_d5_T*.stim` | Clifft, arXiv:2604.27058, [unitaryfoundation/clifft-paper](https://github.com/unitaryfoundation/clifft-paper) `magic_state_cultivation/convert_s_to_t.py` (Apache-2.0). Gidney's d=5 inject+cultivate S proxy; `_T_rule1` only swaps S for T, `_T_rule12` also applies the errata flips, `_T` is the full conversion with feedforward and detector healing. | +| `wan_clifft_d3_T.stim`, `wan_soft_d5_T.stim` | Wan and Zapirain, arXiv:2609.18922, [kh428/exact_ler_for_msc](https://github.com/kh428/exact_ler_for_msc) `data/inputs/` at `332bc04` (Apache-2.0): Clifft's d=3 and SOFT's d=5 native-T circuits. | diff --git a/test/integration/test_determined_literature.py b/test/integration/test_determined_literature.py new file mode 100644 index 00000000..f86c02a5 --- /dev/null +++ b/test/integration/test_determined_literature.py @@ -0,0 +1,142 @@ +"""Determined measurements of published cultivation circuits with T gates. + +The circuits and their sources are in ``test/data/determined``. +""" + +from itertools import combinations +from pathlib import Path + +import numpy as np +import pytest +import stim + +from tsim.circuit import Circuit +from tsim.determined import ( + _Declared, + count_determined_measurements, + missing_detectors, + nondeterministic_detectors, +) +from tsim.utils.gf2_span import unpack + +DATA = Path(__file__).parent.parent / "data" / "determined" + + +def _circuit(name: str) -> Circuit: + return Circuit((DATA / f"{name}.stim").read_text()) + + +def _detectors(*indices: int) -> list[stim.DemTarget]: + return [stim.target_relative_detector_id(i) for i in indices] + + +def _healed(circuit: Circuit) -> list[set[int]]: + """Return each missing detector as the random detectors whose XOR it is.""" + num_m = circuit.num_measurements + declared = unpack(_Declared(circuit.stim_circuit).words, num_m).astype(np.int64) + random = [target.val for target in nondeterministic_detectors(circuit)] + result = [] + for instruction in missing_detectors(circuit): + assert isinstance(instruction, stim.CircuitInstruction) + parity = np.zeros(num_m, dtype=np.int64) + for target in instruction.targets_copy(): + parity[num_m + target.value] ^= 1 + found = [ + set(subset) + for size in (2, 3) + for subset in combinations(random, size) + if np.array_equal(declared[list(subset)].sum(axis=0) % 2, parity) + ] + result.append(found[0] if found else set()) + return result + + +@pytest.mark.parametrize( + "name, num_detectors", + [ + ("chan_d5a19_T", 107), + ("chan_d5a19f13_T", 122), + ("clifft_d5_T", 107), + ("wan_clifft_d3_T", 20), + ("wan_soft_d5_T", 107), + ], +) +@pytest.mark.parametrize("shots", [None, 2000]) +def test_published_t_circuits_have_every_detector_determined( + name, num_detectors, shots +): + # NOTE: Chan et al. (arXiv:2609.17706) and Clifft (arXiv:2604.27058) build + # these from S proxies with feedforward and detector healing; Wan and + # Zapirain (arXiv:2609.18922) use them as given. Each has one observable. + circuit = _circuit(name) + assert circuit.num_detectors == num_detectors + assert count_determined_measurements(circuit, shots=shots, seed=0) == ( + num_detectors + 1 + ) + assert nondeterministic_detectors(circuit, shots=shots, seed=0) == [] + assert len(missing_detectors(circuit, shots=shots, seed=0)) == 0 + + +def test_chan_uncorrected_d5_circuits_have_random_detectors(): + # NOTE: Chan et al. sim/d5-correction.md: "Bell growth leaves seven + # first-round check results that control a Pauli frame", so swapping S for + # T needs feedforward first. + circuit = _circuit("chan_d5a19_uncorrected_T") + assert count_determined_measurements(circuit) == 106 + assert nondeterministic_detectors(circuit) == _detectors(69, 91, 97, 102) + assert _healed(circuit) == [{91, 97}, {91, 102}] + flagged = _circuit("chan_d5a19f13_uncorrected_T") + assert count_determined_measurements(flagged) == 121 + assert nondeterministic_detectors(flagged) == _detectors(71, 106, 112, 117) + assert _healed(flagged) == [{106, 112}, {106, 117}] + + +def test_each_clifft_conversion_rule_heals_detectors(): + # NOTE: Clifft's convert_s_to_t.py: rule 1 swaps S for T, rule 2 flips six + # T gates (Gidney et al.'s erratum), rules 3 and 4 add feedforward and heal + # the detectors. + proxy = _circuit("clifft_d5_sproxy") + assert count_determined_measurements(proxy) == ( + proxy.stim_circuit.count_determined_measurements() + ) + assert count_determined_measurements(proxy) == 108 + swapped = _circuit("clifft_d5_T_rule1") + assert count_determined_measurements(swapped) == 105 + assert nondeterministic_detectors(swapped) == _detectors(69, 93, 95, 99, 101, 103) + flipped = _circuit("clifft_d5_T_rule12") + assert count_determined_measurements(flipped) == 106 + assert nondeterministic_detectors(flipped) == _detectors(69, 99, 101, 103) + assert _healed(flipped) == [{99, 101}, {99, 103}] + assert nondeterministic_detectors(_circuit("clifft_d5_T")) == [] + + +def _feedforward_sources(circuit: stim.Circuit) -> list[int]: + measured, sources = 0, set() + for instruction in circuit.flattened(): + assert isinstance(instruction, stim.CircuitInstruction) + if instruction.name in ("CX", "CZ"): + for target in instruction.targets_copy(): + if target.is_measurement_record_target: + sources.add(measured + target.value) + measured += instruction.num_measurements + return sorted(sources) + + +def test_three_of_clifft_feedforward_sources_are_determined(): + # NOTE: convert_s_to_t.py rule 3 says that seven growth-check measurements + # "become random with T gates (they were deterministic with S)", but rule 4 + # that the (4,1), (4,5), (6,2) ones are "deterministically 0". Alone, those + # three are determined and the other four random, with S and with T. + circuit = _circuit("clifft_d5_T") + sources = _feedforward_sources(circuit.stim_circuit) + assert len(sources) == 7 + num_m = circuit.num_measurements + for name in ("clifft_d5_sproxy", "clifft_d5_T_rule12", "clifft_d5_T"): + alone = Circuit( + str(_circuit(name).stim_circuit.without_noise()) + + "\n" + + "\n".join(f"DETECTOR rec[{m - num_m}]" for m in sources) + ) + first = alone.num_detectors - len(sources) + random = [t.val - first for t in nondeterministic_detectors(alone)] + assert [sources[i] for i in range(7) if i not in random] == [21, 23, 25] diff --git a/test/unit/statevector/test_branches.py b/test/unit/statevector/test_branches.py index 5fa1d15b..9e8685ae 100644 --- a/test/unit/statevector/test_branches.py +++ b/test/unit/statevector/test_branches.py @@ -122,3 +122,34 @@ def test_a_random_noiseless_output_has_no_reference(): ((compiled, _),) = _components(text, sample_detectors=True) with pytest.raises(ValueError, match="detector 0 is random without noise"): assert Branches(compiled, num_detectors=1).reference is not None + + +@pytest.mark.parametrize("name", sorted(CIRCUITS)) +def test_the_support_with_its_coins_is_every_possible_outcome(name): + for compiled, ops in _components(CIRCUITS[name], sample_detectors=False): + branches = Branches(compiled, num_detectors=len(compiled.output_indices)) + f = np.array(f_patterns(ops.num_f, limit=4), dtype=np.uint8) + f = f.reshape(len(f), ops.num_f) + row, values = branches.support(f) + assert np.all(np.diff(row) >= 0) + coins = branches.coin_rows + flips = np.array( + [ + np.bitwise_xor.reduce(coins[list(s)], axis=0, initial=0) + for s in _subsets(len(coins)) + ], + dtype=np.uint8, + ).reshape(-1, coins.shape[1]) + expected = [set() for _ in f] + for r, weight, out in branches._leaves(f): + for i, w, o in zip(r.tolist(), weight.tolist(), out.tolist(), strict=True): + if w > 1e-12: + expected[i].add(tuple(o)) + got = [set() for _ in f] + for i, v in zip(row.tolist(), values, strict=True): + got[i] |= {tuple(int(b) for b in v ^ flip) for flip in flips} + assert got == expected + + +def _subsets(n: int) -> list[list[int]]: + return [[i for i in range(n) if mask >> i & 1] for mask in range(1 << n)] diff --git a/test/unit/test_determined.py b/test/unit/test_determined.py new file mode 100644 index 00000000..f33e389c --- /dev/null +++ b/test/unit/test_determined.py @@ -0,0 +1,291 @@ +"""Tests for ``tsim.determined``: determined measurement parities.""" + +import numpy as np +import pytest +import stim + +from tsim.circuit import Circuit +from tsim.determined import ( + count_determined_measurements, + missing_detectors, + nondeterministic_detectors, +) + +STIM_EXAMPLES = [ + "R 0\nM 0", + "R 0\nH 0\nM 0", + "M 0", + "M 0\nM 0 1\nM 0 1 2\nM 0 1 2 3", + "R 0 1\nMZZ 0 1\nMYY 0 1\nMXX 0 1", + """ + MZZ 0 1 + MYY 0 1 + MXX 0 1 + DEPOLARIZE1(0.1) 0 1 + MZZ 0 1 + MYY 0 1 + MXX 0 1 + DETECTOR rec[-1] rec[-4] + DETECTOR rec[-2] rec[-5] + DETECTOR rec[-3] rec[-6] + """, + "RX 0\nMPP X0*Z1 Y0\nMRY 0\nMY 0", +] + +GENERATED = [ + ("surface_code:rotated_memory_x", 3), + ("surface_code:unrotated_memory_z", 3), + ("repetition_code:memory", 5), + ("color_code:memory_xyz", 5), +] + + +def _generated(task: str, distance: int) -> str: + circuit = stim.Circuit.generated( + task, distance=distance, rounds=3, after_clifford_depolarization=0.01 + ) + return str(circuit) + + +def _clifford_cases() -> list[str]: + return STIM_EXAMPLES + [_generated(task, d) for task, d in GENERATED] + + +@pytest.mark.parametrize("text", _clifford_cases()) +@pytest.mark.parametrize("unknown_input", [False, True]) +@pytest.mark.parametrize("shots", [None, 2000]) +def test_a_clifford_circuit_has_stims_counts(text, unknown_input, shots): + expected = stim.Circuit(text) + circuit = Circuit(text) + options = {"unknown_input": unknown_input, "shots": shots, "seed": 0} + assert count_determined_measurements( + circuit, **options + ) == expected.count_determined_measurements(unknown_input=unknown_input) + missing = missing_detectors(circuit, **options) + # NOTE: Stim's stub says that missing_detectors returns an int. + reference = stim.Circuit( + str(expected.missing_detectors(unknown_input=unknown_input)) + ) + assert len(missing) == len(reference) + assert nondeterministic_detectors(circuit, **options) == [] + # NOTE: with the missing detectors, Stim finds none missing. + rest = (expected + missing).missing_detectors(unknown_input=unknown_input) + assert str(rest) == "" + + +@pytest.mark.parametrize("text", _clifford_cases()) +def test_the_missing_detectors_are_determined_in_every_shot(text): + bare = Circuit(text).without_noise().without_annotations() + missing = missing_detectors(bare) + assert len(missing) == count_determined_measurements(bare) + samples = (bare + missing).compile_detector_sampler(seed=1).sample(500) + assert (samples == samples[0]).all() + + +def test_t_gates_randomize_a_measurement_and_t4_is_z(): + assert count_determined_measurements(Circuit("R 0\nH 0\nT 0\nH 0\nM 0")) == 0 + assert count_determined_measurements(Circuit("R 0\nH 0\nT 0 0 0 0\nH 0\nM 0")) == 1 + + +def test_a_nonlinear_function_of_earlier_measurements_is_not_counted(): + # NOTE: m2 = m0 AND m1 is predictable, but no parity of the three is. + circuit = Circuit("R 0 1 2\nH 0 1\nCCX 0 1 2\nM 0 1 2") + assert count_determined_measurements(circuit) == 0 + assert count_determined_measurements(circuit, shots=1000, seed=0) == 0 + + +@pytest.mark.parametrize( + "gate, value", [("Z", 0), ("S", 0), ("T", 1), ("T_DAG", 1), ("SQRT_X", 0)] +) +def test_ghz_parity_after_four_gates(gate, value): + # NOTE: Gidney, Shutty, Jones (arXiv:2409.17595) Fig. 22, "danger of using S + # as a proxy for T": XXXX of a GHZ state stays determined after T^4, but -1. + circuit = Circuit( + f"R 0 1 2 3\nH 0\nCX 0 1 0 2 0 3\n{gate} 0 1 2 3\nMPP X0*X1*X2*X3" + ) + assert str(missing_detectors(circuit)).split() == ["DETECTOR", "rec[-1]"] + samples = circuit.compile_sampler(seed=0).sample(100) + assert (samples == value).all() + + +def _fifteen_to_one(tail: str, *, flipped: int | None = None) -> Circuit: + # NOTE: Litinski, arXiv:1905.06903, Fig. 3: 15 pi/8 rotations Z_4 Z_b of the + # output qubit 4 and the checks b, which return to |+>. + lines = ["RX 0 1 2 3 4"] + for b in range(1, 16): + pairs = " ".join(f"{q} 4" for q in range(4) if b >> q & 1) + gate = "T_DAG" if b == flipped else "T" + lines += [f"CX {pairs}", f"{gate} 4", f"CX {pairs}"] + return Circuit("\n".join(lines) + "\n" + tail) + + +CHECKS = "MX 0 1 2 3\n" + "".join(f"DETECTOR rec[-{k}]\n" for k in range(1, 5)) + + +@pytest.mark.parametrize("shots", [None, 5000]) +def test_fifteen_to_one_has_four_determined_checks(shots): + circuit = _fifteen_to_one(CHECKS) + assert count_determined_measurements(circuit, shots=shots, seed=0) == 4 + assert nondeterministic_detectors(circuit, shots=shots, seed=0) == [] + assert len(missing_detectors(_fifteen_to_one("MX 0 1 2 3"), shots=shots)) == 4 + # NOTE: the output is T_DAG |+>: undoing it makes it determined. + output = CHECKS + "T 4\nMX 4\nOBSERVABLE_INCLUDE(0) rec[-1]" + assert count_determined_measurements(_fifteen_to_one(output)) == 5 + output = CHECKS + "MX 4\nOBSERVABLE_INCLUDE(0) rec[-1]" + random = nondeterministic_detectors(_fifteen_to_one(output)) + assert random == [stim.target_logical_observable_id(0)] + + +def test_a_wrong_t_gate_randomizes_checks(): + circuit = _fifteen_to_one(CHECKS, flipped=7) + assert count_determined_measurements(circuit) == 3 + assert nondeterministic_detectors(circuit) == [ + stim.target_relative_detector_id(k) for k in (1, 2, 3) + ] + + +def test_five_to_one_distillation_checks_are_random(): + # NOTE: Rodriguez et al., arXiv:2412.15165: noiseless acceptance is 1/6, so + # no syndrome is determined (``docs/tutorials/magic_state_distillation``). + theta = -np.arccos(np.sqrt(1 / 3)) / np.pi + circuit = Circuit(f""" + R 0 1 2 3 4 + R_X({theta}) 0 1 2 3 4 + T_DAG 0 1 2 3 4 + SQRT_X 0 1 4 + CZ 0 1 2 3 + SQRT_Y 0 3 + CZ 0 2 3 4 + SQRT_X_DAG 0 + CZ 0 4 1 3 + SQRT_X_DAG 0 1 2 3 4 + T 0 + R_X({-theta}) 0 + M 0 1 2 3 4 + """) + assert count_determined_measurements(circuit) == 0 + assert count_determined_measurements(circuit, shots=20_000, seed=0) == 0 + + +def test_missing_detectors_heal_random_detectors(): + # NOTE: after T, Z0 is random, and so is its copy Z1, but not Z0 Z1. + circuit = Circuit(""" + R 0 1 + H 0 + T 0 + H 0 + CX 0 1 + M 0 1 + DETECTOR rec[-1] + DETECTOR rec[-2] + """) + assert nondeterministic_detectors(circuit) == [ + stim.target_relative_detector_id(k) for k in (0, 1) + ] + assert count_determined_measurements(circuit) == 1 + assert str(missing_detectors(circuit)).split() == ["DETECTOR", "rec[-2]", "rec[-1]"] + + +def _random_circuit(rng: np.random.Generator, *, measured: bool = True) -> str: + kinds = ["H", "S", "T", "T_DAG", "CX"] + ["M", "MX", "R", "MPP"] * measured + lines = [] + for _ in range(int(rng.integers(6, 16))): + kind = rng.choice(kinds) + a, b = (int(q) for q in rng.choice(3, size=2, replace=False)) + if kind == "CX": + lines.append(f"CX {a} {b}") + elif kind == "MPP": + lines.append(f"MPP X{a}*Z{b}") + else: + lines.append(f"{kind} {a}") + return "\n".join([*lines, "M 0 1 2"]) + + +@pytest.mark.parametrize("seed", range(40)) +@pytest.mark.parametrize("measured", [True, False]) +def test_exact_counts_are_those_of_many_shots(seed, measured): + # NOTE: without measurements and resets before the end, unknown inputs + # reach the rotation signs. + rng = np.random.default_rng(seed) + circuit = Circuit(_random_circuit(rng, measured=measured)) + for unknown_input in (False, True): + exact = count_determined_measurements(circuit, unknown_input=unknown_input) + sampled = count_determined_measurements( + circuit, unknown_input=unknown_input, shots=4000, seed=seed + ) + assert exact == sampled + + +def _two_qubit_circuit(rng: np.random.Generator) -> str: + lines = [] + for _ in range(int(rng.integers(6, 14))): + kind = rng.choice(["H", "T", "T_DAG", "CX", "H"]) + a, b = (int(q) for q in rng.choice(2, size=2, replace=False)) + lines.append(f"CX {a} {b}" if kind == "CX" else f"{kind} {a}") + return "\n".join([*lines, "M 0 1", "CX 0 1", "M 1 0"]) + + +# NOTE: unknown inputs set the sign of a rotation in each of these. +SIGN_CIRCUITS = [ + "H 0\nT 0\nH 0\nT 0\nH 0\nM 0", + "H 0\nT 0\nH 0\nH 1\nT 0\nH 0\nT_DAG 1\nM 0 1\nCX 0 1\nM 1 0", + "H 0\nT 0\nH 1\nCX 1 0\nT_DAG 0\nH 0\nT_DAG 0\nH 0\nT 0\nM 0 1\nCX 0 1\nM 1 0", +] + + +@pytest.mark.parametrize("text", SIGN_CIRCUITS) +def test_unknown_inputs_that_set_rotation_signs_match_many_shots(text, monkeypatch): + circuit = Circuit(text) + exact = count_determined_measurements(circuit, unknown_input=True) + sampled = count_determined_measurements( + circuit, unknown_input=True, shots=4000, seed=0 + ) + assert exact == sampled + monkeypatch.setattr("tsim.determined.MAX_SIGN_BITS", 0) + with pytest.raises(ValueError, match="independent rotation signs"): + count_determined_measurements(circuit, unknown_input=True) + + +def test_unknown_inputs_reach_rotation_signs(): + # NOTE: an unknown input b of qubit 0 flips the sign of the T rotation that + # H T H applies; the second measurement repeats the first either way. + circuit = Circuit("CX 0 1\nH 0\nT 0\nH 0\nM 0 0 1") + assert count_determined_measurements(circuit) == 2 + assert count_determined_measurements(circuit, unknown_input=True) == 1 + + +def test_an_unlikely_outcome_after_another_is_possible(): + # NOTE: m2 = m0 AND m1 flips only when both of chance 1e-7 land 1; that is + # unlikely overall, but each given the one before is not. + angle = 2 * np.arcsin(np.sqrt(1e-7)) / np.pi + circuit = Circuit(f"R 0 1 2\nR_X({angle}) 0 1\nCCX 0 1 2\nM 0 1 2") + assert count_determined_measurements(circuit) == 0 + + +def test_too_many_branches_are_refused(monkeypatch): + monkeypatch.setattr("tsim.statevector.branches.MAX_BRANCHES", 1) + circuit = Circuit("R 0 1\nH 0 1\nT 0 1\nH 0 1\nM 0 1") + with pytest.raises(ValueError, match="measurement branches"): + count_determined_measurements(circuit) + + +def test_too_few_shots_warn(): + circuit = Circuit( + "R 0 1 2 3 4 5 6 7 8 9\nH 0 1 2 3 4 5 6 7 8 9\nM 0 1 2 3 4 5 6 7 8 9" + ) + with pytest.warns(UserWarning, match="use more shots"): + count_determined_measurements(circuit, shots=12, seed=0) + with pytest.raises(ValueError, match="at least 1"): + count_determined_measurements(circuit, shots=0) + + +def test_padded_measurements_are_determined(): + # NOTE: Stim 1.16's count_determined_measurements rejects MPAD. + circuit = Circuit("MPAD 1 0\nH 0\nM 0\nDETECTOR rec[-2]") + assert count_determined_measurements(circuit) == 2 + assert str(missing_detectors(circuit)).split() == ["DETECTOR", "rec[-3]"] + + +def test_a_circuit_without_measurements(): + assert count_determined_measurements(Circuit("H 0\nT 0")) == 0 + assert len(missing_detectors(Circuit("H 0\nT 0"))) == 0 diff --git a/test/unit/test_public_api.py b/test/unit/test_public_api.py index 372842ac..ed295645 100644 --- a/test/unit/test_public_api.py +++ b/test/unit/test_public_api.py @@ -1,5 +1,10 @@ import tsim import tsim.experimental +from tsim.determined import ( + count_determined_measurements, + missing_detectors, + nondeterministic_detectors, +) from tsim.noise.faults import Fault, LogicalError, shortest_errors from tsim.sampler import CompiledStateProbs from tsim.utils.encoder import ColorEncoder5, SteaneEncoder @@ -21,11 +26,19 @@ def test_experimental_api(): assert tsim.experimental.shortest_errors is shortest_errors assert tsim.experimental.LogicalError is LogicalError assert tsim.experimental.Fault is Fault + assert ( + tsim.experimental.count_determined_measurements is count_determined_measurements + ) + assert tsim.experimental.missing_detectors is missing_detectors + assert tsim.experimental.nondeterministic_detectors is nondeterministic_detectors assert sorted(tsim.experimental.__all__) == [ "ColorEncoder5", "CompiledStateProbs", "Fault", "LogicalError", "SteaneEncoder", + "count_determined_measurements", + "missing_detectors", + "nondeterministic_detectors", "shortest_errors", ] diff --git a/test/unit/utils/test_gf2_span.py b/test/unit/utils/test_gf2_span.py new file mode 100644 index 00000000..bf84afde --- /dev/null +++ b/test/unit/utils/test_gf2_span.py @@ -0,0 +1,60 @@ +"""Tests for ``tsim.utils.gf2_span``.""" + +import numpy as np +import pytest + +from tsim.utils.gf2_span import Span, pack, pack_bytes, unpack + + +def _rank(matrix: np.ndarray) -> int: + matrix = matrix.copy() % 2 + rank = 0 + for col in range(matrix.shape[1]): + rows = np.flatnonzero(matrix[rank:, col]) + rank + if not len(rows): + continue + matrix[[rank, rows[0]]] = matrix[[rows[0], rank]] + for r in np.flatnonzero(matrix[:, col]): + if r != rank: + matrix[r] ^= matrix[rank] + rank += 1 + if rank == len(matrix): + break + return rank + + +@pytest.mark.parametrize("width", [0, 1, 7, 64, 65, 130]) +def test_pack_round_trips(width): + bits = np.random.default_rng(width).integers(0, 2, (5, width), dtype=np.uint8) + assert np.array_equal(unpack(pack(bits), width), bits) + packed = np.packbits(bits, axis=1, bitorder="little") + assert np.array_equal(pack_bytes(packed, width), pack(bits)) + + +@pytest.mark.parametrize("seed", range(6)) +def test_the_annihilator_is_the_orthogonal_complement(seed): + rng = np.random.default_rng(seed) + width = int(rng.integers(1, 150)) + vectors = rng.integers(0, 2, (int(rng.integers(0, width + 5)), width)) + vectors = (vectors * (rng.random(vectors.shape) < 0.3)).astype(np.uint8) + span = Span(width) + grew = span.insert_bits(vectors) + assert span.rank == grew.sum() == _rank(vectors) + annihilator = unpack(span.annihilator(), width) + assert len(annihilator) == width - span.rank + assert not ((vectors.astype(int) @ annihilator.T.astype(int)) % 2).any() + assert _rank(annihilator) == len(annihilator) + ends = [int(np.flatnonzero(row).max()) for row in annihilator] + assert ends == sorted(set(ends)) + + +def test_contains(): + span = Span(3) + vectors = pack(np.array([[0, 0, 0], [1, 1, 0], [0, 1, 1], [1, 0, 1]])) + assert span.contains(vectors).tolist() == [True, False, False, False] + span.insert(vectors[1]) + assert span.contains(vectors).tolist() == [True, True, False, False] + span.insert(vectors[2]) + assert span.contains(vectors).tolist() == [True, True, True, True] + assert span.rank == 2 + assert unpack(span.basis(), 3).tolist() == [[1, 1, 0], [0, 1, 1]] From e34c388f23956560b425011433bf62c41e4c74fb Mon Sep 17 00:00:00 2001 From: Rafael Haenel Date: Wed, 18 Nov 2026 14:54:58 -0700 Subject: [PATCH 2/6] test: track the cultivation circuits of the literature tests The repository ignores *.stim; the test data are an exception. Co-Authored-By: Claude Opus 5.5 --- .gitignore | 1 + test/data/determined/chan_d5a19_T.stim | 373 ++++++++++++++++ .../determined/chan_d5a19_uncorrected_T.stim | 371 +++++++++++++++ test/data/determined/chan_d5a19f13_T.stim | 421 ++++++++++++++++++ .../chan_d5a19f13_uncorrected_T.stim | 419 +++++++++++++++++ test/data/determined/clifft_d5_T.stim | 359 +++++++++++++++ test/data/determined/clifft_d5_T_rule1.stim | 353 +++++++++++++++ test/data/determined/clifft_d5_T_rule12.stim | 357 +++++++++++++++ test/data/determined/clifft_d5_sproxy.stim | 350 +++++++++++++++ test/data/determined/wan_clifft_d3_T.stim | 124 ++++++ test/data/determined/wan_soft_d5_T.stim | 211 +++++++++ 11 files changed, 3339 insertions(+) create mode 100644 test/data/determined/chan_d5a19_T.stim create mode 100644 test/data/determined/chan_d5a19_uncorrected_T.stim create mode 100644 test/data/determined/chan_d5a19f13_T.stim create mode 100644 test/data/determined/chan_d5a19f13_uncorrected_T.stim create mode 100644 test/data/determined/clifft_d5_T.stim create mode 100644 test/data/determined/clifft_d5_T_rule1.stim create mode 100644 test/data/determined/clifft_d5_T_rule12.stim create mode 100644 test/data/determined/clifft_d5_sproxy.stim create mode 100644 test/data/determined/wan_clifft_d3_T.stim create mode 100644 test/data/determined/wan_soft_d5_T.stim diff --git a/.gitignore b/.gitignore index 6a7a990c..5c9775de 100644 --- a/.gitignore +++ b/.gitignore @@ -225,3 +225,4 @@ cython_debug/ marimo/_static/ marimo/_lsp/ __marimo__/ +!test/data/**/*.stim diff --git a/test/data/determined/chan_d5a19_T.stim b/test/data/determined/chan_d5a19_T.stim new file mode 100644 index 00000000..54bd68e5 --- /dev/null +++ b/test/data/determined/chan_d5a19_T.stim @@ -0,0 +1,373 @@ +QUBIT_COORDS(0, 0) 0 +QUBIT_COORDS(0, 1) 1 +QUBIT_COORDS(1, 0) 2 +QUBIT_COORDS(1, 1) 3 +QUBIT_COORDS(1, 2) 4 +QUBIT_COORDS(1, 3) 5 +QUBIT_COORDS(2, 0) 6 +QUBIT_COORDS(2, 1) 7 +QUBIT_COORDS(2, 2) 8 +QUBIT_COORDS(2, 3) 9 +QUBIT_COORDS(2, 4) 10 +QUBIT_COORDS(3, 0) 11 +QUBIT_COORDS(3, 1) 12 +QUBIT_COORDS(3, 2) 13 +QUBIT_COORDS(3, 3) 14 +QUBIT_COORDS(3, 4) 15 +QUBIT_COORDS(3, 5) 16 +QUBIT_COORDS(4, 0) 17 +QUBIT_COORDS(4, 1) 18 +QUBIT_COORDS(4, 2) 19 +QUBIT_COORDS(4, 3) 20 +QUBIT_COORDS(4, 4) 21 +QUBIT_COORDS(4, 5) 22 +QUBIT_COORDS(4, 6) 23 +QUBIT_COORDS(5, 0) 24 +QUBIT_COORDS(5, 1) 25 +QUBIT_COORDS(5, 2) 26 +QUBIT_COORDS(5, 3) 27 +QUBIT_COORDS(5, 4) 28 +QUBIT_COORDS(5, 5) 29 +QUBIT_COORDS(5, 6) 30 +QUBIT_COORDS(6, 0) 31 +QUBIT_COORDS(6, 1) 32 +QUBIT_COORDS(6, 2) 33 +QUBIT_COORDS(6, 3) 34 +QUBIT_COORDS(6, 4) 35 +QUBIT_COORDS(7, 0) 36 +QUBIT_COORDS(7, 1) 37 +QUBIT_COORDS(7, 2) 38 +QUBIT_COORDS(7, 3) 39 +QUBIT_COORDS(8, 0) 40 +QUBIT_COORDS(8, 1) 41 +R 12 8 6 +RX 7 11 13 3 2 4 18 0 5 17 +TICK +CX 7 12 11 6 13 8 +TICK +CX 7 8 11 12 +TICK +CX 7 6 13 12 +TICK +CX 2 6 4 8 18 12 +TICK +CX 6 2 8 4 12 18 +TICK +CX 3 4 17 18 +TICK +CX 3 2 18 17 +TICK +CX 4 3 +TICK +CX 2 3 +TICK +T 3 +TICK +CX 2 3 +TICK +CX 4 3 +TICK +CX 0 2 5 4 +TICK +CX 2 0 4 5 +TICK +R 6 18 8 9 +RX 2 12 4 +TICK +CX 2 6 4 8 5 9 12 18 +TICK +CX 2 0 6 11 8 13 9 5 12 7 +TICK +CX 2 3 6 7 8 9 12 13 +TICK +CX 4 3 8 7 12 11 18 17 +TICK +CX 3 4 7 8 11 12 17 18 +TICK +CX 0 2 7 12 11 6 13 8 +TICK +CX 3 2 7 6 9 8 13 12 +TICK +CX 2 6 4 8 12 18 +TICK +M 6 18 8 5 +MX 2 12 4 +DETECTOR(2, 0, 0) rec[-7] +DETECTOR(4, 1, 0) rec[-6] +DETECTOR(2, 2, 0) rec[-5] +DETECTOR(1, 3, 0) rec[-4] +DETECTOR(1, 0, 0) rec[-3] +DETECTOR(3, 1, 0) rec[-2] +DETECTOR(1, 2, 0) rec[-1] +TICK +RX 18 12 6 2 8 1 +TICK +T 3 11 13 +T_DAG 0 7 9 17 +TICK +CX 1 0 2 3 6 7 8 9 12 11 18 17 +TICK +CX 3 1 7 8 12 18 +TICK +CX 7 3 12 13 +TICK +CX 7 12 +TICK +MX 7 +DETECTOR(1, 2, 1) rec[-1] rec[-2] rec[-3] +TICK +RX 7 +TICK +CX 7 12 +TICK +CX 7 3 12 13 +TICK +CX 3 1 7 8 12 18 +TICK +CX 1 0 2 3 6 7 8 9 12 11 18 17 +TICK +T 0 7 9 17 +T_DAG 3 11 13 +TICK +MX 18 12 6 2 8 1 +DETECTOR(4, 1, 2) rec[-6] +DETECTOR(3, 1, 2) rec[-5] +DETECTOR(2, 1, 2) rec[-4] rec[-7] +DETECTOR(1, 0, 2) rec[-3] +DETECTOR(2, 2, 2) rec[-2] +DETECTOR(0, 1, 2) rec[-1] +TICK +R 19 25 32 38 40 23 15 22 21 29 34 +RX 26 33 36 16 28 27 +TICK +CX 16 22 26 19 27 34 28 21 33 38 36 40 +TICK +CX 16 15 22 23 26 25 28 29 33 32 +TICK +CX 15 16 23 22 25 26 29 28 32 33 +TICK +M 26 33 28 22 16 +DETECTOR(5, 2, 3) rec[-5] +DETECTOR(6, 2, 3) rec[-4] +DETECTOR(5, 4, 3) rec[-3] +DETECTOR(4, 5, 3) rec[-2] +DETECTOR(3, 5, 3) rec[-1] +TICK +R 41 35 33 31 22 20 18 8 6 +RX 37 28 26 24 16 14 12 4 2 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +CX 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 +TICK +CX 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 +TICK +CX 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 +TICK +CX 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 +TICK +CX 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 +TICK +CX 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +M 41 35 33 31 22 20 18 8 6 +MX 37 28 26 24 16 14 12 4 2 +DETECTOR(8, 1, 4) rec[-18] +DETECTOR(6, 4, 4) rec[-17] +DETECTOR(6, 2, 4) rec[-16] +DETECTOR(4, 5, 4) rec[-14] +DETECTOR(4, 1, 4) rec[-12] +DETECTOR(2, 2, 4) rec[-11] +DETECTOR(2, 0, 4) rec[-10] +DETECTOR(7, 1, 4) rec[-9] +DETECTOR(5, 4, 4) rec[-8] +DETECTOR(5, 2, 4) rec[-7] +DETECTOR(3, 5, 4) rec[-5] +DETECTOR(2, 1, 4) rec[-3] rec[-30] +DETECTOR(1, 2, 4) rec[-2] rec[-30] +DETECTOR(1, 0, 4) rec[-1] rec[-30] +TICK +CZ rec[-6] 36 rec[-6] 40 rec[-4] 15 rec[-4] 23 +CX rec[-15] 36 rec[-15] 40 rec[-15] 38 rec[-15] 40 rec[-16] 36 rec[-16] 40 rec[-12] 15 rec[-12] 23 rec[-13] 0 rec[-13] 11 rec[-13] 23 rec[-14] 15 rec[-14] 23 +R 41 35 33 31 22 20 18 8 6 +RX 37 28 26 24 16 14 12 4 2 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +CX 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 +TICK +CX 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 +TICK +CX 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 +TICK +CX 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 +TICK +CX 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 +TICK +CX 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +M 41 35 33 31 22 20 18 8 6 +MX 37 28 26 24 16 14 12 4 2 +DETECTOR(8, 1, 5) rec[-18] +DETECTOR(6, 2, 5) rec[-17] +DETECTOR(6, 0, 5) rec[-16] rec[-35] +DETECTOR(6, 0.5, 5) rec[-15] +DETECTOR(4, 3, 5) rec[-14] +DETECTOR(4, 1, 5) rec[-13] +DETECTOR(4, 2, 5) rec[-12] +DETECTOR(2, 0, 5) rec[-11] rec[-28] +DETECTOR(2, 2, 5) rec[-10] rec[-28] rec[-29] +DETECTOR(7, 1, 5) rec[-9] rec[-27] +DETECTOR(5, 4, 5) rec[-8] rec[-26] +DETECTOR(5, 2, 5) rec[-7] rec[-25] +DETECTOR(5, 0, 5) rec[-6] +DETECTOR(3, 5, 5) rec[-5] rec[-23] +DETECTOR(3, 3, 5) rec[-4] +DETECTOR(3, 1, 5) rec[-3] rec[-21] +DETECTOR(1, 2, 5) rec[-2] rec[-20] +DETECTOR(1, 0, 5) rec[-1] rec[-19] +TICK +R 41 35 33 31 22 20 18 8 6 +RX 37 28 26 24 16 14 12 4 2 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +CX 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 +TICK +CX 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 +TICK +CX 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 +TICK +CX 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 +TICK +CX 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 +TICK +CX 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +M 41 35 33 31 22 20 18 8 6 +MX 37 28 26 24 16 14 12 4 2 +DETECTOR(8, 1, 6) rec[-18] +DETECTOR(6, 2, 6) rec[-17] rec[-34] +DETECTOR(6, 0, 6) rec[-16] rec[-33] rec[-35] +DETECTOR(6, 0.5, 6) rec[-15] rec[-33] rec[-34] +DETECTOR(4, 3, 6) rec[-14] rec[-31] +DETECTOR(4, 1, 6) rec[-13] rec[-30] rec[-32] +DETECTOR(4, 2, 6) rec[-12] rec[-31] +DETECTOR(2, 0, 6) rec[-11] rec[-28] +DETECTOR(2, 2, 6) rec[-10] rec[-28] rec[-29] +DETECTOR(7, 1, 6) rec[-9] rec[-27] +DETECTOR(5, 4, 6) rec[-8] rec[-26] +DETECTOR(5, 2, 6) rec[-7] rec[-25] +DETECTOR(5, 0, 6) rec[-6] rec[-24] +DETECTOR(3, 5, 6) rec[-5] rec[-23] +DETECTOR(3, 3, 6) rec[-4] rec[-22] +DETECTOR(3, 1, 6) rec[-3] rec[-21] +DETECTOR(1, 2, 6) rec[-2] rec[-20] +DETECTOR(1, 0, 6) rec[-1] rec[-19] +TICK +RX 24 31 2 6 8 10 20 22 39 1 12 18 37 33 14 26 28 30 41 +TICK +T 3 11 13 25 15 27 29 36 38 +T_DAG 0 7 9 17 19 21 23 32 34 40 +TICK +CX 1 0 2 3 6 7 8 13 10 15 12 11 14 9 18 17 20 27 22 29 24 25 26 19 28 21 30 23 31 32 33 34 37 36 39 38 41 40 +TICK +CX 3 1 14 15 29 30 33 38 37 41 +TICK +CX 7 3 13 14 26 33 28 29 32 37 +TICK +CX 12 13 25 32 27 28 +TICK +CX 12 7 26 27 +TICK +CX 18 12 25 26 +TICK +CX 25 18 +TICK +MX 25 +DETECTOR(0, 1, 7) rec[-1] rec[-12] rec[-13] rec[-14] rec[-15] rec[-17] rec[-18] rec[-19] rec[-30] rec[-31] rec[-32] rec[-33] rec[-35] rec[-36] rec[-37] rec[-48] rec[-49] rec[-51] rec[-53] rec[-54] rec[-55] rec[-61] rec[-62] rec[-65] rec[-66] +TICK +RX 25 +TICK +CX 25 18 +TICK +CX 18 12 25 26 +TICK +CX 12 7 26 27 +TICK +CX 12 13 25 32 27 28 +TICK +CX 7 3 13 14 26 33 28 29 32 37 +TICK +CX 3 1 14 15 29 30 33 38 37 41 +TICK +CX 1 0 2 3 6 7 8 13 10 15 12 11 14 9 18 17 20 27 22 29 24 25 26 19 28 21 30 23 31 32 33 34 37 36 39 38 41 40 +TICK +T 0 7 9 17 19 21 23 32 34 40 +T_DAG 3 11 13 25 15 27 29 36 38 +TICK +MX 20 22 8 10 2 6 24 31 39 1 12 18 37 33 14 26 28 30 41 +DETECTOR(4, 3, 8) rec[-19] +DETECTOR(4, 5, 8) rec[-18] +DETECTOR(2, 2, 8) rec[-17] +DETECTOR(2, 4, 8) rec[-16] +DETECTOR(1, 0, 8) rec[-15] +DETECTOR(2, 0, 8) rec[-14] +DETECTOR(5, 1, 8) rec[-13] rec[-20] +DETECTOR(6, 0, 8) rec[-12] +DETECTOR(7, 3, 8) rec[-11] +DETECTOR(0, 1, 8) rec[-10] +DETECTOR(3, 1, 8) rec[-9] +DETECTOR(4, 1, 8) rec[-8] +DETECTOR(7, 1, 8) rec[-7] +DETECTOR(6, 2, 8) rec[-6] +DETECTOR(3, 3, 8) rec[-5] +DETECTOR(5, 2, 8) rec[-4] +DETECTOR(5, 4, 8) rec[-3] +DETECTOR(5, 6, 8) rec[-2] +DETECTOR(8, 1, 8) rec[-1] +TICK +T 3 11 13 25 15 27 29 36 38 +T_DAG 0 7 9 17 19 21 23 32 34 40 +TICK +MPP X0*X3*X7*X9*X11*X13*X15*X17*X19*X21*X23*X25*X27*X29*X32*X34*X36*X38*X40 +OBSERVABLE_INCLUDE(0) rec[-1] rec[-2] rec[-3] rec[-4] rec[-5] rec[-6] rec[-7] rec[-8] rec[-9] rec[-10] rec[-11] +TICK +T 0 7 9 17 19 21 23 32 34 40 +T_DAG 3 11 13 25 15 27 29 36 38 +TICK +MPP X0*X3*X7*X11 X9*X13*X15*X19*X21*X27 X17*X25*X32*X36 +DETECTOR(1, 0, 9) rec[-3] rec[-25] +DETECTOR(3, 3, 9) rec[-2] rec[-28] +DETECTOR(5, 0, 9) rec[-1] rec[-24] rec[-30] +TICK +MPP Z0*Z3*Z7*Z11 Z9*Z13*Z15*Z19*Z21*Z27 Z17*Z25*Z32*Z36 +DETECTOR(2, 0, 10) rec[-3] rec[-37] rec[-38] +DETECTOR(4, 1, 10) rec[-2] rec[-39] rec[-41] +DETECTOR(6, 0, 10) rec[-1] rec[-42] rec[-43] +TICK +MPP X3*X7*X9*X13 X15*X21*X23*X29 X19*X25*X27*X32*X34*X38 +DETECTOR(1, 2, 11) rec[-3] rec[-32] +DETECTOR(3, 5, 11) rec[-2] rec[-35] +DETECTOR(5, 2, 11) rec[-1] rec[-30] rec[-37] +TICK +MPP Z3*Z7*Z9*Z13 Z15*Z21*Z23*Z29 Z19*Z25*Z27*Z32*Z34*Z38 +DETECTOR(2, 0, 12) rec[-3] rec[-43] +DETECTOR(4, 3, 12) rec[-2] rec[-46] +DETECTOR(6, 0, 12) rec[-1] rec[-48] rec[-50] +TICK +MPP X7*X11*X13*X17*X19*X25 X21*X27*X29*X34 X32*X36*X38*X40 +DETECTOR(3, 1, 13) rec[-3] rec[-36] rec[-39] +DETECTOR(5, 4, 13) rec[-2] rec[-44] +DETECTOR(7, 1, 13) rec[-1] rec[-45] +TICK +MPP Z7*Z11*Z13*Z17*Z19*Z25 Z21*Z27*Z29*Z34 Z32*Z36*Z38*Z40 +DETECTOR(4, 3, 14) rec[-3] rec[-52] +DETECTOR(6, 2, 14) rec[-2] rec[-55] +DETECTOR(6, 1, 14) rec[-1] diff --git a/test/data/determined/chan_d5a19_uncorrected_T.stim b/test/data/determined/chan_d5a19_uncorrected_T.stim new file mode 100644 index 00000000..8791f574 --- /dev/null +++ b/test/data/determined/chan_d5a19_uncorrected_T.stim @@ -0,0 +1,371 @@ +QUBIT_COORDS(0, 0) 0 +QUBIT_COORDS(0, 1) 1 +QUBIT_COORDS(1, 0) 2 +QUBIT_COORDS(1, 1) 3 +QUBIT_COORDS(1, 2) 4 +QUBIT_COORDS(1, 3) 5 +QUBIT_COORDS(2, 0) 6 +QUBIT_COORDS(2, 1) 7 +QUBIT_COORDS(2, 2) 8 +QUBIT_COORDS(2, 3) 9 +QUBIT_COORDS(2, 4) 10 +QUBIT_COORDS(3, 0) 11 +QUBIT_COORDS(3, 1) 12 +QUBIT_COORDS(3, 2) 13 +QUBIT_COORDS(3, 3) 14 +QUBIT_COORDS(3, 4) 15 +QUBIT_COORDS(3, 5) 16 +QUBIT_COORDS(4, 0) 17 +QUBIT_COORDS(4, 1) 18 +QUBIT_COORDS(4, 2) 19 +QUBIT_COORDS(4, 3) 20 +QUBIT_COORDS(4, 4) 21 +QUBIT_COORDS(4, 5) 22 +QUBIT_COORDS(4, 6) 23 +QUBIT_COORDS(5, 0) 24 +QUBIT_COORDS(5, 1) 25 +QUBIT_COORDS(5, 2) 26 +QUBIT_COORDS(5, 3) 27 +QUBIT_COORDS(5, 4) 28 +QUBIT_COORDS(5, 5) 29 +QUBIT_COORDS(5, 6) 30 +QUBIT_COORDS(6, 0) 31 +QUBIT_COORDS(6, 1) 32 +QUBIT_COORDS(6, 2) 33 +QUBIT_COORDS(6, 3) 34 +QUBIT_COORDS(6, 4) 35 +QUBIT_COORDS(7, 0) 36 +QUBIT_COORDS(7, 1) 37 +QUBIT_COORDS(7, 2) 38 +QUBIT_COORDS(7, 3) 39 +QUBIT_COORDS(8, 0) 40 +QUBIT_COORDS(8, 1) 41 +R 12 8 6 +RX 7 11 13 3 2 4 18 0 5 17 +TICK +CX 7 12 11 6 13 8 +TICK +CX 7 8 11 12 +TICK +CX 7 6 13 12 +TICK +CX 2 6 4 8 18 12 +TICK +CX 6 2 8 4 12 18 +TICK +CX 3 4 17 18 +TICK +CX 3 2 18 17 +TICK +CX 4 3 +TICK +CX 2 3 +TICK +T 3 +TICK +CX 2 3 +TICK +CX 4 3 +TICK +CX 0 2 5 4 +TICK +CX 2 0 4 5 +TICK +R 6 18 8 9 +RX 2 12 4 +TICK +CX 2 6 4 8 5 9 12 18 +TICK +CX 2 0 6 11 8 13 9 5 12 7 +TICK +CX 2 3 6 7 8 9 12 13 +TICK +CX 4 3 8 7 12 11 18 17 +TICK +CX 3 4 7 8 11 12 17 18 +TICK +CX 0 2 7 12 11 6 13 8 +TICK +CX 3 2 7 6 9 8 13 12 +TICK +CX 2 6 4 8 12 18 +TICK +M 6 18 8 5 +MX 2 12 4 +DETECTOR(2, 0, 0) rec[-7] +DETECTOR(4, 1, 0) rec[-6] +DETECTOR(2, 2, 0) rec[-5] +DETECTOR(1, 3, 0) rec[-4] +DETECTOR(1, 0, 0) rec[-3] +DETECTOR(3, 1, 0) rec[-2] +DETECTOR(1, 2, 0) rec[-1] +TICK +RX 18 12 6 2 8 1 +TICK +T 3 11 13 +T_DAG 0 7 9 17 +TICK +CX 1 0 2 3 6 7 8 9 12 11 18 17 +TICK +CX 3 1 7 8 12 18 +TICK +CX 7 3 12 13 +TICK +CX 7 12 +TICK +MX 7 +DETECTOR(1, 2, 1) rec[-1] rec[-2] rec[-3] +TICK +RX 7 +TICK +CX 7 12 +TICK +CX 7 3 12 13 +TICK +CX 3 1 7 8 12 18 +TICK +CX 1 0 2 3 6 7 8 9 12 11 18 17 +TICK +T 0 7 9 17 +T_DAG 3 11 13 +TICK +MX 18 12 6 2 8 1 +DETECTOR(4, 1, 2) rec[-6] +DETECTOR(3, 1, 2) rec[-5] +DETECTOR(2, 1, 2) rec[-4] rec[-7] +DETECTOR(1, 0, 2) rec[-3] +DETECTOR(2, 2, 2) rec[-2] +DETECTOR(0, 1, 2) rec[-1] +TICK +R 19 25 32 38 40 23 15 22 21 29 34 +RX 26 33 36 16 28 27 +TICK +CX 16 22 26 19 27 34 28 21 33 38 36 40 +TICK +CX 16 15 22 23 26 25 28 29 33 32 +TICK +CX 15 16 23 22 25 26 29 28 32 33 +TICK +M 26 33 28 22 16 +DETECTOR(5, 2, 3) rec[-5] +DETECTOR(6, 2, 3) rec[-4] +DETECTOR(5, 4, 3) rec[-3] +DETECTOR(4, 5, 3) rec[-2] +DETECTOR(3, 5, 3) rec[-1] +TICK +R 41 35 33 31 22 20 18 8 6 +RX 37 28 26 24 16 14 12 4 2 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +CX 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 +TICK +CX 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 +TICK +CX 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 +TICK +CX 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 +TICK +CX 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 +TICK +CX 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +M 41 35 33 31 22 20 18 8 6 +MX 37 28 26 24 16 14 12 4 2 +DETECTOR(8, 1, 4) rec[-18] +DETECTOR(6, 4, 4) rec[-17] +DETECTOR(6, 2, 4) rec[-16] +DETECTOR(4, 5, 4) rec[-14] +DETECTOR(4, 1, 4) rec[-12] +DETECTOR(2, 2, 4) rec[-11] +DETECTOR(2, 0, 4) rec[-10] +DETECTOR(7, 1, 4) rec[-9] +DETECTOR(5, 4, 4) rec[-8] +DETECTOR(5, 2, 4) rec[-7] +DETECTOR(3, 5, 4) rec[-5] +DETECTOR(2, 1, 4) rec[-3] rec[-30] +DETECTOR(1, 2, 4) rec[-2] rec[-30] +DETECTOR(1, 0, 4) rec[-1] rec[-30] +TICK +R 41 35 33 31 22 20 18 8 6 +RX 37 28 26 24 16 14 12 4 2 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +CX 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 +TICK +CX 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 +TICK +CX 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 +TICK +CX 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 +TICK +CX 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 +TICK +CX 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +M 41 35 33 31 22 20 18 8 6 +MX 37 28 26 24 16 14 12 4 2 +DETECTOR(8, 1, 5) rec[-18] +DETECTOR(6, 2, 5) rec[-17] rec[-34] +DETECTOR(6, 0, 5) rec[-16] rec[-33] rec[-35] +DETECTOR(6, 0.5, 5) rec[-15] rec[-33] rec[-34] +DETECTOR(4, 3, 5) rec[-14] rec[-31] +DETECTOR(4, 1, 5) rec[-13] rec[-30] rec[-32] +DETECTOR(4, 2, 5) rec[-12] rec[-31] +DETECTOR(2, 0, 5) rec[-11] rec[-28] +DETECTOR(2, 2, 5) rec[-10] rec[-28] rec[-29] +DETECTOR(7, 1, 5) rec[-9] rec[-27] +DETECTOR(5, 4, 5) rec[-8] rec[-26] +DETECTOR(5, 2, 5) rec[-7] rec[-25] +DETECTOR(5, 0, 5) rec[-6] rec[-24] +DETECTOR(3, 5, 5) rec[-5] rec[-23] +DETECTOR(3, 3, 5) rec[-4] rec[-22] +DETECTOR(3, 1, 5) rec[-3] rec[-21] +DETECTOR(1, 2, 5) rec[-2] rec[-20] +DETECTOR(1, 0, 5) rec[-1] rec[-19] +TICK +R 41 35 33 31 22 20 18 8 6 +RX 37 28 26 24 16 14 12 4 2 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +CX 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 +TICK +CX 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 +TICK +CX 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 +TICK +CX 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 +TICK +CX 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 +TICK +CX 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +M 41 35 33 31 22 20 18 8 6 +MX 37 28 26 24 16 14 12 4 2 +DETECTOR(8, 1, 6) rec[-18] +DETECTOR(6, 2, 6) rec[-17] rec[-34] +DETECTOR(6, 0, 6) rec[-16] rec[-33] rec[-35] +DETECTOR(6, 0.5, 6) rec[-15] rec[-33] rec[-34] +DETECTOR(4, 3, 6) rec[-14] rec[-31] +DETECTOR(4, 1, 6) rec[-13] rec[-30] rec[-32] +DETECTOR(4, 2, 6) rec[-12] rec[-31] +DETECTOR(2, 0, 6) rec[-11] rec[-28] +DETECTOR(2, 2, 6) rec[-10] rec[-28] rec[-29] +DETECTOR(7, 1, 6) rec[-9] rec[-27] +DETECTOR(5, 4, 6) rec[-8] rec[-26] +DETECTOR(5, 2, 6) rec[-7] rec[-25] +DETECTOR(5, 0, 6) rec[-6] rec[-24] +DETECTOR(3, 5, 6) rec[-5] rec[-23] +DETECTOR(3, 3, 6) rec[-4] rec[-22] +DETECTOR(3, 1, 6) rec[-3] rec[-21] +DETECTOR(1, 2, 6) rec[-2] rec[-20] +DETECTOR(1, 0, 6) rec[-1] rec[-19] +TICK +RX 24 31 2 6 8 10 20 22 39 1 12 18 37 33 14 26 28 30 41 +TICK +T 3 11 13 25 15 27 29 36 38 +T_DAG 0 7 9 17 19 21 23 32 34 40 +TICK +CX 1 0 2 3 6 7 8 13 10 15 12 11 14 9 18 17 20 27 22 29 24 25 26 19 28 21 30 23 31 32 33 34 37 36 39 38 41 40 +TICK +CX 3 1 14 15 29 30 33 38 37 41 +TICK +CX 7 3 13 14 26 33 28 29 32 37 +TICK +CX 12 13 25 32 27 28 +TICK +CX 12 7 26 27 +TICK +CX 18 12 25 26 +TICK +CX 25 18 +TICK +MX 25 +DETECTOR(0, 1, 7) rec[-1] rec[-12] rec[-13] rec[-14] rec[-15] rec[-17] rec[-18] rec[-19] rec[-30] rec[-31] rec[-32] rec[-33] rec[-35] rec[-36] rec[-37] rec[-48] rec[-49] rec[-50] rec[-51] rec[-53] rec[-54] rec[-55] rec[-61] rec[-62] rec[-65] rec[-66] +TICK +RX 25 +TICK +CX 25 18 +TICK +CX 18 12 25 26 +TICK +CX 12 7 26 27 +TICK +CX 12 13 25 32 27 28 +TICK +CX 7 3 13 14 26 33 28 29 32 37 +TICK +CX 3 1 14 15 29 30 33 38 37 41 +TICK +CX 1 0 2 3 6 7 8 13 10 15 12 11 14 9 18 17 20 27 22 29 24 25 26 19 28 21 30 23 31 32 33 34 37 36 39 38 41 40 +TICK +T 0 7 9 17 19 21 23 32 34 40 +T_DAG 3 11 13 25 15 27 29 36 38 +TICK +MX 20 22 8 10 2 6 24 31 39 1 12 18 37 33 14 26 28 30 41 +DETECTOR(4, 3, 8) rec[-19] +DETECTOR(4, 5, 8) rec[-18] +DETECTOR(2, 2, 8) rec[-17] +DETECTOR(2, 4, 8) rec[-16] +DETECTOR(1, 0, 8) rec[-15] +DETECTOR(2, 0, 8) rec[-14] +DETECTOR(5, 1, 8) rec[-13] rec[-20] +DETECTOR(6, 0, 8) rec[-12] +DETECTOR(7, 3, 8) rec[-11] +DETECTOR(0, 1, 8) rec[-10] +DETECTOR(3, 1, 8) rec[-9] +DETECTOR(4, 1, 8) rec[-8] +DETECTOR(7, 1, 8) rec[-7] +DETECTOR(6, 2, 8) rec[-6] +DETECTOR(3, 3, 8) rec[-5] +DETECTOR(5, 2, 8) rec[-4] +DETECTOR(5, 4, 8) rec[-3] +DETECTOR(5, 6, 8) rec[-2] +DETECTOR(8, 1, 8) rec[-1] +TICK +T 3 11 13 25 15 27 29 36 38 +T_DAG 0 7 9 17 19 21 23 32 34 40 +TICK +MPP X0*X3*X7*X9*X11*X13*X15*X17*X19*X21*X23*X25*X27*X29*X32*X34*X36*X38*X40 +OBSERVABLE_INCLUDE(0) rec[-1] rec[-2] rec[-3] rec[-4] rec[-5] rec[-6] rec[-7] rec[-8] rec[-9] rec[-10] rec[-11] +TICK +T 0 7 9 17 19 21 23 32 34 40 +T_DAG 3 11 13 25 15 27 29 36 38 +TICK +MPP X0*X3*X7*X11 X9*X13*X15*X19*X21*X27 X17*X25*X32*X36 +DETECTOR(1, 0, 9) rec[-3] rec[-25] +DETECTOR(3, 3, 9) rec[-2] rec[-28] +DETECTOR(5, 0, 9) rec[-1] rec[-24] rec[-30] +TICK +MPP Z0*Z3*Z7*Z11 Z9*Z13*Z15*Z19*Z21*Z27 Z17*Z25*Z32*Z36 +DETECTOR(2, 0, 10) rec[-3] rec[-37] rec[-38] +DETECTOR(4, 1, 10) rec[-2] rec[-39] rec[-41] +DETECTOR(6, 0, 10) rec[-1] rec[-42] rec[-43] +TICK +MPP X3*X7*X9*X13 X15*X21*X23*X29 X19*X25*X27*X32*X34*X38 +DETECTOR(1, 2, 11) rec[-3] rec[-32] +DETECTOR(3, 5, 11) rec[-2] rec[-35] +DETECTOR(5, 2, 11) rec[-1] rec[-30] rec[-37] +TICK +MPP Z3*Z7*Z9*Z13 Z15*Z21*Z23*Z29 Z19*Z25*Z27*Z32*Z34*Z38 +DETECTOR(2, 0, 12) rec[-3] rec[-43] +DETECTOR(4, 3, 12) rec[-2] rec[-46] +DETECTOR(6, 0, 12) rec[-1] rec[-48] rec[-50] +TICK +MPP X7*X11*X13*X17*X19*X25 X21*X27*X29*X34 X32*X36*X38*X40 +DETECTOR(3, 1, 13) rec[-3] rec[-36] rec[-39] +DETECTOR(5, 4, 13) rec[-2] rec[-44] +DETECTOR(7, 1, 13) rec[-1] rec[-45] +TICK +MPP Z7*Z11*Z13*Z17*Z19*Z25 Z21*Z27*Z29*Z34 Z32*Z36*Z38*Z40 +DETECTOR(4, 3, 14) rec[-3] rec[-52] +DETECTOR(6, 2, 14) rec[-2] rec[-55] +DETECTOR(6, 1, 14) rec[-1] diff --git a/test/data/determined/chan_d5a19f13_T.stim b/test/data/determined/chan_d5a19f13_T.stim new file mode 100644 index 00000000..4acfcd9b --- /dev/null +++ b/test/data/determined/chan_d5a19f13_T.stim @@ -0,0 +1,421 @@ +QUBIT_COORDS(0, 0) 0 +QUBIT_COORDS(0, 1) 1 +QUBIT_COORDS(1, 0) 2 +QUBIT_COORDS(1, 1) 3 +QUBIT_COORDS(1, 2) 4 +QUBIT_COORDS(1, 3) 5 +QUBIT_COORDS(1.5, 0.5) 6 +QUBIT_COORDS(2, 0) 7 +QUBIT_COORDS(2, 1) 8 +QUBIT_COORDS(2, 2) 9 +QUBIT_COORDS(2, 3) 10 +QUBIT_COORDS(2, 4) 11 +QUBIT_COORDS(2.5, 0.5) 12 +QUBIT_COORDS(2.5, 1.5) 13 +QUBIT_COORDS(2.5, 2.5) 14 +QUBIT_COORDS(3, 0) 15 +QUBIT_COORDS(3, 1) 16 +QUBIT_COORDS(3, 2) 17 +QUBIT_COORDS(3, 3) 18 +QUBIT_COORDS(3, 4) 19 +QUBIT_COORDS(3, 5) 20 +QUBIT_COORDS(3.5, 0.5) 21 +QUBIT_COORDS(4, 0) 22 +QUBIT_COORDS(4, 1) 23 +QUBIT_COORDS(4, 2) 24 +QUBIT_COORDS(4, 3) 25 +QUBIT_COORDS(4, 4) 26 +QUBIT_COORDS(4, 5) 27 +QUBIT_COORDS(4, 6) 28 +QUBIT_COORDS(4.5, 0.5) 29 +QUBIT_COORDS(4.5, 1.5) 30 +QUBIT_COORDS(4.5, 2.5) 31 +QUBIT_COORDS(4.5, 3.5) 32 +QUBIT_COORDS(4.5, 4.5) 33 +QUBIT_COORDS(5, 0) 34 +QUBIT_COORDS(5, 1) 35 +QUBIT_COORDS(5, 2) 36 +QUBIT_COORDS(5, 3) 37 +QUBIT_COORDS(5, 4) 38 +QUBIT_COORDS(5, 5) 39 +QUBIT_COORDS(5, 6) 40 +QUBIT_COORDS(5.5, 0.5) 41 +QUBIT_COORDS(5.5, 1.5) 42 +QUBIT_COORDS(6, 0) 43 +QUBIT_COORDS(6, 1) 44 +QUBIT_COORDS(6, 2) 45 +QUBIT_COORDS(6, 3) 46 +QUBIT_COORDS(6, 4) 47 +QUBIT_COORDS(6.5, 0.5) 48 +QUBIT_COORDS(7, 0) 49 +QUBIT_COORDS(7, 1) 50 +QUBIT_COORDS(7, 2) 51 +QUBIT_COORDS(7, 3) 52 +QUBIT_COORDS(8, 0) 53 +QUBIT_COORDS(8, 1) 54 +R 16 9 7 +RX 8 15 17 3 2 4 23 0 5 22 +TICK +CX 8 16 15 7 17 9 +TICK +CX 8 9 15 16 +TICK +CX 8 7 17 16 +TICK +CX 2 7 4 9 23 16 +TICK +CX 7 2 9 4 16 23 +TICK +CX 3 4 22 23 +TICK +CX 3 2 23 22 +TICK +CX 4 3 +TICK +CX 2 3 +TICK +T 3 +TICK +CX 2 3 +TICK +CX 4 3 +TICK +CX 0 2 5 4 +TICK +CX 2 0 4 5 +TICK +R 7 23 9 10 +RX 2 16 4 +TICK +CX 2 7 4 9 5 10 16 23 +TICK +CX 2 0 7 15 9 17 10 5 16 8 +TICK +CX 2 3 7 8 9 10 16 17 +TICK +CX 4 3 9 8 16 15 23 22 +TICK +CX 3 4 8 9 15 16 22 23 +TICK +CX 0 2 8 16 15 7 17 9 +TICK +CX 3 2 8 7 10 9 17 16 +TICK +CX 2 7 4 9 16 23 +TICK +M 7 23 9 5 +MX 2 16 4 +DETECTOR(2, 0, 0) rec[-7] +DETECTOR(4, 1, 0) rec[-6] +DETECTOR(2, 2, 0) rec[-5] +DETECTOR(1, 3, 0) rec[-4] +DETECTOR(1, 0, 0) rec[-3] +DETECTOR(3, 1, 0) rec[-2] +DETECTOR(1, 2, 0) rec[-1] +TICK +RX 23 16 7 2 9 1 +TICK +T 3 15 17 +T_DAG 0 8 10 22 +TICK +CX 1 0 2 3 7 8 9 10 16 15 23 22 +R 6 12 +TICK +CX 3 6 8 12 +TICK +CX 8 6 16 12 +TICK +CX 3 1 8 9 16 23 +TICK +CX 8 3 16 17 +TICK +CX 8 16 +TICK +MX 8 +DETECTOR(1, 2, 1) rec[-1] rec[-2] rec[-3] +TICK +RX 8 +TICK +CX 8 16 +TICK +CX 8 3 16 17 +TICK +CX 3 1 8 9 16 23 +TICK +CX 8 6 16 12 +TICK +CX 3 6 8 12 +TICK +CX 1 0 2 3 7 8 9 10 16 15 23 22 +M 6 12 +DETECTOR(1.5, 0.5, 2) rec[-2] +DETECTOR(2.5, 0.5, 2) rec[-1] +TICK +T 0 8 10 22 +T_DAG 3 15 17 +TICK +MX 23 16 7 2 9 1 +DETECTOR(4, 1, 3) rec[-6] +DETECTOR(3, 1, 3) rec[-5] +DETECTOR(2, 1, 3) rec[-4] rec[-9] +DETECTOR(1, 0, 3) rec[-3] +DETECTOR(2, 2, 3) rec[-2] +DETECTOR(0, 1, 3) rec[-1] +TICK +R 24 35 44 51 53 28 19 27 26 39 46 +RX 36 45 49 20 38 37 +TICK +CX 20 27 36 24 37 46 38 26 45 51 49 53 +TICK +CX 20 19 27 28 36 35 38 39 45 44 +TICK +CX 19 20 28 27 35 36 39 38 44 45 +TICK +M 36 45 38 27 20 +DETECTOR(5, 2, 4) rec[-5] +DETECTOR(6, 2, 4) rec[-4] +DETECTOR(5, 4, 4) rec[-3] +DETECTOR(4, 5, 4) rec[-2] +DETECTOR(3, 5, 4) rec[-1] +TICK +R 54 47 45 43 27 25 23 9 7 +RX 50 38 36 34 20 18 16 4 2 +TICK +CX 2 7 4 9 16 23 18 25 20 27 34 43 36 45 38 47 50 54 +TICK +CX 3 4 8 9 15 16 17 18 19 20 22 23 24 25 26 27 35 36 37 38 44 45 46 47 49 50 53 54 +TICK +CX 3 2 8 7 10 9 17 16 19 18 24 23 26 25 28 27 35 34 37 36 39 38 44 43 46 45 51 50 +TICK +CX 0 2 8 16 10 18 15 7 17 9 22 34 24 36 26 38 35 23 37 25 39 27 44 50 49 43 51 45 +TICK +CX 4 3 9 8 16 15 18 17 20 19 23 22 25 24 27 26 36 35 38 37 45 44 47 46 50 49 54 53 +TICK +CX 2 3 7 8 9 10 16 17 18 19 23 24 25 26 27 28 34 35 36 37 38 39 43 44 45 46 50 51 +TICK +CX 2 0 7 15 9 17 16 8 18 10 23 35 25 37 27 39 34 22 36 24 38 26 43 49 45 51 50 44 +TICK +CX 2 7 4 9 16 23 18 25 20 27 34 43 36 45 38 47 50 54 +TICK +M 54 47 45 43 27 25 23 9 7 +MX 50 38 36 34 20 18 16 4 2 +DETECTOR(8, 1, 5) rec[-18] +DETECTOR(6, 4, 5) rec[-17] +DETECTOR(6, 2, 5) rec[-16] +DETECTOR(4, 5, 5) rec[-14] +DETECTOR(4, 1, 5) rec[-12] +DETECTOR(2, 2, 5) rec[-11] +DETECTOR(2, 0, 5) rec[-10] +DETECTOR(7, 1, 5) rec[-9] +DETECTOR(5, 4, 5) rec[-8] +DETECTOR(5, 2, 5) rec[-7] +DETECTOR(3, 5, 5) rec[-5] +DETECTOR(2, 1, 5) rec[-3] rec[-32] +DETECTOR(1, 2, 5) rec[-2] rec[-32] +DETECTOR(1, 0, 5) rec[-1] rec[-32] +TICK +CZ rec[-6] 49 rec[-6] 53 rec[-4] 19 rec[-4] 28 +CX rec[-15] 49 rec[-15] 53 rec[-15] 51 rec[-15] 53 rec[-16] 49 rec[-16] 53 rec[-12] 19 rec[-12] 28 rec[-13] 0 rec[-13] 15 rec[-13] 28 rec[-14] 19 rec[-14] 28 +R 54 47 45 43 27 25 23 9 7 +RX 50 38 36 34 20 18 16 4 2 +TICK +CX 2 7 4 9 16 23 18 25 20 27 34 43 36 45 38 47 50 54 +TICK +CX 3 4 8 9 15 16 17 18 19 20 22 23 24 25 26 27 35 36 37 38 44 45 46 47 49 50 53 54 +TICK +CX 3 2 8 7 10 9 17 16 19 18 24 23 26 25 28 27 35 34 37 36 39 38 44 43 46 45 51 50 +TICK +CX 0 2 8 16 10 18 15 7 17 9 22 34 24 36 26 38 35 23 37 25 39 27 44 50 49 43 51 45 +TICK +CX 4 3 9 8 16 15 18 17 20 19 23 22 25 24 27 26 36 35 38 37 45 44 47 46 50 49 54 53 +TICK +CX 2 3 7 8 9 10 16 17 18 19 23 24 25 26 27 28 34 35 36 37 38 39 43 44 45 46 50 51 +TICK +CX 2 0 7 15 9 17 16 8 18 10 23 35 25 37 27 39 34 22 36 24 38 26 43 49 45 51 50 44 +TICK +CX 2 7 4 9 16 23 18 25 20 27 34 43 36 45 38 47 50 54 +TICK +M 54 47 45 43 27 25 23 9 7 +MX 50 38 36 34 20 18 16 4 2 +DETECTOR(8, 1, 6) rec[-18] +DETECTOR(6, 2, 6) rec[-17] +DETECTOR(6, 0, 6) rec[-16] rec[-35] +DETECTOR(6, 0.5, 6) rec[-15] +DETECTOR(4, 3, 6) rec[-14] +DETECTOR(4, 1, 6) rec[-13] +DETECTOR(4, 2, 6) rec[-12] +DETECTOR(2, 0, 6) rec[-11] rec[-28] +DETECTOR(2, 2, 6) rec[-10] rec[-28] rec[-29] +DETECTOR(7, 1, 6) rec[-9] rec[-27] +DETECTOR(5, 4, 6) rec[-8] rec[-26] +DETECTOR(5, 2, 6) rec[-7] rec[-25] +DETECTOR(5, 0, 6) rec[-6] +DETECTOR(3, 5, 6) rec[-5] rec[-23] +DETECTOR(3, 3, 6) rec[-4] +DETECTOR(3, 1, 6) rec[-3] rec[-21] +DETECTOR(1, 2, 6) rec[-2] rec[-20] +DETECTOR(1, 0, 6) rec[-1] rec[-19] +TICK +R 54 47 45 43 27 25 23 9 7 +RX 50 38 36 34 20 18 16 4 2 +TICK +CX 2 7 4 9 16 23 18 25 20 27 34 43 36 45 38 47 50 54 +TICK +CX 3 4 8 9 15 16 17 18 19 20 22 23 24 25 26 27 35 36 37 38 44 45 46 47 49 50 53 54 +TICK +CX 3 2 8 7 10 9 17 16 19 18 24 23 26 25 28 27 35 34 37 36 39 38 44 43 46 45 51 50 +TICK +CX 0 2 8 16 10 18 15 7 17 9 22 34 24 36 26 38 35 23 37 25 39 27 44 50 49 43 51 45 +TICK +CX 4 3 9 8 16 15 18 17 20 19 23 22 25 24 27 26 36 35 38 37 45 44 47 46 50 49 54 53 +TICK +CX 2 3 7 8 9 10 16 17 18 19 23 24 25 26 27 28 34 35 36 37 38 39 43 44 45 46 50 51 +TICK +CX 2 0 7 15 9 17 16 8 18 10 23 35 25 37 27 39 34 22 36 24 38 26 43 49 45 51 50 44 +TICK +CX 2 7 4 9 16 23 18 25 20 27 34 43 36 45 38 47 50 54 +TICK +M 54 47 45 43 27 25 23 9 7 +MX 50 38 36 34 20 18 16 4 2 +DETECTOR(8, 1, 7) rec[-18] +DETECTOR(6, 2, 7) rec[-17] rec[-34] +DETECTOR(6, 0, 7) rec[-16] rec[-33] rec[-35] +DETECTOR(6, 0.5, 7) rec[-15] rec[-33] rec[-34] +DETECTOR(4, 3, 7) rec[-14] rec[-31] +DETECTOR(4, 1, 7) rec[-13] rec[-30] rec[-32] +DETECTOR(4, 2, 7) rec[-12] rec[-31] +DETECTOR(2, 0, 7) rec[-11] rec[-28] +DETECTOR(2, 2, 7) rec[-10] rec[-28] rec[-29] +DETECTOR(7, 1, 7) rec[-9] rec[-27] +DETECTOR(5, 4, 7) rec[-8] rec[-26] +DETECTOR(5, 2, 7) rec[-7] rec[-25] +DETECTOR(5, 0, 7) rec[-6] rec[-24] +DETECTOR(3, 5, 7) rec[-5] rec[-23] +DETECTOR(3, 3, 7) rec[-4] rec[-22] +DETECTOR(3, 1, 7) rec[-3] rec[-21] +DETECTOR(1, 2, 7) rec[-2] rec[-20] +DETECTOR(1, 0, 7) rec[-1] rec[-19] +TICK +RX 34 43 2 7 9 11 25 27 52 1 16 23 50 45 18 36 38 40 54 +TICK +T 3 15 17 35 19 37 39 49 51 +T_DAG 0 8 10 22 24 26 28 44 46 53 +TICK +CX 1 0 2 3 7 8 9 17 11 19 16 15 18 10 23 22 25 37 27 39 34 35 36 24 38 26 40 28 43 44 45 46 50 49 52 51 54 53 +R 21 13 30 14 32 33 +TICK +CX 16 21 17 13 36 30 18 14 38 32 39 33 +R 6 12 48 41 42 31 +TICK +CX 18 19 39 40 3 6 8 12 16 13 17 14 35 30 36 31 37 32 38 33 45 42 44 41 50 48 +TICK +CX 17 18 38 39 3 1 50 54 45 51 8 6 16 12 37 31 35 41 44 48 36 42 +R 29 +TICK +CX 16 17 37 38 8 3 23 21 35 29 44 50 36 45 +TICK +CX 16 8 36 37 23 29 35 44 +TICK +CX 23 16 35 36 +TICK +CX 35 23 +TICK +MX 35 +DETECTOR(0, 1, 8) rec[-1] rec[-12] rec[-13] rec[-14] rec[-15] rec[-17] rec[-18] rec[-19] rec[-30] rec[-31] rec[-32] rec[-33] rec[-35] rec[-36] rec[-37] rec[-48] rec[-49] rec[-51] rec[-53] rec[-54] rec[-55] rec[-61] rec[-62] rec[-65] rec[-66] +TICK +RX 35 +TICK +CX 35 23 +TICK +CX 23 16 35 36 +TICK +CX 16 8 36 37 23 29 35 44 +TICK +CX 16 17 37 38 8 3 23 21 35 29 44 50 36 45 +TICK +CX 17 18 38 39 3 1 8 6 16 12 37 31 35 41 36 42 44 48 45 51 50 54 +M 29 +DETECTOR(4.5, 0.5, 9) rec[-1] +TICK +CX 18 19 39 40 3 6 8 12 16 13 17 14 35 30 36 31 37 32 38 33 45 42 44 41 50 48 +TICK +CX 16 21 17 13 18 14 36 30 38 32 39 33 +M 6 12 31 42 41 48 +DETECTOR(1.5, 0.5, 10) rec[-6] +DETECTOR(2.5, 0.5, 10) rec[-5] +DETECTOR(4.5, 2.5, 10) rec[-4] +DETECTOR(5.5, 1.5, 10) rec[-3] +DETECTOR(5.5, 0.5, 10) rec[-2] +DETECTOR(6.5, 0.5, 10) rec[-1] +TICK +CX 1 0 2 3 7 8 9 17 11 19 16 15 18 10 23 22 25 37 27 39 34 35 36 24 38 26 40 28 43 44 45 46 50 49 52 51 54 53 +M 21 13 30 14 32 33 +DETECTOR(3.5, 0.5, 11) rec[-6] +DETECTOR(2.5, 1.5, 11) rec[-5] +DETECTOR(4.5, 1.5, 11) rec[-4] +DETECTOR(2.5, 2.5, 11) rec[-3] +DETECTOR(4.5, 3.5, 11) rec[-2] +DETECTOR(4.5, 4.5, 11) rec[-1] +TICK +T 0 8 10 22 24 26 28 44 46 53 +T_DAG 3 15 17 35 19 37 39 49 51 +TICK +MX 25 27 9 11 2 7 34 43 52 1 16 23 50 45 18 36 38 40 54 +DETECTOR(4, 3, 12) rec[-19] +DETECTOR(4, 5, 12) rec[-18] +DETECTOR(2, 2, 12) rec[-17] +DETECTOR(2, 4, 12) rec[-16] +DETECTOR(1, 0, 12) rec[-15] +DETECTOR(2, 0, 12) rec[-14] +DETECTOR(5, 1, 12) rec[-13] rec[-33] +DETECTOR(6, 0, 12) rec[-12] +DETECTOR(7, 3, 12) rec[-11] +DETECTOR(0, 1, 12) rec[-10] +DETECTOR(3, 1, 12) rec[-9] +DETECTOR(4, 1, 12) rec[-8] +DETECTOR(7, 1, 12) rec[-7] +DETECTOR(6, 2, 12) rec[-6] +DETECTOR(3, 3, 12) rec[-5] +DETECTOR(5, 2, 12) rec[-4] +DETECTOR(5, 4, 12) rec[-3] +DETECTOR(5, 6, 12) rec[-2] +DETECTOR(8, 1, 12) rec[-1] +TICK +T 3 15 17 35 19 37 39 49 51 +T_DAG 0 8 10 22 24 26 28 44 46 53 +TICK +MPP X0*X3*X8*X10*X15*X17*X19*X22*X24*X26*X28*X35*X37*X39*X44*X46*X49*X51*X53 +OBSERVABLE_INCLUDE(0) rec[-1] rec[-2] rec[-3] rec[-4] rec[-5] rec[-6] rec[-7] rec[-8] rec[-9] rec[-10] rec[-11] +TICK +T 0 8 10 22 24 26 28 44 46 53 +T_DAG 3 15 17 35 19 37 39 49 51 +TICK +MPP X0*X3*X8*X15 X10*X17*X19*X24*X26*X37 X22*X35*X44*X49 +DETECTOR(1, 0, 13) rec[-3] rec[-38] +DETECTOR(3, 3, 13) rec[-2] rec[-41] +DETECTOR(5, 0, 13) rec[-1] rec[-37] rec[-43] +TICK +MPP Z0*Z3*Z8*Z15 Z10*Z17*Z19*Z24*Z26*Z37 Z22*Z35*Z44*Z49 +DETECTOR(2, 0, 14) rec[-3] rec[-50] rec[-51] +DETECTOR(4, 1, 14) rec[-2] rec[-52] rec[-54] +DETECTOR(6, 0, 14) rec[-1] rec[-55] rec[-56] +TICK +MPP X3*X8*X10*X17 X19*X26*X28*X39 X24*X35*X37*X44*X46*X51 +DETECTOR(1, 2, 15) rec[-3] rec[-45] +DETECTOR(3, 5, 15) rec[-2] rec[-48] +DETECTOR(5, 2, 15) rec[-1] rec[-43] rec[-50] +TICK +MPP Z3*Z8*Z10*Z17 Z19*Z26*Z28*Z39 Z24*Z35*Z37*Z44*Z46*Z51 +DETECTOR(2, 0, 16) rec[-3] rec[-56] +DETECTOR(4, 3, 16) rec[-2] rec[-59] +DETECTOR(6, 0, 16) rec[-1] rec[-61] rec[-63] +TICK +MPP X8*X15*X17*X22*X24*X35 X26*X37*X39*X46 X44*X49*X51*X53 +DETECTOR(3, 1, 17) rec[-3] rec[-49] rec[-52] +DETECTOR(5, 4, 17) rec[-2] rec[-57] +DETECTOR(7, 1, 17) rec[-1] rec[-58] +TICK +MPP Z8*Z15*Z17*Z22*Z24*Z35 Z26*Z37*Z39*Z46 Z44*Z49*Z51*Z53 +DETECTOR(4, 3, 18) rec[-3] rec[-65] +DETECTOR(6, 2, 18) rec[-2] rec[-68] +DETECTOR(6, 1, 18) rec[-1] diff --git a/test/data/determined/chan_d5a19f13_uncorrected_T.stim b/test/data/determined/chan_d5a19f13_uncorrected_T.stim new file mode 100644 index 00000000..7d11168d --- /dev/null +++ b/test/data/determined/chan_d5a19f13_uncorrected_T.stim @@ -0,0 +1,419 @@ +QUBIT_COORDS(0, 0) 0 +QUBIT_COORDS(0, 1) 1 +QUBIT_COORDS(1, 0) 2 +QUBIT_COORDS(1, 1) 3 +QUBIT_COORDS(1, 2) 4 +QUBIT_COORDS(1, 3) 5 +QUBIT_COORDS(1.5, 0.5) 6 +QUBIT_COORDS(2, 0) 7 +QUBIT_COORDS(2, 1) 8 +QUBIT_COORDS(2, 2) 9 +QUBIT_COORDS(2, 3) 10 +QUBIT_COORDS(2, 4) 11 +QUBIT_COORDS(2.5, 0.5) 12 +QUBIT_COORDS(2.5, 1.5) 13 +QUBIT_COORDS(2.5, 2.5) 14 +QUBIT_COORDS(3, 0) 15 +QUBIT_COORDS(3, 1) 16 +QUBIT_COORDS(3, 2) 17 +QUBIT_COORDS(3, 3) 18 +QUBIT_COORDS(3, 4) 19 +QUBIT_COORDS(3, 5) 20 +QUBIT_COORDS(3.5, 0.5) 21 +QUBIT_COORDS(4, 0) 22 +QUBIT_COORDS(4, 1) 23 +QUBIT_COORDS(4, 2) 24 +QUBIT_COORDS(4, 3) 25 +QUBIT_COORDS(4, 4) 26 +QUBIT_COORDS(4, 5) 27 +QUBIT_COORDS(4, 6) 28 +QUBIT_COORDS(4.5, 0.5) 29 +QUBIT_COORDS(4.5, 1.5) 30 +QUBIT_COORDS(4.5, 2.5) 31 +QUBIT_COORDS(4.5, 3.5) 32 +QUBIT_COORDS(4.5, 4.5) 33 +QUBIT_COORDS(5, 0) 34 +QUBIT_COORDS(5, 1) 35 +QUBIT_COORDS(5, 2) 36 +QUBIT_COORDS(5, 3) 37 +QUBIT_COORDS(5, 4) 38 +QUBIT_COORDS(5, 5) 39 +QUBIT_COORDS(5, 6) 40 +QUBIT_COORDS(5.5, 0.5) 41 +QUBIT_COORDS(5.5, 1.5) 42 +QUBIT_COORDS(6, 0) 43 +QUBIT_COORDS(6, 1) 44 +QUBIT_COORDS(6, 2) 45 +QUBIT_COORDS(6, 3) 46 +QUBIT_COORDS(6, 4) 47 +QUBIT_COORDS(6.5, 0.5) 48 +QUBIT_COORDS(7, 0) 49 +QUBIT_COORDS(7, 1) 50 +QUBIT_COORDS(7, 2) 51 +QUBIT_COORDS(7, 3) 52 +QUBIT_COORDS(8, 0) 53 +QUBIT_COORDS(8, 1) 54 +R 16 9 7 +RX 8 15 17 3 2 4 23 0 5 22 +TICK +CX 8 16 15 7 17 9 +TICK +CX 8 9 15 16 +TICK +CX 8 7 17 16 +TICK +CX 2 7 4 9 23 16 +TICK +CX 7 2 9 4 16 23 +TICK +CX 3 4 22 23 +TICK +CX 3 2 23 22 +TICK +CX 4 3 +TICK +CX 2 3 +TICK +T 3 +TICK +CX 2 3 +TICK +CX 4 3 +TICK +CX 0 2 5 4 +TICK +CX 2 0 4 5 +TICK +R 7 23 9 10 +RX 2 16 4 +TICK +CX 2 7 4 9 5 10 16 23 +TICK +CX 2 0 7 15 9 17 10 5 16 8 +TICK +CX 2 3 7 8 9 10 16 17 +TICK +CX 4 3 9 8 16 15 23 22 +TICK +CX 3 4 8 9 15 16 22 23 +TICK +CX 0 2 8 16 15 7 17 9 +TICK +CX 3 2 8 7 10 9 17 16 +TICK +CX 2 7 4 9 16 23 +TICK +M 7 23 9 5 +MX 2 16 4 +DETECTOR(2, 0, 0) rec[-7] +DETECTOR(4, 1, 0) rec[-6] +DETECTOR(2, 2, 0) rec[-5] +DETECTOR(1, 3, 0) rec[-4] +DETECTOR(1, 0, 0) rec[-3] +DETECTOR(3, 1, 0) rec[-2] +DETECTOR(1, 2, 0) rec[-1] +TICK +RX 23 16 7 2 9 1 +TICK +T 3 15 17 +T_DAG 0 8 10 22 +TICK +CX 1 0 2 3 7 8 9 10 16 15 23 22 +R 6 12 +TICK +CX 3 6 8 12 +TICK +CX 8 6 16 12 +TICK +CX 3 1 8 9 16 23 +TICK +CX 8 3 16 17 +TICK +CX 8 16 +TICK +MX 8 +DETECTOR(1, 2, 1) rec[-1] rec[-2] rec[-3] +TICK +RX 8 +TICK +CX 8 16 +TICK +CX 8 3 16 17 +TICK +CX 3 1 8 9 16 23 +TICK +CX 8 6 16 12 +TICK +CX 3 6 8 12 +TICK +CX 1 0 2 3 7 8 9 10 16 15 23 22 +M 6 12 +DETECTOR(1.5, 0.5, 2) rec[-2] +DETECTOR(2.5, 0.5, 2) rec[-1] +TICK +T 0 8 10 22 +T_DAG 3 15 17 +TICK +MX 23 16 7 2 9 1 +DETECTOR(4, 1, 3) rec[-6] +DETECTOR(3, 1, 3) rec[-5] +DETECTOR(2, 1, 3) rec[-4] rec[-9] +DETECTOR(1, 0, 3) rec[-3] +DETECTOR(2, 2, 3) rec[-2] +DETECTOR(0, 1, 3) rec[-1] +TICK +R 24 35 44 51 53 28 19 27 26 39 46 +RX 36 45 49 20 38 37 +TICK +CX 20 27 36 24 37 46 38 26 45 51 49 53 +TICK +CX 20 19 27 28 36 35 38 39 45 44 +TICK +CX 19 20 28 27 35 36 39 38 44 45 +TICK +M 36 45 38 27 20 +DETECTOR(5, 2, 4) rec[-5] +DETECTOR(6, 2, 4) rec[-4] +DETECTOR(5, 4, 4) rec[-3] +DETECTOR(4, 5, 4) rec[-2] +DETECTOR(3, 5, 4) rec[-1] +TICK +R 54 47 45 43 27 25 23 9 7 +RX 50 38 36 34 20 18 16 4 2 +TICK +CX 2 7 4 9 16 23 18 25 20 27 34 43 36 45 38 47 50 54 +TICK +CX 3 4 8 9 15 16 17 18 19 20 22 23 24 25 26 27 35 36 37 38 44 45 46 47 49 50 53 54 +TICK +CX 3 2 8 7 10 9 17 16 19 18 24 23 26 25 28 27 35 34 37 36 39 38 44 43 46 45 51 50 +TICK +CX 0 2 8 16 10 18 15 7 17 9 22 34 24 36 26 38 35 23 37 25 39 27 44 50 49 43 51 45 +TICK +CX 4 3 9 8 16 15 18 17 20 19 23 22 25 24 27 26 36 35 38 37 45 44 47 46 50 49 54 53 +TICK +CX 2 3 7 8 9 10 16 17 18 19 23 24 25 26 27 28 34 35 36 37 38 39 43 44 45 46 50 51 +TICK +CX 2 0 7 15 9 17 16 8 18 10 23 35 25 37 27 39 34 22 36 24 38 26 43 49 45 51 50 44 +TICK +CX 2 7 4 9 16 23 18 25 20 27 34 43 36 45 38 47 50 54 +TICK +M 54 47 45 43 27 25 23 9 7 +MX 50 38 36 34 20 18 16 4 2 +DETECTOR(8, 1, 5) rec[-18] +DETECTOR(6, 4, 5) rec[-17] +DETECTOR(6, 2, 5) rec[-16] +DETECTOR(4, 5, 5) rec[-14] +DETECTOR(4, 1, 5) rec[-12] +DETECTOR(2, 2, 5) rec[-11] +DETECTOR(2, 0, 5) rec[-10] +DETECTOR(7, 1, 5) rec[-9] +DETECTOR(5, 4, 5) rec[-8] +DETECTOR(5, 2, 5) rec[-7] +DETECTOR(3, 5, 5) rec[-5] +DETECTOR(2, 1, 5) rec[-3] rec[-32] +DETECTOR(1, 2, 5) rec[-2] rec[-32] +DETECTOR(1, 0, 5) rec[-1] rec[-32] +TICK +R 54 47 45 43 27 25 23 9 7 +RX 50 38 36 34 20 18 16 4 2 +TICK +CX 2 7 4 9 16 23 18 25 20 27 34 43 36 45 38 47 50 54 +TICK +CX 3 4 8 9 15 16 17 18 19 20 22 23 24 25 26 27 35 36 37 38 44 45 46 47 49 50 53 54 +TICK +CX 3 2 8 7 10 9 17 16 19 18 24 23 26 25 28 27 35 34 37 36 39 38 44 43 46 45 51 50 +TICK +CX 0 2 8 16 10 18 15 7 17 9 22 34 24 36 26 38 35 23 37 25 39 27 44 50 49 43 51 45 +TICK +CX 4 3 9 8 16 15 18 17 20 19 23 22 25 24 27 26 36 35 38 37 45 44 47 46 50 49 54 53 +TICK +CX 2 3 7 8 9 10 16 17 18 19 23 24 25 26 27 28 34 35 36 37 38 39 43 44 45 46 50 51 +TICK +CX 2 0 7 15 9 17 16 8 18 10 23 35 25 37 27 39 34 22 36 24 38 26 43 49 45 51 50 44 +TICK +CX 2 7 4 9 16 23 18 25 20 27 34 43 36 45 38 47 50 54 +TICK +M 54 47 45 43 27 25 23 9 7 +MX 50 38 36 34 20 18 16 4 2 +DETECTOR(8, 1, 6) rec[-18] +DETECTOR(6, 2, 6) rec[-17] rec[-34] +DETECTOR(6, 0, 6) rec[-16] rec[-33] rec[-35] +DETECTOR(6, 0.5, 6) rec[-15] rec[-33] rec[-34] +DETECTOR(4, 3, 6) rec[-14] rec[-31] +DETECTOR(4, 1, 6) rec[-13] rec[-30] rec[-32] +DETECTOR(4, 2, 6) rec[-12] rec[-31] +DETECTOR(2, 0, 6) rec[-11] rec[-28] +DETECTOR(2, 2, 6) rec[-10] rec[-28] rec[-29] +DETECTOR(7, 1, 6) rec[-9] rec[-27] +DETECTOR(5, 4, 6) rec[-8] rec[-26] +DETECTOR(5, 2, 6) rec[-7] rec[-25] +DETECTOR(5, 0, 6) rec[-6] rec[-24] +DETECTOR(3, 5, 6) rec[-5] rec[-23] +DETECTOR(3, 3, 6) rec[-4] rec[-22] +DETECTOR(3, 1, 6) rec[-3] rec[-21] +DETECTOR(1, 2, 6) rec[-2] rec[-20] +DETECTOR(1, 0, 6) rec[-1] rec[-19] +TICK +R 54 47 45 43 27 25 23 9 7 +RX 50 38 36 34 20 18 16 4 2 +TICK +CX 2 7 4 9 16 23 18 25 20 27 34 43 36 45 38 47 50 54 +TICK +CX 3 4 8 9 15 16 17 18 19 20 22 23 24 25 26 27 35 36 37 38 44 45 46 47 49 50 53 54 +TICK +CX 3 2 8 7 10 9 17 16 19 18 24 23 26 25 28 27 35 34 37 36 39 38 44 43 46 45 51 50 +TICK +CX 0 2 8 16 10 18 15 7 17 9 22 34 24 36 26 38 35 23 37 25 39 27 44 50 49 43 51 45 +TICK +CX 4 3 9 8 16 15 18 17 20 19 23 22 25 24 27 26 36 35 38 37 45 44 47 46 50 49 54 53 +TICK +CX 2 3 7 8 9 10 16 17 18 19 23 24 25 26 27 28 34 35 36 37 38 39 43 44 45 46 50 51 +TICK +CX 2 0 7 15 9 17 16 8 18 10 23 35 25 37 27 39 34 22 36 24 38 26 43 49 45 51 50 44 +TICK +CX 2 7 4 9 16 23 18 25 20 27 34 43 36 45 38 47 50 54 +TICK +M 54 47 45 43 27 25 23 9 7 +MX 50 38 36 34 20 18 16 4 2 +DETECTOR(8, 1, 7) rec[-18] +DETECTOR(6, 2, 7) rec[-17] rec[-34] +DETECTOR(6, 0, 7) rec[-16] rec[-33] rec[-35] +DETECTOR(6, 0.5, 7) rec[-15] rec[-33] rec[-34] +DETECTOR(4, 3, 7) rec[-14] rec[-31] +DETECTOR(4, 1, 7) rec[-13] rec[-30] rec[-32] +DETECTOR(4, 2, 7) rec[-12] rec[-31] +DETECTOR(2, 0, 7) rec[-11] rec[-28] +DETECTOR(2, 2, 7) rec[-10] rec[-28] rec[-29] +DETECTOR(7, 1, 7) rec[-9] rec[-27] +DETECTOR(5, 4, 7) rec[-8] rec[-26] +DETECTOR(5, 2, 7) rec[-7] rec[-25] +DETECTOR(5, 0, 7) rec[-6] rec[-24] +DETECTOR(3, 5, 7) rec[-5] rec[-23] +DETECTOR(3, 3, 7) rec[-4] rec[-22] +DETECTOR(3, 1, 7) rec[-3] rec[-21] +DETECTOR(1, 2, 7) rec[-2] rec[-20] +DETECTOR(1, 0, 7) rec[-1] rec[-19] +TICK +RX 34 43 2 7 9 11 25 27 52 1 16 23 50 45 18 36 38 40 54 +TICK +T 3 15 17 35 19 37 39 49 51 +T_DAG 0 8 10 22 24 26 28 44 46 53 +TICK +CX 1 0 2 3 7 8 9 17 11 19 16 15 18 10 23 22 25 37 27 39 34 35 36 24 38 26 40 28 43 44 45 46 50 49 52 51 54 53 +R 21 13 30 14 32 33 +TICK +CX 16 21 17 13 36 30 18 14 38 32 39 33 +R 6 12 48 41 42 31 +TICK +CX 18 19 39 40 3 6 8 12 16 13 17 14 35 30 36 31 37 32 38 33 45 42 44 41 50 48 +TICK +CX 17 18 38 39 3 1 50 54 45 51 8 6 16 12 37 31 35 41 44 48 36 42 +R 29 +TICK +CX 16 17 37 38 8 3 23 21 35 29 44 50 36 45 +TICK +CX 16 8 36 37 23 29 35 44 +TICK +CX 23 16 35 36 +TICK +CX 35 23 +TICK +MX 35 +DETECTOR(0, 1, 8) rec[-1] rec[-12] rec[-13] rec[-14] rec[-15] rec[-17] rec[-18] rec[-19] rec[-30] rec[-31] rec[-32] rec[-33] rec[-35] rec[-36] rec[-37] rec[-48] rec[-49] rec[-50] rec[-51] rec[-53] rec[-54] rec[-55] rec[-61] rec[-62] rec[-65] rec[-66] +TICK +RX 35 +TICK +CX 35 23 +TICK +CX 23 16 35 36 +TICK +CX 16 8 36 37 23 29 35 44 +TICK +CX 16 17 37 38 8 3 23 21 35 29 44 50 36 45 +TICK +CX 17 18 38 39 3 1 8 6 16 12 37 31 35 41 36 42 44 48 45 51 50 54 +M 29 +DETECTOR(4.5, 0.5, 9) rec[-1] +TICK +CX 18 19 39 40 3 6 8 12 16 13 17 14 35 30 36 31 37 32 38 33 45 42 44 41 50 48 +TICK +CX 16 21 17 13 18 14 36 30 38 32 39 33 +M 6 12 31 42 41 48 +DETECTOR(1.5, 0.5, 10) rec[-6] +DETECTOR(2.5, 0.5, 10) rec[-5] +DETECTOR(4.5, 2.5, 10) rec[-4] +DETECTOR(5.5, 1.5, 10) rec[-3] +DETECTOR(5.5, 0.5, 10) rec[-2] +DETECTOR(6.5, 0.5, 10) rec[-1] +TICK +CX 1 0 2 3 7 8 9 17 11 19 16 15 18 10 23 22 25 37 27 39 34 35 36 24 38 26 40 28 43 44 45 46 50 49 52 51 54 53 +M 21 13 30 14 32 33 +DETECTOR(3.5, 0.5, 11) rec[-6] +DETECTOR(2.5, 1.5, 11) rec[-5] +DETECTOR(4.5, 1.5, 11) rec[-4] +DETECTOR(2.5, 2.5, 11) rec[-3] +DETECTOR(4.5, 3.5, 11) rec[-2] +DETECTOR(4.5, 4.5, 11) rec[-1] +TICK +T 0 8 10 22 24 26 28 44 46 53 +T_DAG 3 15 17 35 19 37 39 49 51 +TICK +MX 25 27 9 11 2 7 34 43 52 1 16 23 50 45 18 36 38 40 54 +DETECTOR(4, 3, 12) rec[-19] +DETECTOR(4, 5, 12) rec[-18] +DETECTOR(2, 2, 12) rec[-17] +DETECTOR(2, 4, 12) rec[-16] +DETECTOR(1, 0, 12) rec[-15] +DETECTOR(2, 0, 12) rec[-14] +DETECTOR(5, 1, 12) rec[-13] rec[-33] +DETECTOR(6, 0, 12) rec[-12] +DETECTOR(7, 3, 12) rec[-11] +DETECTOR(0, 1, 12) rec[-10] +DETECTOR(3, 1, 12) rec[-9] +DETECTOR(4, 1, 12) rec[-8] +DETECTOR(7, 1, 12) rec[-7] +DETECTOR(6, 2, 12) rec[-6] +DETECTOR(3, 3, 12) rec[-5] +DETECTOR(5, 2, 12) rec[-4] +DETECTOR(5, 4, 12) rec[-3] +DETECTOR(5, 6, 12) rec[-2] +DETECTOR(8, 1, 12) rec[-1] +TICK +T 3 15 17 35 19 37 39 49 51 +T_DAG 0 8 10 22 24 26 28 44 46 53 +TICK +MPP X0*X3*X8*X10*X15*X17*X19*X22*X24*X26*X28*X35*X37*X39*X44*X46*X49*X51*X53 +OBSERVABLE_INCLUDE(0) rec[-1] rec[-2] rec[-3] rec[-4] rec[-5] rec[-6] rec[-7] rec[-8] rec[-9] rec[-10] rec[-11] +TICK +T 0 8 10 22 24 26 28 44 46 53 +T_DAG 3 15 17 35 19 37 39 49 51 +TICK +MPP X0*X3*X8*X15 X10*X17*X19*X24*X26*X37 X22*X35*X44*X49 +DETECTOR(1, 0, 13) rec[-3] rec[-38] +DETECTOR(3, 3, 13) rec[-2] rec[-41] +DETECTOR(5, 0, 13) rec[-1] rec[-37] rec[-43] +TICK +MPP Z0*Z3*Z8*Z15 Z10*Z17*Z19*Z24*Z26*Z37 Z22*Z35*Z44*Z49 +DETECTOR(2, 0, 14) rec[-3] rec[-50] rec[-51] +DETECTOR(4, 1, 14) rec[-2] rec[-52] rec[-54] +DETECTOR(6, 0, 14) rec[-1] rec[-55] rec[-56] +TICK +MPP X3*X8*X10*X17 X19*X26*X28*X39 X24*X35*X37*X44*X46*X51 +DETECTOR(1, 2, 15) rec[-3] rec[-45] +DETECTOR(3, 5, 15) rec[-2] rec[-48] +DETECTOR(5, 2, 15) rec[-1] rec[-43] rec[-50] +TICK +MPP Z3*Z8*Z10*Z17 Z19*Z26*Z28*Z39 Z24*Z35*Z37*Z44*Z46*Z51 +DETECTOR(2, 0, 16) rec[-3] rec[-56] +DETECTOR(4, 3, 16) rec[-2] rec[-59] +DETECTOR(6, 0, 16) rec[-1] rec[-61] rec[-63] +TICK +MPP X8*X15*X17*X22*X24*X35 X26*X37*X39*X46 X44*X49*X51*X53 +DETECTOR(3, 1, 17) rec[-3] rec[-49] rec[-52] +DETECTOR(5, 4, 17) rec[-2] rec[-57] +DETECTOR(7, 1, 17) rec[-1] rec[-58] +TICK +MPP Z8*Z15*Z17*Z22*Z24*Z35 Z26*Z37*Z39*Z46 Z44*Z49*Z51*Z53 +DETECTOR(4, 3, 18) rec[-3] rec[-65] +DETECTOR(6, 2, 18) rec[-2] rec[-68] +DETECTOR(6, 1, 18) rec[-1] diff --git a/test/data/determined/clifft_d5_T.stim b/test/data/determined/clifft_d5_T.stim new file mode 100644 index 00000000..8317f64c --- /dev/null +++ b/test/data/determined/clifft_d5_T.stim @@ -0,0 +1,359 @@ +QUBIT_COORDS(0, 0) 0 +QUBIT_COORDS(0, 1) 1 +QUBIT_COORDS(1, 0) 2 +QUBIT_COORDS(1, 1) 3 +QUBIT_COORDS(1, 2) 4 +QUBIT_COORDS(1, 3) 5 +QUBIT_COORDS(2, 0) 6 +QUBIT_COORDS(2, 1) 7 +QUBIT_COORDS(2, 2) 8 +QUBIT_COORDS(2, 3) 9 +QUBIT_COORDS(2, 4) 10 +QUBIT_COORDS(3, 0) 11 +QUBIT_COORDS(3, 1) 12 +QUBIT_COORDS(3, 2) 13 +QUBIT_COORDS(3, 3) 14 +QUBIT_COORDS(3, 4) 15 +QUBIT_COORDS(3, 5) 16 +QUBIT_COORDS(4, 0) 17 +QUBIT_COORDS(4, 1) 18 +QUBIT_COORDS(4, 2) 19 +QUBIT_COORDS(4, 3) 20 +QUBIT_COORDS(4, 4) 21 +QUBIT_COORDS(4, 5) 22 +QUBIT_COORDS(4, 6) 23 +QUBIT_COORDS(5, 0) 24 +QUBIT_COORDS(5, 1) 25 +QUBIT_COORDS(5, 2) 26 +QUBIT_COORDS(5, 3) 27 +QUBIT_COORDS(5, 4) 28 +QUBIT_COORDS(5, 5) 29 +QUBIT_COORDS(5, 6) 30 +QUBIT_COORDS(6, 0) 31 +QUBIT_COORDS(6, 1) 32 +QUBIT_COORDS(6, 2) 33 +QUBIT_COORDS(6, 3) 34 +QUBIT_COORDS(6, 4) 35 +QUBIT_COORDS(7, 0) 36 +QUBIT_COORDS(7, 1) 37 +QUBIT_COORDS(7, 2) 38 +QUBIT_COORDS(7, 3) 39 +QUBIT_COORDS(8, 0) 40 +QUBIT_COORDS(8, 1) 41 +RX 7 11 13 3 2 4 18 0 5 17 +R 12 8 6 +TICK +CX 7 12 11 6 13 8 +TICK +CX 7 8 11 12 +TICK +CX 7 6 13 12 +TICK +CX 2 6 4 8 18 12 +TICK +CX 6 2 8 4 12 18 +TICK +CX 3 4 17 18 +TICK +CX 3 2 18 17 +TICK +CX 4 3 +TICK +CX 2 3 +TICK +T_DAG 3 +TICK +CX 2 3 +TICK +CX 4 3 +TICK +CX 0 2 5 4 +TICK +CX 2 0 4 5 +TICK +RX 2 12 4 +R 6 18 8 9 +TICK +CX 2 6 4 8 5 9 12 18 +TICK +CX 2 0 6 11 8 13 9 5 12 7 +TICK +CX 2 3 6 7 8 9 12 13 +TICK +CX 4 3 8 7 12 11 18 17 +TICK +CX 3 4 7 8 11 12 17 18 +TICK +CX 0 2 7 12 11 6 13 8 +TICK +CX 3 2 7 6 9 8 13 12 +TICK +CX 2 6 4 8 12 18 +TICK +M 6 18 8 5 +MX 2 12 4 +DETECTOR(2, 0, 0) rec[-7] +DETECTOR(4, 1, 0) rec[-6] +DETECTOR(2, 2, 0) rec[-5] +DETECTOR(1, 3, 0) rec[-4] +DETECTOR(1, 0, 0) rec[-3] +DETECTOR(3, 1, 0) rec[-2] +DETECTOR(1, 2, 0) rec[-1] +TICK +RX 18 12 6 2 8 1 +TICK +T_DAG 0 3 7 9 11 13 17 +TICK +CX 1 0 2 3 6 7 8 9 12 11 18 17 +TICK +CX 3 1 7 8 12 18 +TICK +CX 7 3 12 13 +TICK +CX 7 12 +TICK +MX 7 +TICK +RX 7 +TICK +CX 7 12 +TICK +CX 7 3 12 13 +TICK +CX 3 1 7 8 12 18 +TICK +CX 1 0 2 3 6 7 8 9 12 11 18 17 +TICK +T 0 3 7 9 11 13 17 +TICK +MX 18 12 6 2 8 1 +DETECTOR(2.14286, 1, 1, -1, -9) rec[-9] rec[-8] rec[-7] +DETECTOR(4, 1, 2) rec[-6] +DETECTOR(3, 1, 2) rec[-5] +DETECTOR(2, 1, 2) rec[-4] rec[-7] +DETECTOR(1, 0, 2) rec[-3] +DETECTOR(2, 2, 2) rec[-2] +DETECTOR(0, 1, 2) rec[-1] +TICK +RX 26 33 36 16 28 27 +R 19 25 32 38 40 23 15 22 21 29 34 +TICK +CX 16 22 26 19 27 34 28 21 33 38 36 40 +TICK +CX 16 15 22 23 26 25 28 29 33 32 +TICK +CX 15 16 23 22 25 26 29 28 32 33 +TICK +M 26 33 28 22 16 +DETECTOR(5, 2, 4) rec[-5] +DETECTOR(6, 2, 4) rec[-4] +DETECTOR(5, 4, 4) rec[-3] +DETECTOR(4, 5, 4) rec[-2] +DETECTOR(3, 5, 4) rec[-1] +TICK +RX 37 28 26 24 16 14 12 4 2 +R 41 35 33 31 22 20 18 8 6 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +CX 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 +TICK +CX 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 +TICK +CX 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 +TICK +CX 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 +TICK +CX 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 +TICK +CX 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +M 41 35 33 31 22 20 18 8 6 +MX 37 28 26 24 16 14 12 4 2 +DETECTOR(1.25, 0.25, 5, -1, -9) rec[-30] rec[-1] +DETECTOR(1.5, 1.875, 5, -1, -9) rec[-30] rec[-2] +DETECTOR(1.75, 0.25, 5, -1, -9) rec[-10] +DETECTOR(2, 1.875, 5, -1, -9) rec[-11] +DETECTOR(3.075, 0.9125, 5, -1, -9) rec[-30] rec[-3] +DETECTOR(3.5, 4.875, 5, -1, -9) rec[-5] +DETECTOR(3.575, 0.9125, 5, -1, -9) rec[-12] +DETECTOR(4, 4.875, 5, -1, -9) rec[-14] +DETECTOR(5.25, 2, 5, -1, -9) rec[-7] +DETECTOR(5, 3.875, 5, -1, -9) rec[-8] +DETECTOR(5.75, 2, 5, -1, -9) rec[-16] +DETECTOR(5.5, 3.875, 5, -1, -9) rec[-17] +DETECTOR(7, 0.875, 5, -1, -9) rec[-9] +DETECTOR(7.5, 0.875, 5, -1, -9) rec[-18] +TICK +CZ rec[-6] 36 rec[-6] 40 rec[-4] 15 rec[-4] 23 +CX rec[-15] 36 rec[-15] 40 rec[-15] 38 rec[-15] 40 rec[-16] 36 rec[-16] 40 rec[-12] 15 rec[-12] 23 rec[-13] 0 rec[-13] 11 rec[-13] 23 rec[-14] 15 rec[-14] 23 +RX 37 28 26 24 16 14 12 4 2 +R 41 35 33 31 22 20 18 8 6 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +CX 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 +TICK +CX 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 +TICK +CX 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 +TICK +CX 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 +TICK +CX 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 +TICK +CX 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +M 41 35 33 31 22 20 18 8 6 +MX 37 28 26 24 16 14 12 4 2 +DETECTOR(1, 0, 6, -1, -9) rec[-19] rec[-1] +DETECTOR(1, 2, 6, -1, -9) rec[-20] rec[-2] +DETECTOR(2, 0, 6, -1, -9) rec[-29] rec[-28] rec[-10] +DETECTOR(2, 2, 6, -1, -9) rec[-28] rec[-11] +DETECTOR(3, 1, 6, -1, -9) rec[-21] rec[-3] +DETECTOR(3, 3, 6, -1, -9) rec[-4] +DETECTOR(3, 5, 6, -1, -9) rec[-23] rec[-5] +DETECTOR(4, 1, 6, -1, -9) rec[-12] +DETECTOR(4, 3, 6, -1, -9) rec[-13] +DETECTOR(4, 5, 6, -1, -9) rec[-14] +DETECTOR(5, 0, 6, -1, -9) rec[-6] +DETECTOR(5, 2, 6, -1, -9) rec[-25] rec[-7] +DETECTOR(5, 4, 6, -1, -9) rec[-26] rec[-8] +DETECTOR(6, 0, 6, -1, -9) rec[-15] +DETECTOR(6, 2, 6, -1, -9) rec[-35] rec[-16] +DETECTOR(6, 4, 6, -1, -9) rec[-17] +DETECTOR(7, 1, 6, -1, -9) rec[-27] rec[-9] +DETECTOR(8, 1, 6, -1, -9) rec[-18] +TICK +RX 37 28 26 24 16 14 12 4 2 +R 41 35 33 31 22 20 18 8 6 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +CX 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 +TICK +CX 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 +TICK +CX 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 +TICK +CX 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 +TICK +CX 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 +TICK +CX 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +M 41 35 33 31 22 20 18 8 6 +MX 37 28 26 24 16 14 12 4 2 +DETECTOR(1, 0, 7, -1, -9) rec[-19] rec[-1] +DETECTOR(1, 2, 7, -1, -9) rec[-20] rec[-2] +DETECTOR(2, 0, 7, -1, -9) rec[-29] rec[-28] rec[-10] +DETECTOR(2, 2, 7, -1, -9) rec[-28] rec[-11] +DETECTOR(3, 1, 7, -1, -9) rec[-21] rec[-3] +DETECTOR(3, 3, 7, -1, -9) rec[-22] rec[-4] +DETECTOR(3, 5, 7, -1, -9) rec[-23] rec[-5] +DETECTOR(4, 1, 7, -1, -9) rec[-31] rec[-12] +DETECTOR(4, 3, 7, -1, -9) rec[-32] rec[-30] rec[-13] +DETECTOR(4, 5, 7, -1, -9) rec[-31] rec[-14] +DETECTOR(5, 0, 7, -1, -9) rec[-24] rec[-6] +DETECTOR(5, 2, 7, -1, -9) rec[-25] rec[-7] +DETECTOR(5, 4, 7, -1, -9) rec[-26] rec[-8] +DETECTOR(6, 0, 7, -1, -9) rec[-34] rec[-33] rec[-15] +DETECTOR(6, 2, 7, -1, -9) rec[-35] rec[-33] rec[-16] +DETECTOR(6, 4, 7, -1, -9) rec[-34] rec[-17] +DETECTOR(7, 1, 7, -1, -9) rec[-27] rec[-9] +DETECTOR(8, 1, 7, -1, -9) rec[-18] +TICK +RX 24 31 2 6 8 10 20 22 39 1 12 18 37 33 14 26 28 30 41 +TICK +T_DAG 3 7 9 13 15 21 23 25 27 29 32 34 38 +T 0 11 17 19 36 40 +TICK +CX 1 0 2 3 6 7 8 13 10 15 12 11 14 9 18 17 20 27 22 29 24 25 26 19 28 21 30 23 31 32 33 34 37 36 39 38 41 40 +TICK +CX 3 1 14 15 29 30 33 38 37 41 +TICK +CX 7 3 13 14 26 33 28 29 32 37 +TICK +CX 12 13 25 32 27 28 +TICK +CX 12 7 26 27 +TICK +CX 18 12 25 26 +TICK +CX 25 18 +TICK +MX 25 +TICK +RX 25 +TICK +CX 25 18 +TICK +CX 18 12 25 26 +TICK +CX 12 7 26 27 +TICK +CX 12 13 25 32 27 28 +TICK +CX 7 3 13 14 26 33 28 29 32 37 +TICK +CX 3 1 14 15 29 30 33 38 37 41 +TICK +CX 1 0 2 3 6 7 8 13 10 15 12 11 14 9 18 17 20 27 22 29 24 25 26 19 28 21 30 23 31 32 33 34 37 36 39 38 41 40 +TICK +T 3 7 9 13 15 21 23 25 27 29 32 34 38 +T_DAG 0 11 17 19 36 40 +TICK +MX 20 22 8 10 2 6 24 31 39 1 12 18 37 33 14 26 28 30 41 +OBSERVABLE_INCLUDE(0) rec[-10] rec[-9] rec[-8] rec[-7] rec[-6] rec[-5] rec[-4] rec[-3] rec[-2] rec[-1] +DETECTOR(2.25889, 1.08534, 8, -1, -9) rec[-85] rec[-84] rec[-81] rec[-80] rec[-74] rec[-73] rec[-72] rec[-70] rec[-68] rec[-67] rec[-56] rec[-55] rec[-54] rec[-52] rec[-51] rec[-50] rec[-49] rec[-38] rec[-37] rec[-36] rec[-34] rec[-33] rec[-32] rec[-31] rec[-20] +DETECTOR(4, 3, 9) rec[-19] +DETECTOR(4, 5, 9) rec[-18] +DETECTOR(2, 2, 9) rec[-17] +DETECTOR(2, 4, 9) rec[-16] +DETECTOR(1, 0, 9) rec[-15] +DETECTOR(2, 0, 9) rec[-14] +DETECTOR(5, 1, 9) rec[-13] rec[-20] +DETECTOR(6, 0, 9) rec[-12] +DETECTOR(7, 3, 9) rec[-11] +DETECTOR(0, 1, 9) rec[-10] +DETECTOR(3, 1, 9) rec[-9] +DETECTOR(4, 1, 9) rec[-8] +DETECTOR(7, 1, 9) rec[-7] +DETECTOR(6, 2, 9) rec[-6] +DETECTOR(3, 3, 9) rec[-5] +DETECTOR(5, 2, 9) rec[-4] +DETECTOR(5, 4, 9) rec[-3] +DETECTOR(5, 6, 9) rec[-2] +DETECTOR(8, 1, 9) rec[-1] +TICK +T 3 7 9 13 15 21 23 25 27 29 32 34 38 +T_DAG 0 11 17 19 36 40 +MPP Y0*Y3*Y7*Y9*Y11*Y13*Y15*Y17*Y19*Y21*Y23*Y25*Y27*Y29*Y32*Y34*Y36*Y38*Y40 +T_DAG 3 7 9 13 15 21 23 25 27 29 32 34 38 +T 0 11 17 19 36 40 +MPP X0*X3*X7*X11 X9*X13*X15*X19*X21*X27 X17*X25*X32*X36 Z0*Z3*Z7*Z11 Z9*Z13*Z15*Z19*Z21*Z27 Z17*Z25*Z32*Z36 X3*X7*X9*X13 X15*X21*X23*X29 X19*X25*X27*X32*X34*X38 Z3*Z7*Z9*Z13 Z15*Z21*Z23*Z29 Z19*Z25*Z27*Z32*Z34*Z38 X7*X11*X13*X17*X19*X25 X21*X27*X29*X34 X32*X36*X38*X40 Z7*Z11*Z13*Z17*Z19*Z25 Z21*Z27*Z29*Z34 Z32*Z36*Z38*Z40 +OBSERVABLE_INCLUDE(0) rec[-19] +DETECTOR(0.625, 0.125, 11, -1, -9) rec[-40] rec[-18] +DETECTOR(0.875, 0.125, 11, -1, -9) rec[-50] rec[-49] rec[-15] +DETECTOR(1.25, 1.4375, 11, -1, -9) rec[-41] rec[-12] +DETECTOR(1.5, 1.4375, 11, -1, -9) rec[-49] rec[-9] +DETECTOR(2.625, 1, 11, -1, -9) rec[-42] rec[-39] rec[-6] +DETECTOR(2.875, 1, 11, -1, -9) rec[-52] rec[-3] +DETECTOR(2.625, 3, 11, -1, -9) rec[-43] rec[-17] +DETECTOR(2.875, 3, 11, -1, -9) rec[-53] rec[-51] rec[-14] +DETECTOR(3.25, 4.4375, 11, -1, -9) rec[-44] rec[-11] +DETECTOR(3.5, 4.4375, 11, -1, -9) rec[-52] rec[-8] +DETECTOR(4.625, 0.125, 11, -1, -9) rec[-45] rec[-39] rec[-16] +DETECTOR(4.875, 0.125, 11, -1, -9) rec[-55] rec[-54] rec[-13] +DETECTOR(4.625, 2, 11, -1, -9) rec[-46] rec[-39] rec[-10] +DETECTOR(4.875, 2, 11, -1, -9) rec[-56] rec[-54] rec[-7] +DETECTOR(4.5, 3.9375, 11, -1, -9) rec[-47] rec[-5] +DETECTOR(4.75, 3.9375, 11, -1, -9) rec[-55] rec[-2] +DETECTOR(6.5, 0.9375, 11, -1, -9) rec[-48] rec[-4] +DETECTOR(6.75, 0.9375, 11, -1, -9) rec[-1] diff --git a/test/data/determined/clifft_d5_T_rule1.stim b/test/data/determined/clifft_d5_T_rule1.stim new file mode 100644 index 00000000..1838ffab --- /dev/null +++ b/test/data/determined/clifft_d5_T_rule1.stim @@ -0,0 +1,353 @@ +QUBIT_COORDS(0, 0) 0 +QUBIT_COORDS(0, 1) 1 +QUBIT_COORDS(1, 0) 2 +QUBIT_COORDS(1, 1) 3 +QUBIT_COORDS(1, 2) 4 +QUBIT_COORDS(1, 3) 5 +QUBIT_COORDS(2, 0) 6 +QUBIT_COORDS(2, 1) 7 +QUBIT_COORDS(2, 2) 8 +QUBIT_COORDS(2, 3) 9 +QUBIT_COORDS(2, 4) 10 +QUBIT_COORDS(3, 0) 11 +QUBIT_COORDS(3, 1) 12 +QUBIT_COORDS(3, 2) 13 +QUBIT_COORDS(3, 3) 14 +QUBIT_COORDS(3, 4) 15 +QUBIT_COORDS(3, 5) 16 +QUBIT_COORDS(4, 0) 17 +QUBIT_COORDS(4, 1) 18 +QUBIT_COORDS(4, 2) 19 +QUBIT_COORDS(4, 3) 20 +QUBIT_COORDS(4, 4) 21 +QUBIT_COORDS(4, 5) 22 +QUBIT_COORDS(4, 6) 23 +QUBIT_COORDS(5, 0) 24 +QUBIT_COORDS(5, 1) 25 +QUBIT_COORDS(5, 2) 26 +QUBIT_COORDS(5, 3) 27 +QUBIT_COORDS(5, 4) 28 +QUBIT_COORDS(5, 5) 29 +QUBIT_COORDS(5, 6) 30 +QUBIT_COORDS(6, 0) 31 +QUBIT_COORDS(6, 1) 32 +QUBIT_COORDS(6, 2) 33 +QUBIT_COORDS(6, 3) 34 +QUBIT_COORDS(6, 4) 35 +QUBIT_COORDS(7, 0) 36 +QUBIT_COORDS(7, 1) 37 +QUBIT_COORDS(7, 2) 38 +QUBIT_COORDS(7, 3) 39 +QUBIT_COORDS(8, 0) 40 +QUBIT_COORDS(8, 1) 41 +RX 7 11 13 3 2 4 18 0 5 17 +R 12 8 6 +TICK +CX 7 12 11 6 13 8 +TICK +CX 7 8 11 12 +TICK +CX 7 6 13 12 +TICK +CX 2 6 4 8 18 12 +TICK +CX 6 2 8 4 12 18 +TICK +CX 3 4 17 18 +TICK +CX 3 2 18 17 +TICK +CX 4 3 +TICK +CX 2 3 +TICK +T_DAG 3 +TICK +CX 2 3 +TICK +CX 4 3 +TICK +CX 0 2 5 4 +TICK +CX 2 0 4 5 +TICK +RX 2 12 4 +R 6 18 8 9 +TICK +CX 2 6 4 8 5 9 12 18 +TICK +CX 2 0 6 11 8 13 9 5 12 7 +TICK +CX 2 3 6 7 8 9 12 13 +TICK +CX 4 3 8 7 12 11 18 17 +TICK +CX 3 4 7 8 11 12 17 18 +TICK +CX 0 2 7 12 11 6 13 8 +TICK +CX 3 2 7 6 9 8 13 12 +TICK +CX 2 6 4 8 12 18 +TICK +M 6 18 8 5 +MX 2 12 4 +DETECTOR(2, 0, 0) rec[-7] +DETECTOR(4, 1, 0) rec[-6] +DETECTOR(2, 2, 0) rec[-5] +DETECTOR(1, 3, 0) rec[-4] +DETECTOR(1, 0, 0) rec[-3] +DETECTOR(3, 1, 0) rec[-2] +DETECTOR(1, 2, 0) rec[-1] +TICK +RX 18 12 6 2 8 1 +TICK +T_DAG 0 3 7 9 11 13 17 +TICK +CX 1 0 2 3 6 7 8 9 12 11 18 17 +TICK +CX 3 1 7 8 12 18 +TICK +CX 7 3 12 13 +TICK +CX 7 12 +TICK +MX 7 +TICK +RX 7 +TICK +CX 7 12 +TICK +CX 7 3 12 13 +TICK +CX 3 1 7 8 12 18 +TICK +CX 1 0 2 3 6 7 8 9 12 11 18 17 +TICK +T 0 3 7 9 11 13 17 +TICK +MX 18 12 6 2 8 1 +DETECTOR(2.14286, 1, 1, -1, -9) rec[-9] rec[-8] rec[-7] +DETECTOR(4, 1, 2) rec[-6] +DETECTOR(3, 1, 2) rec[-5] +DETECTOR(2, 1, 2) rec[-4] rec[-7] +DETECTOR(1, 0, 2) rec[-3] +DETECTOR(2, 2, 2) rec[-2] +DETECTOR(0, 1, 2) rec[-1] +TICK +RX 26 33 36 16 28 27 +R 19 25 32 38 40 23 15 22 21 29 34 +TICK +CX 16 22 26 19 27 34 28 21 33 38 36 40 +TICK +CX 16 15 22 23 26 25 28 29 33 32 +TICK +CX 15 16 23 22 25 26 29 28 32 33 +TICK +M 26 33 28 22 16 +DETECTOR(5, 2, 4) rec[-5] +DETECTOR(6, 2, 4) rec[-4] +DETECTOR(5, 4, 4) rec[-3] +DETECTOR(4, 5, 4) rec[-2] +DETECTOR(3, 5, 4) rec[-1] +TICK +RX 37 28 26 24 16 14 12 4 2 +R 41 35 33 31 22 20 18 8 6 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +CX 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 +TICK +CX 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 +TICK +CX 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 +TICK +CX 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 +TICK +CX 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 +TICK +CX 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +M 41 35 33 31 22 20 18 8 6 +MX 37 28 26 24 16 14 12 4 2 +DETECTOR(1.25, 0.25, 5, -1, -9) rec[-30] rec[-1] +DETECTOR(1.5, 1.875, 5, -1, -9) rec[-30] rec[-2] +DETECTOR(1.75, 0.25, 5, -1, -9) rec[-10] +DETECTOR(2, 1.875, 5, -1, -9) rec[-11] +DETECTOR(3.075, 0.9125, 5, -1, -9) rec[-30] rec[-3] +DETECTOR(3.5, 4.875, 5, -1, -9) rec[-5] +DETECTOR(3.575, 0.9125, 5, -1, -9) rec[-12] +DETECTOR(4, 4.875, 5, -1, -9) rec[-14] +DETECTOR(5.25, 2, 5, -1, -9) rec[-7] +DETECTOR(5, 3.875, 5, -1, -9) rec[-8] +DETECTOR(5.75, 2, 5, -1, -9) rec[-16] +DETECTOR(5.5, 3.875, 5, -1, -9) rec[-17] +DETECTOR(7, 0.875, 5, -1, -9) rec[-9] +DETECTOR(7.5, 0.875, 5, -1, -9) rec[-18] +TICK +RX 37 28 26 24 16 14 12 4 2 +R 41 35 33 31 22 20 18 8 6 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +CX 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 +TICK +CX 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 +TICK +CX 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 +TICK +CX 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 +TICK +CX 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 +TICK +CX 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +M 41 35 33 31 22 20 18 8 6 +MX 37 28 26 24 16 14 12 4 2 +DETECTOR(1, 0, 6, -1, -9) rec[-19] rec[-1] +DETECTOR(1, 2, 6, -1, -9) rec[-20] rec[-2] +DETECTOR(2, 0, 6, -1, -9) rec[-29] rec[-28] rec[-10] +DETECTOR(2, 2, 6, -1, -9) rec[-28] rec[-11] +DETECTOR(3, 1, 6, -1, -9) rec[-21] rec[-3] +DETECTOR(3, 3, 6, -1, -9) rec[-22] rec[-4] +DETECTOR(3, 5, 6, -1, -9) rec[-23] rec[-5] +DETECTOR(4, 1, 6, -1, -9) rec[-31] rec[-12] +DETECTOR(4, 3, 6, -1, -9) rec[-32] rec[-30] rec[-13] +DETECTOR(4, 5, 6, -1, -9) rec[-31] rec[-14] +DETECTOR(5, 0, 6, -1, -9) rec[-24] rec[-6] +DETECTOR(5, 2, 6, -1, -9) rec[-25] rec[-7] +DETECTOR(5, 4, 6, -1, -9) rec[-26] rec[-8] +DETECTOR(6, 0, 6, -1, -9) rec[-34] rec[-33] rec[-15] +DETECTOR(6, 2, 6, -1, -9) rec[-35] rec[-33] rec[-16] +DETECTOR(6, 4, 6, -1, -9) rec[-34] rec[-17] +DETECTOR(7, 1, 6, -1, -9) rec[-27] rec[-9] +DETECTOR(8, 1, 6, -1, -9) rec[-18] +TICK +RX 37 28 26 24 16 14 12 4 2 +R 41 35 33 31 22 20 18 8 6 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +CX 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 +TICK +CX 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 +TICK +CX 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 +TICK +CX 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 +TICK +CX 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 +TICK +CX 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +M 41 35 33 31 22 20 18 8 6 +MX 37 28 26 24 16 14 12 4 2 +DETECTOR(1, 0, 7, -1, -9) rec[-19] rec[-1] +DETECTOR(1, 2, 7, -1, -9) rec[-20] rec[-2] +DETECTOR(2, 0, 7, -1, -9) rec[-29] rec[-28] rec[-10] +DETECTOR(2, 2, 7, -1, -9) rec[-28] rec[-11] +DETECTOR(3, 1, 7, -1, -9) rec[-21] rec[-3] +DETECTOR(3, 3, 7, -1, -9) rec[-22] rec[-4] +DETECTOR(3, 5, 7, -1, -9) rec[-23] rec[-5] +DETECTOR(4, 1, 7, -1, -9) rec[-31] rec[-12] +DETECTOR(4, 3, 7, -1, -9) rec[-32] rec[-30] rec[-13] +DETECTOR(4, 5, 7, -1, -9) rec[-31] rec[-14] +DETECTOR(5, 0, 7, -1, -9) rec[-24] rec[-6] +DETECTOR(5, 2, 7, -1, -9) rec[-25] rec[-7] +DETECTOR(5, 4, 7, -1, -9) rec[-26] rec[-8] +DETECTOR(6, 0, 7, -1, -9) rec[-34] rec[-33] rec[-15] +DETECTOR(6, 2, 7, -1, -9) rec[-35] rec[-33] rec[-16] +DETECTOR(6, 4, 7, -1, -9) rec[-34] rec[-17] +DETECTOR(7, 1, 7, -1, -9) rec[-27] rec[-9] +DETECTOR(8, 1, 7, -1, -9) rec[-18] +TICK +RX 24 31 2 6 8 10 20 22 39 1 12 18 37 33 14 26 28 30 41 +TICK +T_DAG 0 3 7 9 11 13 15 17 19 21 23 25 27 29 32 34 36 38 40 +TICK +CX 1 0 2 3 6 7 8 13 10 15 12 11 14 9 18 17 20 27 22 29 24 25 26 19 28 21 30 23 31 32 33 34 37 36 39 38 41 40 +TICK +CX 3 1 14 15 29 30 33 38 37 41 +TICK +CX 7 3 13 14 26 33 28 29 32 37 +TICK +CX 12 13 25 32 27 28 +TICK +CX 12 7 26 27 +TICK +CX 18 12 25 26 +TICK +CX 25 18 +TICK +MX 25 +TICK +RX 25 +TICK +CX 25 18 +TICK +CX 18 12 25 26 +TICK +CX 12 7 26 27 +TICK +CX 12 13 25 32 27 28 +TICK +CX 7 3 13 14 26 33 28 29 32 37 +TICK +CX 3 1 14 15 29 30 33 38 37 41 +TICK +CX 1 0 2 3 6 7 8 13 10 15 12 11 14 9 18 17 20 27 22 29 24 25 26 19 28 21 30 23 31 32 33 34 37 36 39 38 41 40 +TICK +T 0 3 7 9 11 13 15 17 19 21 23 25 27 29 32 34 36 38 40 +TICK +MX 20 22 8 10 2 6 24 31 39 1 12 18 37 33 14 26 28 30 41 +OBSERVABLE_INCLUDE(0) rec[-10] rec[-9] rec[-8] rec[-7] rec[-6] rec[-5] rec[-4] rec[-3] rec[-2] rec[-1] +DETECTOR(2.25889, 1.08534, 8, -1, -9) rec[-85] rec[-84] rec[-81] rec[-80] rec[-74] rec[-73] rec[-72] rec[-70] rec[-69] rec[-68] rec[-67] rec[-56] rec[-55] rec[-54] rec[-52] rec[-51] rec[-50] rec[-49] rec[-38] rec[-37] rec[-36] rec[-34] rec[-33] rec[-32] rec[-31] rec[-20] +DETECTOR(4, 3, 9) rec[-19] +DETECTOR(4, 5, 9) rec[-18] +DETECTOR(2, 2, 9) rec[-17] +DETECTOR(2, 4, 9) rec[-16] +DETECTOR(1, 0, 9) rec[-15] +DETECTOR(2, 0, 9) rec[-14] +DETECTOR(5, 1, 9) rec[-13] rec[-20] +DETECTOR(6, 0, 9) rec[-12] +DETECTOR(7, 3, 9) rec[-11] +DETECTOR(0, 1, 9) rec[-10] +DETECTOR(3, 1, 9) rec[-9] +DETECTOR(4, 1, 9) rec[-8] +DETECTOR(7, 1, 9) rec[-7] +DETECTOR(6, 2, 9) rec[-6] +DETECTOR(3, 3, 9) rec[-5] +DETECTOR(5, 2, 9) rec[-4] +DETECTOR(5, 4, 9) rec[-3] +DETECTOR(5, 6, 9) rec[-2] +DETECTOR(8, 1, 9) rec[-1] +TICK +T 0 3 7 9 11 13 15 17 19 21 23 25 27 29 32 34 36 38 40 +MPP Y0*Y3*Y7*Y9*Y11*Y13*Y15*Y17*Y19*Y21*Y23*Y25*Y27*Y29*Y32*Y34*Y36*Y38*Y40 +T_DAG 0 3 7 9 11 13 15 17 19 21 23 25 27 29 32 34 36 38 40 +MPP X0*X3*X7*X11 X9*X13*X15*X19*X21*X27 X17*X25*X32*X36 Z0*Z3*Z7*Z11 Z9*Z13*Z15*Z19*Z21*Z27 Z17*Z25*Z32*Z36 X3*X7*X9*X13 X15*X21*X23*X29 X19*X25*X27*X32*X34*X38 Z3*Z7*Z9*Z13 Z15*Z21*Z23*Z29 Z19*Z25*Z27*Z32*Z34*Z38 X7*X11*X13*X17*X19*X25 X21*X27*X29*X34 X32*X36*X38*X40 Z7*Z11*Z13*Z17*Z19*Z25 Z21*Z27*Z29*Z34 Z32*Z36*Z38*Z40 +OBSERVABLE_INCLUDE(0) rec[-19] +DETECTOR(0.625, 0.125, 11, -1, -9) rec[-40] rec[-18] +DETECTOR(0.875, 0.125, 11, -1, -9) rec[-50] rec[-49] rec[-15] +DETECTOR(1.25, 1.4375, 11, -1, -9) rec[-41] rec[-12] +DETECTOR(1.5, 1.4375, 11, -1, -9) rec[-49] rec[-9] +DETECTOR(2.625, 1, 11, -1, -9) rec[-42] rec[-39] rec[-6] +DETECTOR(2.875, 1, 11, -1, -9) rec[-52] rec[-3] +DETECTOR(2.625, 3, 11, -1, -9) rec[-43] rec[-17] +DETECTOR(2.875, 3, 11, -1, -9) rec[-53] rec[-51] rec[-14] +DETECTOR(3.25, 4.4375, 11, -1, -9) rec[-44] rec[-11] +DETECTOR(3.5, 4.4375, 11, -1, -9) rec[-52] rec[-8] +DETECTOR(4.625, 0.125, 11, -1, -9) rec[-45] rec[-39] rec[-16] +DETECTOR(4.875, 0.125, 11, -1, -9) rec[-55] rec[-54] rec[-13] +DETECTOR(4.625, 2, 11, -1, -9) rec[-46] rec[-39] rec[-10] +DETECTOR(4.875, 2, 11, -1, -9) rec[-56] rec[-54] rec[-7] +DETECTOR(4.5, 3.9375, 11, -1, -9) rec[-47] rec[-5] +DETECTOR(4.75, 3.9375, 11, -1, -9) rec[-55] rec[-2] +DETECTOR(6.5, 0.9375, 11, -1, -9) rec[-48] rec[-4] +DETECTOR(6.75, 0.9375, 11, -1, -9) rec[-1] diff --git a/test/data/determined/clifft_d5_T_rule12.stim b/test/data/determined/clifft_d5_T_rule12.stim new file mode 100644 index 00000000..53083ec1 --- /dev/null +++ b/test/data/determined/clifft_d5_T_rule12.stim @@ -0,0 +1,357 @@ +QUBIT_COORDS(0, 0) 0 +QUBIT_COORDS(0, 1) 1 +QUBIT_COORDS(1, 0) 2 +QUBIT_COORDS(1, 1) 3 +QUBIT_COORDS(1, 2) 4 +QUBIT_COORDS(1, 3) 5 +QUBIT_COORDS(2, 0) 6 +QUBIT_COORDS(2, 1) 7 +QUBIT_COORDS(2, 2) 8 +QUBIT_COORDS(2, 3) 9 +QUBIT_COORDS(2, 4) 10 +QUBIT_COORDS(3, 0) 11 +QUBIT_COORDS(3, 1) 12 +QUBIT_COORDS(3, 2) 13 +QUBIT_COORDS(3, 3) 14 +QUBIT_COORDS(3, 4) 15 +QUBIT_COORDS(3, 5) 16 +QUBIT_COORDS(4, 0) 17 +QUBIT_COORDS(4, 1) 18 +QUBIT_COORDS(4, 2) 19 +QUBIT_COORDS(4, 3) 20 +QUBIT_COORDS(4, 4) 21 +QUBIT_COORDS(4, 5) 22 +QUBIT_COORDS(4, 6) 23 +QUBIT_COORDS(5, 0) 24 +QUBIT_COORDS(5, 1) 25 +QUBIT_COORDS(5, 2) 26 +QUBIT_COORDS(5, 3) 27 +QUBIT_COORDS(5, 4) 28 +QUBIT_COORDS(5, 5) 29 +QUBIT_COORDS(5, 6) 30 +QUBIT_COORDS(6, 0) 31 +QUBIT_COORDS(6, 1) 32 +QUBIT_COORDS(6, 2) 33 +QUBIT_COORDS(6, 3) 34 +QUBIT_COORDS(6, 4) 35 +QUBIT_COORDS(7, 0) 36 +QUBIT_COORDS(7, 1) 37 +QUBIT_COORDS(7, 2) 38 +QUBIT_COORDS(7, 3) 39 +QUBIT_COORDS(8, 0) 40 +QUBIT_COORDS(8, 1) 41 +RX 7 11 13 3 2 4 18 0 5 17 +R 12 8 6 +TICK +CX 7 12 11 6 13 8 +TICK +CX 7 8 11 12 +TICK +CX 7 6 13 12 +TICK +CX 2 6 4 8 18 12 +TICK +CX 6 2 8 4 12 18 +TICK +CX 3 4 17 18 +TICK +CX 3 2 18 17 +TICK +CX 4 3 +TICK +CX 2 3 +TICK +T_DAG 3 +TICK +CX 2 3 +TICK +CX 4 3 +TICK +CX 0 2 5 4 +TICK +CX 2 0 4 5 +TICK +RX 2 12 4 +R 6 18 8 9 +TICK +CX 2 6 4 8 5 9 12 18 +TICK +CX 2 0 6 11 8 13 9 5 12 7 +TICK +CX 2 3 6 7 8 9 12 13 +TICK +CX 4 3 8 7 12 11 18 17 +TICK +CX 3 4 7 8 11 12 17 18 +TICK +CX 0 2 7 12 11 6 13 8 +TICK +CX 3 2 7 6 9 8 13 12 +TICK +CX 2 6 4 8 12 18 +TICK +M 6 18 8 5 +MX 2 12 4 +DETECTOR(2, 0, 0) rec[-7] +DETECTOR(4, 1, 0) rec[-6] +DETECTOR(2, 2, 0) rec[-5] +DETECTOR(1, 3, 0) rec[-4] +DETECTOR(1, 0, 0) rec[-3] +DETECTOR(3, 1, 0) rec[-2] +DETECTOR(1, 2, 0) rec[-1] +TICK +RX 18 12 6 2 8 1 +TICK +T_DAG 0 3 7 9 11 13 17 +TICK +CX 1 0 2 3 6 7 8 9 12 11 18 17 +TICK +CX 3 1 7 8 12 18 +TICK +CX 7 3 12 13 +TICK +CX 7 12 +TICK +MX 7 +TICK +RX 7 +TICK +CX 7 12 +TICK +CX 7 3 12 13 +TICK +CX 3 1 7 8 12 18 +TICK +CX 1 0 2 3 6 7 8 9 12 11 18 17 +TICK +T 0 3 7 9 11 13 17 +TICK +MX 18 12 6 2 8 1 +DETECTOR(2.14286, 1, 1, -1, -9) rec[-9] rec[-8] rec[-7] +DETECTOR(4, 1, 2) rec[-6] +DETECTOR(3, 1, 2) rec[-5] +DETECTOR(2, 1, 2) rec[-4] rec[-7] +DETECTOR(1, 0, 2) rec[-3] +DETECTOR(2, 2, 2) rec[-2] +DETECTOR(0, 1, 2) rec[-1] +TICK +RX 26 33 36 16 28 27 +R 19 25 32 38 40 23 15 22 21 29 34 +TICK +CX 16 22 26 19 27 34 28 21 33 38 36 40 +TICK +CX 16 15 22 23 26 25 28 29 33 32 +TICK +CX 15 16 23 22 25 26 29 28 32 33 +TICK +M 26 33 28 22 16 +DETECTOR(5, 2, 4) rec[-5] +DETECTOR(6, 2, 4) rec[-4] +DETECTOR(5, 4, 4) rec[-3] +DETECTOR(4, 5, 4) rec[-2] +DETECTOR(3, 5, 4) rec[-1] +TICK +RX 37 28 26 24 16 14 12 4 2 +R 41 35 33 31 22 20 18 8 6 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +CX 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 +TICK +CX 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 +TICK +CX 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 +TICK +CX 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 +TICK +CX 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 +TICK +CX 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +M 41 35 33 31 22 20 18 8 6 +MX 37 28 26 24 16 14 12 4 2 +DETECTOR(1.25, 0.25, 5, -1, -9) rec[-30] rec[-1] +DETECTOR(1.5, 1.875, 5, -1, -9) rec[-30] rec[-2] +DETECTOR(1.75, 0.25, 5, -1, -9) rec[-10] +DETECTOR(2, 1.875, 5, -1, -9) rec[-11] +DETECTOR(3.075, 0.9125, 5, -1, -9) rec[-30] rec[-3] +DETECTOR(3.5, 4.875, 5, -1, -9) rec[-5] +DETECTOR(3.575, 0.9125, 5, -1, -9) rec[-12] +DETECTOR(4, 4.875, 5, -1, -9) rec[-14] +DETECTOR(5.25, 2, 5, -1, -9) rec[-7] +DETECTOR(5, 3.875, 5, -1, -9) rec[-8] +DETECTOR(5.75, 2, 5, -1, -9) rec[-16] +DETECTOR(5.5, 3.875, 5, -1, -9) rec[-17] +DETECTOR(7, 0.875, 5, -1, -9) rec[-9] +DETECTOR(7.5, 0.875, 5, -1, -9) rec[-18] +TICK +RX 37 28 26 24 16 14 12 4 2 +R 41 35 33 31 22 20 18 8 6 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +CX 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 +TICK +CX 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 +TICK +CX 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 +TICK +CX 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 +TICK +CX 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 +TICK +CX 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +M 41 35 33 31 22 20 18 8 6 +MX 37 28 26 24 16 14 12 4 2 +DETECTOR(1, 0, 6, -1, -9) rec[-19] rec[-1] +DETECTOR(1, 2, 6, -1, -9) rec[-20] rec[-2] +DETECTOR(2, 0, 6, -1, -9) rec[-29] rec[-28] rec[-10] +DETECTOR(2, 2, 6, -1, -9) rec[-28] rec[-11] +DETECTOR(3, 1, 6, -1, -9) rec[-21] rec[-3] +DETECTOR(3, 3, 6, -1, -9) rec[-22] rec[-4] +DETECTOR(3, 5, 6, -1, -9) rec[-23] rec[-5] +DETECTOR(4, 1, 6, -1, -9) rec[-31] rec[-12] +DETECTOR(4, 3, 6, -1, -9) rec[-32] rec[-30] rec[-13] +DETECTOR(4, 5, 6, -1, -9) rec[-31] rec[-14] +DETECTOR(5, 0, 6, -1, -9) rec[-24] rec[-6] +DETECTOR(5, 2, 6, -1, -9) rec[-25] rec[-7] +DETECTOR(5, 4, 6, -1, -9) rec[-26] rec[-8] +DETECTOR(6, 0, 6, -1, -9) rec[-34] rec[-33] rec[-15] +DETECTOR(6, 2, 6, -1, -9) rec[-35] rec[-33] rec[-16] +DETECTOR(6, 4, 6, -1, -9) rec[-34] rec[-17] +DETECTOR(7, 1, 6, -1, -9) rec[-27] rec[-9] +DETECTOR(8, 1, 6, -1, -9) rec[-18] +TICK +RX 37 28 26 24 16 14 12 4 2 +R 41 35 33 31 22 20 18 8 6 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +CX 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 +TICK +CX 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 +TICK +CX 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 +TICK +CX 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 +TICK +CX 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 +TICK +CX 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +M 41 35 33 31 22 20 18 8 6 +MX 37 28 26 24 16 14 12 4 2 +DETECTOR(1, 0, 7, -1, -9) rec[-19] rec[-1] +DETECTOR(1, 2, 7, -1, -9) rec[-20] rec[-2] +DETECTOR(2, 0, 7, -1, -9) rec[-29] rec[-28] rec[-10] +DETECTOR(2, 2, 7, -1, -9) rec[-28] rec[-11] +DETECTOR(3, 1, 7, -1, -9) rec[-21] rec[-3] +DETECTOR(3, 3, 7, -1, -9) rec[-22] rec[-4] +DETECTOR(3, 5, 7, -1, -9) rec[-23] rec[-5] +DETECTOR(4, 1, 7, -1, -9) rec[-31] rec[-12] +DETECTOR(4, 3, 7, -1, -9) rec[-32] rec[-30] rec[-13] +DETECTOR(4, 5, 7, -1, -9) rec[-31] rec[-14] +DETECTOR(5, 0, 7, -1, -9) rec[-24] rec[-6] +DETECTOR(5, 2, 7, -1, -9) rec[-25] rec[-7] +DETECTOR(5, 4, 7, -1, -9) rec[-26] rec[-8] +DETECTOR(6, 0, 7, -1, -9) rec[-34] rec[-33] rec[-15] +DETECTOR(6, 2, 7, -1, -9) rec[-35] rec[-33] rec[-16] +DETECTOR(6, 4, 7, -1, -9) rec[-34] rec[-17] +DETECTOR(7, 1, 7, -1, -9) rec[-27] rec[-9] +DETECTOR(8, 1, 7, -1, -9) rec[-18] +TICK +RX 24 31 2 6 8 10 20 22 39 1 12 18 37 33 14 26 28 30 41 +TICK +T_DAG 3 7 9 13 15 21 23 25 27 29 32 34 38 +T 0 11 17 19 36 40 +TICK +CX 1 0 2 3 6 7 8 13 10 15 12 11 14 9 18 17 20 27 22 29 24 25 26 19 28 21 30 23 31 32 33 34 37 36 39 38 41 40 +TICK +CX 3 1 14 15 29 30 33 38 37 41 +TICK +CX 7 3 13 14 26 33 28 29 32 37 +TICK +CX 12 13 25 32 27 28 +TICK +CX 12 7 26 27 +TICK +CX 18 12 25 26 +TICK +CX 25 18 +TICK +MX 25 +TICK +RX 25 +TICK +CX 25 18 +TICK +CX 18 12 25 26 +TICK +CX 12 7 26 27 +TICK +CX 12 13 25 32 27 28 +TICK +CX 7 3 13 14 26 33 28 29 32 37 +TICK +CX 3 1 14 15 29 30 33 38 37 41 +TICK +CX 1 0 2 3 6 7 8 13 10 15 12 11 14 9 18 17 20 27 22 29 24 25 26 19 28 21 30 23 31 32 33 34 37 36 39 38 41 40 +TICK +T 3 7 9 13 15 21 23 25 27 29 32 34 38 +T_DAG 0 11 17 19 36 40 +TICK +MX 20 22 8 10 2 6 24 31 39 1 12 18 37 33 14 26 28 30 41 +OBSERVABLE_INCLUDE(0) rec[-10] rec[-9] rec[-8] rec[-7] rec[-6] rec[-5] rec[-4] rec[-3] rec[-2] rec[-1] +DETECTOR(2.25889, 1.08534, 8, -1, -9) rec[-85] rec[-84] rec[-81] rec[-80] rec[-74] rec[-73] rec[-72] rec[-70] rec[-69] rec[-68] rec[-67] rec[-56] rec[-55] rec[-54] rec[-52] rec[-51] rec[-50] rec[-49] rec[-38] rec[-37] rec[-36] rec[-34] rec[-33] rec[-32] rec[-31] rec[-20] +DETECTOR(4, 3, 9) rec[-19] +DETECTOR(4, 5, 9) rec[-18] +DETECTOR(2, 2, 9) rec[-17] +DETECTOR(2, 4, 9) rec[-16] +DETECTOR(1, 0, 9) rec[-15] +DETECTOR(2, 0, 9) rec[-14] +DETECTOR(5, 1, 9) rec[-13] rec[-20] +DETECTOR(6, 0, 9) rec[-12] +DETECTOR(7, 3, 9) rec[-11] +DETECTOR(0, 1, 9) rec[-10] +DETECTOR(3, 1, 9) rec[-9] +DETECTOR(4, 1, 9) rec[-8] +DETECTOR(7, 1, 9) rec[-7] +DETECTOR(6, 2, 9) rec[-6] +DETECTOR(3, 3, 9) rec[-5] +DETECTOR(5, 2, 9) rec[-4] +DETECTOR(5, 4, 9) rec[-3] +DETECTOR(5, 6, 9) rec[-2] +DETECTOR(8, 1, 9) rec[-1] +TICK +T 3 7 9 13 15 21 23 25 27 29 32 34 38 +T_DAG 0 11 17 19 36 40 +MPP Y0*Y3*Y7*Y9*Y11*Y13*Y15*Y17*Y19*Y21*Y23*Y25*Y27*Y29*Y32*Y34*Y36*Y38*Y40 +T_DAG 3 7 9 13 15 21 23 25 27 29 32 34 38 +T 0 11 17 19 36 40 +MPP X0*X3*X7*X11 X9*X13*X15*X19*X21*X27 X17*X25*X32*X36 Z0*Z3*Z7*Z11 Z9*Z13*Z15*Z19*Z21*Z27 Z17*Z25*Z32*Z36 X3*X7*X9*X13 X15*X21*X23*X29 X19*X25*X27*X32*X34*X38 Z3*Z7*Z9*Z13 Z15*Z21*Z23*Z29 Z19*Z25*Z27*Z32*Z34*Z38 X7*X11*X13*X17*X19*X25 X21*X27*X29*X34 X32*X36*X38*X40 Z7*Z11*Z13*Z17*Z19*Z25 Z21*Z27*Z29*Z34 Z32*Z36*Z38*Z40 +OBSERVABLE_INCLUDE(0) rec[-19] +DETECTOR(0.625, 0.125, 11, -1, -9) rec[-40] rec[-18] +DETECTOR(0.875, 0.125, 11, -1, -9) rec[-50] rec[-49] rec[-15] +DETECTOR(1.25, 1.4375, 11, -1, -9) rec[-41] rec[-12] +DETECTOR(1.5, 1.4375, 11, -1, -9) rec[-49] rec[-9] +DETECTOR(2.625, 1, 11, -1, -9) rec[-42] rec[-39] rec[-6] +DETECTOR(2.875, 1, 11, -1, -9) rec[-52] rec[-3] +DETECTOR(2.625, 3, 11, -1, -9) rec[-43] rec[-17] +DETECTOR(2.875, 3, 11, -1, -9) rec[-53] rec[-51] rec[-14] +DETECTOR(3.25, 4.4375, 11, -1, -9) rec[-44] rec[-11] +DETECTOR(3.5, 4.4375, 11, -1, -9) rec[-52] rec[-8] +DETECTOR(4.625, 0.125, 11, -1, -9) rec[-45] rec[-39] rec[-16] +DETECTOR(4.875, 0.125, 11, -1, -9) rec[-55] rec[-54] rec[-13] +DETECTOR(4.625, 2, 11, -1, -9) rec[-46] rec[-39] rec[-10] +DETECTOR(4.875, 2, 11, -1, -9) rec[-56] rec[-54] rec[-7] +DETECTOR(4.5, 3.9375, 11, -1, -9) rec[-47] rec[-5] +DETECTOR(4.75, 3.9375, 11, -1, -9) rec[-55] rec[-2] +DETECTOR(6.5, 0.9375, 11, -1, -9) rec[-48] rec[-4] +DETECTOR(6.75, 0.9375, 11, -1, -9) rec[-1] diff --git a/test/data/determined/clifft_d5_sproxy.stim b/test/data/determined/clifft_d5_sproxy.stim new file mode 100644 index 00000000..3f8530fa --- /dev/null +++ b/test/data/determined/clifft_d5_sproxy.stim @@ -0,0 +1,350 @@ +QUBIT_COORDS(0, 0) 0 +QUBIT_COORDS(0, 1) 1 +QUBIT_COORDS(1, 0) 2 +QUBIT_COORDS(1, 1) 3 +QUBIT_COORDS(1, 2) 4 +QUBIT_COORDS(1, 3) 5 +QUBIT_COORDS(2, 0) 6 +QUBIT_COORDS(2, 1) 7 +QUBIT_COORDS(2, 2) 8 +QUBIT_COORDS(2, 3) 9 +QUBIT_COORDS(2, 4) 10 +QUBIT_COORDS(3, 0) 11 +QUBIT_COORDS(3, 1) 12 +QUBIT_COORDS(3, 2) 13 +QUBIT_COORDS(3, 3) 14 +QUBIT_COORDS(3, 4) 15 +QUBIT_COORDS(3, 5) 16 +QUBIT_COORDS(4, 0) 17 +QUBIT_COORDS(4, 1) 18 +QUBIT_COORDS(4, 2) 19 +QUBIT_COORDS(4, 3) 20 +QUBIT_COORDS(4, 4) 21 +QUBIT_COORDS(4, 5) 22 +QUBIT_COORDS(4, 6) 23 +QUBIT_COORDS(5, 0) 24 +QUBIT_COORDS(5, 1) 25 +QUBIT_COORDS(5, 2) 26 +QUBIT_COORDS(5, 3) 27 +QUBIT_COORDS(5, 4) 28 +QUBIT_COORDS(5, 5) 29 +QUBIT_COORDS(5, 6) 30 +QUBIT_COORDS(6, 0) 31 +QUBIT_COORDS(6, 1) 32 +QUBIT_COORDS(6, 2) 33 +QUBIT_COORDS(6, 3) 34 +QUBIT_COORDS(6, 4) 35 +QUBIT_COORDS(7, 0) 36 +QUBIT_COORDS(7, 1) 37 +QUBIT_COORDS(7, 2) 38 +QUBIT_COORDS(7, 3) 39 +QUBIT_COORDS(8, 0) 40 +QUBIT_COORDS(8, 1) 41 +RX 7 11 13 3 2 4 18 0 5 17 +R 12 8 6 +TICK +CX 7 12 11 6 13 8 +TICK +CX 7 8 11 12 +TICK +CX 7 6 13 12 +TICK +CX 2 6 4 8 18 12 +TICK +CX 6 2 8 4 12 18 +TICK +CX 3 4 17 18 +TICK +CX 3 2 18 17 +TICK +CX 4 3 +TICK +CX 2 3 +TICK +S_DAG 3 +TICK +CX 2 3 +TICK +CX 4 3 +TICK +CX 0 2 5 4 +TICK +CX 2 0 4 5 +TICK +RX 2 12 4 +R 6 18 8 9 +TICK +CX 2 6 4 8 5 9 12 18 +TICK +CX 2 0 6 11 8 13 9 5 12 7 +TICK +CX 2 3 6 7 8 9 12 13 +TICK +CX 4 3 8 7 12 11 18 17 +TICK +CX 3 4 7 8 11 12 17 18 +TICK +CX 0 2 7 12 11 6 13 8 +TICK +CX 3 2 7 6 9 8 13 12 +TICK +CX 2 6 4 8 12 18 +TICK +M 6 18 8 5 +MX 2 12 4 +DETECTOR(2, 0, 0) rec[-7] +DETECTOR(4, 1, 0) rec[-6] +DETECTOR(2, 2, 0) rec[-5] +DETECTOR(1, 3, 0) rec[-4] +DETECTOR(1, 0, 0) rec[-3] +DETECTOR(3, 1, 0) rec[-2] +DETECTOR(1, 2, 0) rec[-1] +TICK +RX 18 12 6 2 8 1 +TICK +S_DAG 0 3 7 9 11 13 17 +TICK +CX 1 0 2 3 6 7 8 9 12 11 18 17 +TICK +CX 3 1 7 8 12 18 +TICK +CX 7 3 12 13 +TICK +CX 7 12 +TICK +MX 7 +TICK +RX 7 +TICK +CX 7 12 +TICK +CX 7 3 12 13 +TICK +CX 3 1 7 8 12 18 +TICK +CX 1 0 2 3 6 7 8 9 12 11 18 17 +TICK +S 0 3 7 9 11 13 17 +TICK +MX 18 12 6 2 8 1 +DETECTOR(2.14286, 1, 1, -1, -9) rec[-9] rec[-8] rec[-7] +DETECTOR(4, 1, 2) rec[-6] +DETECTOR(3, 1, 2) rec[-5] +DETECTOR(2, 1, 2) rec[-4] rec[-7] +DETECTOR(1, 0, 2) rec[-3] +DETECTOR(2, 2, 2) rec[-2] +DETECTOR(0, 1, 2) rec[-1] +TICK +RX 26 33 36 16 28 27 +R 19 25 32 38 40 23 15 22 21 29 34 +TICK +CX 16 22 26 19 27 34 28 21 33 38 36 40 +TICK +CX 16 15 22 23 26 25 28 29 33 32 +TICK +CX 15 16 23 22 25 26 29 28 32 33 +TICK +M 26 33 28 22 16 +DETECTOR(5, 2, 4) rec[-5] +DETECTOR(6, 2, 4) rec[-4] +DETECTOR(5, 4, 4) rec[-3] +DETECTOR(4, 5, 4) rec[-2] +DETECTOR(3, 5, 4) rec[-1] +TICK +RX 37 28 26 24 16 14 12 4 2 +R 41 35 33 31 22 20 18 8 6 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +CX 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 +TICK +CX 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 +TICK +CX 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 +TICK +CX 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 +TICK +CX 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 +TICK +CX 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +M 41 35 33 31 22 20 18 8 6 +MX 37 28 26 24 16 14 12 4 2 +DETECTOR(1.25, 0.25, 5, -1, -9) rec[-30] rec[-1] +DETECTOR(1.5, 1.875, 5, -1, -9) rec[-30] rec[-2] +DETECTOR(1.75, 0.25, 5, -1, -9) rec[-10] +DETECTOR(2, 1.875, 5, -1, -9) rec[-11] +DETECTOR(3.075, 0.9125, 5, -1, -9) rec[-30] rec[-3] +DETECTOR(3.5, 4.875, 5, -1, -9) rec[-5] +DETECTOR(3.575, 0.9125, 5, -1, -9) rec[-12] +DETECTOR(4, 4.875, 5, -1, -9) rec[-14] +DETECTOR(5.25, 2, 5, -1, -9) rec[-7] +DETECTOR(5, 3.875, 5, -1, -9) rec[-8] +DETECTOR(5.75, 2, 5, -1, -9) rec[-16] +DETECTOR(5.5, 3.875, 5, -1, -9) rec[-17] +DETECTOR(7, 0.875, 5, -1, -9) rec[-9] +DETECTOR(7.5, 0.875, 5, -1, -9) rec[-18] +TICK +RX 37 28 26 24 16 14 12 4 2 +R 41 35 33 31 22 20 18 8 6 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +CX 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 +TICK +CX 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 +TICK +CX 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 +TICK +CX 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 +TICK +CX 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 +TICK +CX 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +M 41 35 33 31 22 20 18 8 6 +MX 37 28 26 24 16 14 12 4 2 +DETECTOR(1, 0, 6, -1, -9) rec[-19] rec[-1] +DETECTOR(1, 2, 6, -1, -9) rec[-20] rec[-2] +DETECTOR(2, 0, 6, -1, -9) rec[-29] rec[-28] rec[-10] +DETECTOR(2, 2, 6, -1, -9) rec[-28] rec[-11] +DETECTOR(3, 1, 6, -1, -9) rec[-21] rec[-3] +DETECTOR(3, 3, 6, -1, -9) rec[-22] rec[-4] +DETECTOR(3, 5, 6, -1, -9) rec[-23] rec[-5] +DETECTOR(4, 1, 6, -1, -9) rec[-31] rec[-12] +DETECTOR(4, 3, 6, -1, -9) rec[-32] rec[-30] rec[-13] +DETECTOR(4, 5, 6, -1, -9) rec[-31] rec[-14] +DETECTOR(5, 0, 6, -1, -9) rec[-24] rec[-6] +DETECTOR(5, 2, 6, -1, -9) rec[-25] rec[-7] +DETECTOR(5, 4, 6, -1, -9) rec[-26] rec[-8] +DETECTOR(6, 0, 6, -1, -9) rec[-34] rec[-33] rec[-15] +DETECTOR(6, 2, 6, -1, -9) rec[-35] rec[-33] rec[-16] +DETECTOR(6, 4, 6, -1, -9) rec[-34] rec[-17] +DETECTOR(7, 1, 6, -1, -9) rec[-27] rec[-9] +DETECTOR(8, 1, 6, -1, -9) rec[-18] +TICK +RX 37 28 26 24 16 14 12 4 2 +R 41 35 33 31 22 20 18 8 6 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +CX 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 +TICK +CX 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 +TICK +CX 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 +TICK +CX 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 +TICK +CX 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 +TICK +CX 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 +TICK +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +TICK +M 41 35 33 31 22 20 18 8 6 +MX 37 28 26 24 16 14 12 4 2 +DETECTOR(1, 0, 7, -1, -9) rec[-19] rec[-1] +DETECTOR(1, 2, 7, -1, -9) rec[-20] rec[-2] +DETECTOR(2, 0, 7, -1, -9) rec[-29] rec[-28] rec[-10] +DETECTOR(2, 2, 7, -1, -9) rec[-28] rec[-11] +DETECTOR(3, 1, 7, -1, -9) rec[-21] rec[-3] +DETECTOR(3, 3, 7, -1, -9) rec[-22] rec[-4] +DETECTOR(3, 5, 7, -1, -9) rec[-23] rec[-5] +DETECTOR(4, 1, 7, -1, -9) rec[-31] rec[-12] +DETECTOR(4, 3, 7, -1, -9) rec[-32] rec[-30] rec[-13] +DETECTOR(4, 5, 7, -1, -9) rec[-31] rec[-14] +DETECTOR(5, 0, 7, -1, -9) rec[-24] rec[-6] +DETECTOR(5, 2, 7, -1, -9) rec[-25] rec[-7] +DETECTOR(5, 4, 7, -1, -9) rec[-26] rec[-8] +DETECTOR(6, 0, 7, -1, -9) rec[-34] rec[-33] rec[-15] +DETECTOR(6, 2, 7, -1, -9) rec[-35] rec[-33] rec[-16] +DETECTOR(6, 4, 7, -1, -9) rec[-34] rec[-17] +DETECTOR(7, 1, 7, -1, -9) rec[-27] rec[-9] +DETECTOR(8, 1, 7, -1, -9) rec[-18] +TICK +RX 24 31 2 6 8 10 20 22 39 1 12 18 37 33 14 26 28 30 41 +TICK +S_DAG 0 3 7 9 11 13 15 17 19 21 23 25 27 29 32 34 36 38 40 +TICK +CX 1 0 2 3 6 7 8 13 10 15 12 11 14 9 18 17 20 27 22 29 24 25 26 19 28 21 30 23 31 32 33 34 37 36 39 38 41 40 +TICK +CX 3 1 14 15 29 30 33 38 37 41 +TICK +CX 7 3 13 14 26 33 28 29 32 37 +TICK +CX 12 13 25 32 27 28 +TICK +CX 12 7 26 27 +TICK +CX 18 12 25 26 +TICK +CX 25 18 +TICK +MX 25 +TICK +RX 25 +TICK +CX 25 18 +TICK +CX 18 12 25 26 +TICK +CX 12 7 26 27 +TICK +CX 12 13 25 32 27 28 +TICK +CX 7 3 13 14 26 33 28 29 32 37 +TICK +CX 3 1 14 15 29 30 33 38 37 41 +TICK +CX 1 0 2 3 6 7 8 13 10 15 12 11 14 9 18 17 20 27 22 29 24 25 26 19 28 21 30 23 31 32 33 34 37 36 39 38 41 40 +TICK +S 0 3 7 9 11 13 15 17 19 21 23 25 27 29 32 34 36 38 40 +TICK +MX 20 22 8 10 2 6 24 31 39 1 12 18 37 33 14 26 28 30 41 +OBSERVABLE_INCLUDE(0) rec[-10] rec[-9] rec[-8] rec[-7] rec[-6] rec[-5] rec[-4] rec[-3] rec[-2] rec[-1] +DETECTOR(2.25889, 1.08534, 8, -1, -9) rec[-85] rec[-84] rec[-81] rec[-80] rec[-74] rec[-73] rec[-72] rec[-70] rec[-69] rec[-68] rec[-67] rec[-56] rec[-55] rec[-54] rec[-52] rec[-51] rec[-50] rec[-49] rec[-38] rec[-37] rec[-36] rec[-34] rec[-33] rec[-32] rec[-31] rec[-20] +DETECTOR(4, 3, 9) rec[-19] +DETECTOR(4, 5, 9) rec[-18] +DETECTOR(2, 2, 9) rec[-17] +DETECTOR(2, 4, 9) rec[-16] +DETECTOR(1, 0, 9) rec[-15] +DETECTOR(2, 0, 9) rec[-14] +DETECTOR(5, 1, 9) rec[-13] rec[-20] +DETECTOR(6, 0, 9) rec[-12] +DETECTOR(7, 3, 9) rec[-11] +DETECTOR(0, 1, 9) rec[-10] +DETECTOR(3, 1, 9) rec[-9] +DETECTOR(4, 1, 9) rec[-8] +DETECTOR(7, 1, 9) rec[-7] +DETECTOR(6, 2, 9) rec[-6] +DETECTOR(3, 3, 9) rec[-5] +DETECTOR(5, 2, 9) rec[-4] +DETECTOR(5, 4, 9) rec[-3] +DETECTOR(5, 6, 9) rec[-2] +DETECTOR(8, 1, 9) rec[-1] +TICK +MPP Y0*Y3*Y7*Y9*Y11*Y13*Y15*Y17*Y19*Y21*Y23*Y25*Y27*Y29*Y32*Y34*Y36*Y38*Y40 X0*X3*X7*X11 X9*X13*X15*X19*X21*X27 X17*X25*X32*X36 Z0*Z3*Z7*Z11 Z9*Z13*Z15*Z19*Z21*Z27 Z17*Z25*Z32*Z36 X3*X7*X9*X13 X15*X21*X23*X29 X19*X25*X27*X32*X34*X38 Z3*Z7*Z9*Z13 Z15*Z21*Z23*Z29 Z19*Z25*Z27*Z32*Z34*Z38 X7*X11*X13*X17*X19*X25 X21*X27*X29*X34 X32*X36*X38*X40 Z7*Z11*Z13*Z17*Z19*Z25 Z21*Z27*Z29*Z34 Z32*Z36*Z38*Z40 +OBSERVABLE_INCLUDE(0) rec[-19] +DETECTOR(0.625, 0.125, 11, -1, -9) rec[-40] rec[-18] +DETECTOR(0.875, 0.125, 11, -1, -9) rec[-50] rec[-49] rec[-15] +DETECTOR(1.25, 1.4375, 11, -1, -9) rec[-41] rec[-12] +DETECTOR(1.5, 1.4375, 11, -1, -9) rec[-49] rec[-9] +DETECTOR(2.625, 1, 11, -1, -9) rec[-42] rec[-39] rec[-6] +DETECTOR(2.875, 1, 11, -1, -9) rec[-52] rec[-3] +DETECTOR(2.625, 3, 11, -1, -9) rec[-43] rec[-17] +DETECTOR(2.875, 3, 11, -1, -9) rec[-53] rec[-51] rec[-14] +DETECTOR(3.25, 4.4375, 11, -1, -9) rec[-44] rec[-11] +DETECTOR(3.5, 4.4375, 11, -1, -9) rec[-52] rec[-8] +DETECTOR(4.625, 0.125, 11, -1, -9) rec[-45] rec[-39] rec[-16] +DETECTOR(4.875, 0.125, 11, -1, -9) rec[-55] rec[-54] rec[-13] +DETECTOR(4.625, 2, 11, -1, -9) rec[-46] rec[-39] rec[-10] +DETECTOR(4.875, 2, 11, -1, -9) rec[-56] rec[-54] rec[-7] +DETECTOR(4.5, 3.9375, 11, -1, -9) rec[-47] rec[-5] +DETECTOR(4.75, 3.9375, 11, -1, -9) rec[-55] rec[-2] +DETECTOR(6.5, 0.9375, 11, -1, -9) rec[-48] rec[-4] +DETECTOR(6.75, 0.9375, 11, -1, -9) rec[-1] diff --git a/test/data/determined/wan_clifft_d3_T.stim b/test/data/determined/wan_clifft_d3_T.stim new file mode 100644 index 00000000..129a7375 --- /dev/null +++ b/test/data/determined/wan_clifft_d3_T.stim @@ -0,0 +1,124 @@ +QUBIT_COORDS(0, 0) 0 +QUBIT_COORDS(0, 1) 1 +QUBIT_COORDS(1, 0) 2 +QUBIT_COORDS(1, 1) 3 +QUBIT_COORDS(1, 2) 4 +QUBIT_COORDS(1, 3) 5 +QUBIT_COORDS(2, 0) 6 +QUBIT_COORDS(2, 1) 7 +QUBIT_COORDS(2, 2) 8 +QUBIT_COORDS(2, 3) 9 +QUBIT_COORDS(3, 0) 10 +QUBIT_COORDS(3, 1) 11 +QUBIT_COORDS(3, 2) 12 +QUBIT_COORDS(4, 0) 13 +QUBIT_COORDS(4, 1) 14 +RX 7 10 12 3 2 4 14 0 5 13 +R 11 8 6 +TICK +CX 7 11 10 6 12 8 +TICK +CX 7 8 10 11 +TICK +CX 7 6 12 11 +TICK +CX 2 6 4 8 14 11 +TICK +CX 6 2 8 4 11 14 +TICK +CX 3 4 13 14 +TICK +CX 3 2 14 13 +TICK +CX 4 3 +TICK +CX 2 3 +TICK +T_DAG 3 +TICK +CX 2 3 +TICK +CX 4 3 +TICK +CX 0 2 5 4 +TICK +CX 2 0 4 5 +TICK +RX 2 11 4 +R 6 14 8 9 +TICK +CX 2 6 4 8 5 9 11 14 +TICK +CX 2 0 6 10 8 12 9 5 11 7 +TICK +CX 2 3 6 7 8 9 11 12 +TICK +CX 4 3 8 7 11 10 14 13 +TICK +CX 3 4 7 8 10 11 13 14 +TICK +CX 0 2 7 11 10 6 12 8 +TICK +CX 3 2 7 6 9 8 12 11 +TICK +CX 2 6 4 8 11 14 +TICK +M 6 14 8 5 +MX 2 11 4 +DETECTOR(2, 0, 0) rec[-7] +DETECTOR(4, 1, 0) rec[-6] +DETECTOR(2, 2, 0) rec[-5] +DETECTOR(1, 3, 0) rec[-4] +DETECTOR(1, 0, 0) rec[-3] +DETECTOR(3, 1, 0) rec[-2] +DETECTOR(1, 2, 0) rec[-1] +SHIFT_COORDS(0, 0, 1) +TICK +RX 14 11 6 2 8 1 +TICK +T_DAG 0 3 7 9 10 12 13 +TICK +CX 1 0 2 3 6 7 8 9 11 10 14 13 +TICK +CX 3 1 7 8 11 14 +TICK +CX 7 3 11 12 +TICK +CX 7 11 +TICK +MX 7 +TICK +RX 7 +TICK +CX 7 11 +TICK +CX 7 3 11 12 +TICK +CX 3 1 7 8 11 14 +TICK +CX 1 0 2 3 6 7 8 9 11 10 14 13 +TICK +T 0 3 7 9 10 12 13 +TICK +MX 14 11 6 2 8 1 +OBSERVABLE_INCLUDE(0) rec[-6] rec[-5] rec[-2] rec[-1] +DETECTOR(2.14286, 1, 0, -1, -9) rec[-9] rec[-8] rec[-7] +DETECTOR(4, 1, 1) rec[-6] +DETECTOR(3, 1, 1) rec[-5] +DETECTOR(2, 1, 1) rec[-4] rec[-7] +DETECTOR(1, 0, 1) rec[-3] +DETECTOR(2, 2, 1) rec[-2] +DETECTOR(0, 1, 1) rec[-1] +SHIFT_COORDS(0, 0, 3) +TICK +T 0 3 7 9 10 12 13 +MPP Y0*Y3*Y7*Y9*Y10*Y12*Y13 +T_DAG 0 3 7 9 10 12 13 +OBSERVABLE_INCLUDE(0) rec[-1] +MPP X0*X3*X7*X10 Z0*Z3*Z7*Z10 X3*X7*X9*X12 Z3*Z7*Z9*Z12 X7*X10*X12*X13 Z7*Z10*Z12*Z13 +DETECTOR(0.75, 0.25, 0, -1, -9) rec[-14] rec[-6] +DETECTOR(0.75, 0.25, 1, -1, -9) rec[-5] +DETECTOR(1.5, 1.375, 0, -1, -9) rec[-14] rec[-4] +DETECTOR(1.5, 1.375, 1, -1, -9) rec[-3] +DETECTOR(2.5, 0.875, 0, -1, -9) rec[-14] rec[-2] +DETECTOR(2.5, 0.875, 1, -1, -9) rec[-1] diff --git a/test/data/determined/wan_soft_d5_T.stim b/test/data/determined/wan_soft_d5_T.stim new file mode 100644 index 00000000..860627fa --- /dev/null +++ b/test/data/determined/wan_soft_d5_T.stim @@ -0,0 +1,211 @@ +QUBIT_COORDS(0, 0) 0 +QUBIT_COORDS(0, 1) 1 +QUBIT_COORDS(1, 0) 2 +QUBIT_COORDS(1, 1) 3 +QUBIT_COORDS(1, 2) 4 +QUBIT_COORDS(1, 3) 5 +QUBIT_COORDS(2, 0) 6 +QUBIT_COORDS(2, 1) 7 +QUBIT_COORDS(2, 2) 8 +QUBIT_COORDS(2, 3) 9 +QUBIT_COORDS(2, 4) 10 +QUBIT_COORDS(3, 0) 11 +QUBIT_COORDS(3, 1) 12 +QUBIT_COORDS(3, 2) 13 +QUBIT_COORDS(3, 3) 14 +QUBIT_COORDS(3, 4) 15 +QUBIT_COORDS(3, 5) 16 +QUBIT_COORDS(4, 0) 17 +QUBIT_COORDS(4, 1) 18 +QUBIT_COORDS(4, 2) 19 +QUBIT_COORDS(4, 3) 20 +QUBIT_COORDS(4, 4) 21 +QUBIT_COORDS(4, 5) 22 +QUBIT_COORDS(4, 6) 23 +QUBIT_COORDS(5, 0) 24 +QUBIT_COORDS(5, 1) 25 +QUBIT_COORDS(5, 2) 26 +QUBIT_COORDS(5, 3) 27 +QUBIT_COORDS(5, 4) 28 +QUBIT_COORDS(5, 5) 29 +QUBIT_COORDS(5, 6) 30 +QUBIT_COORDS(6, 0) 31 +QUBIT_COORDS(6, 1) 32 +QUBIT_COORDS(6, 2) 33 +QUBIT_COORDS(6, 3) 34 +QUBIT_COORDS(6, 4) 35 +QUBIT_COORDS(7, 0) 36 +QUBIT_COORDS(7, 1) 37 +QUBIT_COORDS(7, 2) 38 +QUBIT_COORDS(7, 3) 39 +QUBIT_COORDS(8, 0) 40 +QUBIT_COORDS(8, 1) 41 +RX 7 11 13 3 2 4 18 0 5 17 +R 12 8 6 +CX 7 12 11 6 13 8 7 8 11 12 7 6 13 12 2 6 4 8 18 12 6 2 8 4 12 18 3 4 17 18 3 2 18 17 4 3 2 3 +T_DAG 3 +CX 2 3 4 3 0 2 5 4 2 0 4 5 +RX 2 12 4 +R 6 18 8 9 +CX 2 6 4 8 5 9 12 18 2 0 6 11 8 13 9 5 12 7 2 3 6 7 8 9 12 13 4 3 8 7 12 11 18 17 3 4 7 8 11 12 17 18 0 2 7 12 11 6 13 8 3 2 7 6 9 8 13 12 2 6 4 8 12 18 +M 6 18 8 5 +MX 2 12 4 +DETECTOR(2, 0, 0) rec[-7] +DETECTOR(4, 1, 0) rec[-6] +DETECTOR(2, 2, 0) rec[-5] +DETECTOR(1, 3, 0) rec[-4] +DETECTOR(1, 0, 0) rec[-3] +DETECTOR(3, 1, 0) rec[-2] +DETECTOR(1, 2, 0) rec[-1] +SHIFT_COORDS(0, 0, 1) +RX 18 12 6 2 8 1 +T_DAG 0 3 7 9 11 13 17 +CX 1 0 2 3 6 7 8 9 12 11 18 17 3 1 7 8 12 18 7 3 12 13 7 12 +MX 7 +RX 7 +CX 7 12 7 3 12 13 3 1 7 8 12 18 1 0 2 3 6 7 8 9 12 11 18 17 +T 0 3 7 9 11 13 17 +MX 18 12 6 2 8 1 +DETECTOR(2.14286, 1, 0, -1, -9) rec[-9] rec[-8] rec[-7] +DETECTOR(4, 1, 1) rec[-6] +DETECTOR(3, 1, 1) rec[-5] +DETECTOR(2, 1, 1) rec[-4] rec[-7] +DETECTOR(1, 0, 1) rec[-3] +DETECTOR(2, 2, 1) rec[-2] +DETECTOR(0, 1, 1) rec[-1] +SHIFT_COORDS(0, 0, 3) +RX 26 33 36 16 28 27 +R 19 25 32 38 40 23 15 22 21 29 34 +CX 16 22 26 19 27 34 28 21 33 38 36 40 16 15 22 23 26 25 28 29 33 32 15 16 23 22 25 26 29 28 32 33 +M 26 33 28 22 16 +DETECTOR(5, 2, 0) rec[-5] +DETECTOR(6, 2, 0) rec[-4] +DETECTOR(5, 4, 0) rec[-3] +DETECTOR(4, 5, 0) rec[-2] +DETECTOR(3, 5, 0) rec[-1] +SHIFT_COORDS(0, 0, 1) +RX 37 28 26 24 16 14 12 4 2 +R 41 35 33 31 22 20 18 8 6 +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +M 41 35 33 31 22 20 18 8 6 +MX 37 28 26 24 16 14 12 4 2 +DETECTOR(1.25, 0.25, 0, -1, -9) rec[-30] rec[-1] +DETECTOR(1.5, 1.875, 0, -1, -9) rec[-30] rec[-2] +DETECTOR(1.75, 0.25, 0, -1, -9) rec[-10] +DETECTOR(2, 1.875, 0, -1, -9) rec[-11] +DETECTOR(3.075, 0.9125, 0, -1, -9) rec[-30] rec[-3] +DETECTOR(3.5, 4.875, 0, -1, -9) rec[-5] +DETECTOR(3.575, 0.9125, 0, -1, -9) rec[-12] +DETECTOR(4, 4.875, 0, -1, -9) rec[-14] +DETECTOR(5.25, 2, 0, -1, -9) rec[-7] +DETECTOR(5, 3.875, 0, -1, -9) rec[-8] +DETECTOR(5.75, 2, 0, -1, -9) rec[-16] +DETECTOR(5.5, 3.875, 0, -1, -9) rec[-17] +DETECTOR(7, 0.875, 0, -1, -9) rec[-9] +DETECTOR(7.5, 0.875, 0, -1, -9) rec[-18] +SHIFT_COORDS(0, 0, 1) +CZ rec[-6] 36 rec[-6] 40 rec[-4] 15 rec[-4] 23 +CX rec[-15] 36 rec[-15] 40 rec[-15] 38 rec[-15] 40 rec[-16] 36 rec[-16] 40 rec[-12] 15 rec[-12] 23 rec[-13] 0 rec[-13] 11 rec[-13] 23 rec[-14] 15 rec[-14] 23 +RX 37 28 26 24 16 14 12 4 2 +R 41 35 33 31 22 20 18 8 6 +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +M 41 35 33 31 22 20 18 8 6 +MX 37 28 26 24 16 14 12 4 2 +DETECTOR(1, 0, 0, -1, -9) rec[-19] rec[-1] +DETECTOR(1, 2, 0, -1, -9) rec[-20] rec[-2] +DETECTOR(2, 0, 0, -1, -9) rec[-29] rec[-28] rec[-10] +DETECTOR(2, 2, 0, -1, -9) rec[-28] rec[-11] +DETECTOR(3, 1, 0, -1, -9) rec[-21] rec[-3] +DETECTOR(3, 3, 0, -1, -9) rec[-4] +DETECTOR(3, 5, 0, -1, -9) rec[-23] rec[-5] +DETECTOR(4, 1, 0, -1, -9) rec[-12] +DETECTOR(4, 3, 0, -1, -9) rec[-13] +DETECTOR(4, 5, 0, -1, -9) rec[-14] +DETECTOR(5, 0, 0, -1, -9) rec[-6] +DETECTOR(5, 2, 0, -1, -9) rec[-25] rec[-7] +DETECTOR(5, 4, 0, -1, -9) rec[-26] rec[-8] +DETECTOR(6, 0, 0, -1, -9) rec[-15] +DETECTOR(6, 2, 0, -1, -9) rec[-16] +DETECTOR(6, 4, 0, -1, -9) rec[-34] rec[-17] +DETECTOR(7, 1, 0, -1, -9) rec[-27] rec[-9] +DETECTOR(8, 1, 0, -1, -9) rec[-18] +SHIFT_COORDS(0, 0, 1) +RX 37 28 26 24 16 14 12 4 2 +R 41 35 33 31 22 20 18 8 6 +CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 +M 41 35 33 31 22 20 18 8 6 +MX 37 28 26 24 16 14 12 4 2 +DETECTOR(1, 0, 0, -1, -9) rec[-19] rec[-1] +DETECTOR(1, 2, 0, -1, -9) rec[-20] rec[-2] +DETECTOR(2, 0, 0, -1, -9) rec[-29] rec[-28] rec[-10] +DETECTOR(2, 2, 0, -1, -9) rec[-28] rec[-11] +DETECTOR(3, 1, 0, -1, -9) rec[-21] rec[-3] +DETECTOR(3, 3, 0, -1, -9) rec[-22] rec[-4] +DETECTOR(3, 5, 0, -1, -9) rec[-23] rec[-5] +DETECTOR(4, 1, 0, -1, -9) rec[-31] rec[-12] +DETECTOR(4, 3, 0, -1, -9) rec[-32] rec[-30] rec[-13] +DETECTOR(4, 5, 0, -1, -9) rec[-31] rec[-14] +DETECTOR(5, 0, 0, -1, -9) rec[-24] rec[-6] +DETECTOR(5, 2, 0, -1, -9) rec[-25] rec[-7] +DETECTOR(5, 4, 0, -1, -9) rec[-26] rec[-8] +DETECTOR(6, 0, 0, -1, -9) rec[-34] rec[-33] rec[-15] +DETECTOR(6, 2, 0, -1, -9) rec[-35] rec[-33] rec[-16] +DETECTOR(6, 4, 0, -1, -9) rec[-34] rec[-17] +DETECTOR(7, 1, 0, -1, -9) rec[-27] rec[-9] +DETECTOR(8, 1, 0, -1, -9) rec[-18] +SHIFT_COORDS(0, 0, 1) +RX 24 31 2 6 8 10 20 22 39 1 12 18 37 33 14 26 28 30 41 +T 0 11 17 19 36 40 +T_DAG 3 7 9 13 15 21 23 25 27 29 32 34 38 +CX 1 0 2 3 6 7 8 13 10 15 12 11 14 9 18 17 20 27 22 29 24 25 26 19 28 21 30 23 31 32 33 34 37 36 39 38 41 40 3 1 14 15 29 30 33 38 37 41 7 3 13 14 26 33 28 29 32 37 12 13 25 32 27 28 12 7 26 27 18 12 25 26 25 18 +MX 25 +RX 25 +CX 25 18 18 12 25 26 12 7 26 27 12 13 25 32 27 28 7 3 13 14 26 33 28 29 32 37 3 1 14 15 29 30 33 38 37 41 1 0 2 3 6 7 8 13 10 15 12 11 14 9 18 17 20 27 22 29 24 25 26 19 28 21 30 23 31 32 33 34 37 36 39 38 41 40 +T_DAG 0 11 17 19 36 40 +T 3 7 9 13 15 21 23 25 27 29 32 34 38 +MX 20 22 8 10 2 6 24 31 39 1 12 18 37 33 14 26 28 30 41 +OBSERVABLE_INCLUDE(0) rec[-10] rec[-9] rec[-8] rec[-7] rec[-6] rec[-5] rec[-4] rec[-3] rec[-2] rec[-1] +DETECTOR(2.25889, 1.08534, 0, -1, -9) rec[-85] rec[-84] rec[-81] rec[-80] rec[-74] rec[-73] rec[-72] rec[-70] rec[-68] rec[-67] rec[-56] rec[-55] rec[-54] rec[-52] rec[-51] rec[-50] rec[-49] rec[-38] rec[-37] rec[-36] rec[-34] rec[-33] rec[-32] rec[-31] rec[-20] +DETECTOR(4, 3, 1) rec[-19] +DETECTOR(4, 5, 1) rec[-18] +DETECTOR(2, 2, 1) rec[-17] +DETECTOR(2, 4, 1) rec[-16] +DETECTOR(1, 0, 1) rec[-15] +DETECTOR(2, 0, 1) rec[-14] +DETECTOR(5, 1, 1) rec[-13] rec[-20] +DETECTOR(6, 0, 1) rec[-12] +DETECTOR(7, 3, 1) rec[-11] +DETECTOR(0, 1, 1) rec[-10] +DETECTOR(3, 1, 1) rec[-9] +DETECTOR(4, 1, 1) rec[-8] +DETECTOR(7, 1, 1) rec[-7] +DETECTOR(6, 2, 1) rec[-6] +DETECTOR(3, 3, 1) rec[-5] +DETECTOR(5, 2, 1) rec[-4] +DETECTOR(5, 4, 1) rec[-3] +DETECTOR(5, 6, 1) rec[-2] +DETECTOR(8, 1, 1) rec[-1] +SHIFT_COORDS(0, 0, 3) +MPP X0*X3*X7*X11 X9*X13*X15*X19*X21*X27 X17*X25*X32*X36 Z0*Z3*Z7*Z11 Z9*Z13*Z15*Z19*Z21*Z27 Z17*Z25*Z32*Z36 X3*X7*X9*X13 X15*X21*X23*X29 X19*X25*X27*X32*X34*X38 Z3*Z7*Z9*Z13 Z15*Z21*Z23*Z29 Z19*Z25*Z27*Z32*Z34*Z38 X7*X11*X13*X17*X19*X25 X21*X27*X29*X34 X32*X36*X38*X40 Z7*Z11*Z13*Z17*Z19*Z25 Z21*Z27*Z29*Z34 Z32*Z36*Z38*Z40 +DETECTOR(0.625, 0.125, 0, -1, -9) rec[-39] rec[-18] +DETECTOR(0.875, 0.125, 0, -1, -9) rec[-49] rec[-48] rec[-15] +DETECTOR(1.25, 1.4375, 0, -1, -9) rec[-40] rec[-12] +DETECTOR(1.5, 1.4375, 0, -1, -9) rec[-48] rec[-9] +DETECTOR(2.625, 1, 0, -1, -9) rec[-41] rec[-38] rec[-6] +DETECTOR(2.875, 1, 0, -1, -9) rec[-51] rec[-3] +DETECTOR(2.625, 3, 0, -1, -9) rec[-42] rec[-17] +DETECTOR(2.875, 3, 0, -1, -9) rec[-52] rec[-50] rec[-14] +DETECTOR(3.25, 4.4375, 0, -1, -9) rec[-43] rec[-11] +DETECTOR(3.5, 4.4375, 0, -1, -9) rec[-51] rec[-8] +DETECTOR(4.625, 0.125, 0, -1, -9) rec[-44] rec[-38] rec[-16] +DETECTOR(4.875, 0.125, 0, -1, -9) rec[-54] rec[-53] rec[-13] +DETECTOR(4.625, 2, 0, -1, -9) rec[-45] rec[-38] rec[-10] +DETECTOR(4.875, 2, 0, -1, -9) rec[-55] rec[-53] rec[-7] +DETECTOR(4.5, 3.9375, 0, -1, -9) rec[-46] rec[-5] +DETECTOR(4.75, 3.9375, 0, -1, -9) rec[-54] rec[-2] +DETECTOR(6.5, 0.9375, 0, -1, -9) rec[-47] rec[-4] +DETECTOR(6.75, 0.9375, 0, -1, -9) rec[-1] +T_DAG 0 11 17 19 36 40 +T 3 7 9 13 15 21 23 25 27 29 32 34 38 +MPP Y0*Y3*Y7*Y9*Y11*Y13*Y15*Y17*Y19*Y21*Y23*Y25*Y27*Y29*Y32*Y34*Y36*Y38*Y40 +OBSERVABLE_INCLUDE(0) rec[-1] From d03e8b789cc9c19e6a8176cf3eab2bb92b340e47 Mon Sep 17 00:00:00 2001 From: Rafael Haenel Date: Wed, 18 Nov 2026 16:13:53 -0700 Subject: [PATCH 3/6] test: keep one literature circuit for the determined measurements The other nine circuits checked claims of their papers; the unit tests cover correctness. Keep Chan et al.'s uncorrected d=5 circuit, a cultivation-sized T circuit with random detectors to heal. Co-Authored-By: Claude Opus 5.5 --- test/data/determined/README.md | 17 +- test/data/determined/chan_d5a19_T.stim | 373 ---------------- test/data/determined/chan_d5a19f13_T.stim | 421 ------------------ .../chan_d5a19f13_uncorrected_T.stim | 419 ----------------- test/data/determined/clifft_d5_T.stim | 359 --------------- test/data/determined/clifft_d5_T_rule1.stim | 353 --------------- test/data/determined/clifft_d5_T_rule12.stim | 357 --------------- test/data/determined/clifft_d5_sproxy.stim | 350 --------------- test/data/determined/wan_clifft_d3_T.stim | 124 ------ test/data/determined/wan_soft_d5_T.stim | 211 --------- .../integration/test_determined_literature.py | 140 +----- 11 files changed, 26 insertions(+), 3098 deletions(-) delete mode 100644 test/data/determined/chan_d5a19_T.stim delete mode 100644 test/data/determined/chan_d5a19f13_T.stim delete mode 100644 test/data/determined/chan_d5a19f13_uncorrected_T.stim delete mode 100644 test/data/determined/clifft_d5_T.stim delete mode 100644 test/data/determined/clifft_d5_T_rule1.stim delete mode 100644 test/data/determined/clifft_d5_T_rule12.stim delete mode 100644 test/data/determined/clifft_d5_sproxy.stim delete mode 100644 test/data/determined/wan_clifft_d3_T.stim delete mode 100644 test/data/determined/wan_soft_d5_T.stim diff --git a/test/data/determined/README.md b/test/data/determined/README.md index 1ed692c4..83381a96 100644 --- a/test/data/determined/README.md +++ b/test/data/determined/README.md @@ -1,10 +1,9 @@ -# Cultivation circuits with T gates +# A cultivation circuit with T gates -Noiseless copies of published magic state cultivation circuits, for the -integration tests in `test/integration/test_determined_literature.py`. - -| file | source | -|---|---| -| `chan_d5a19[f13][_uncorrected]_T.stim` | Chan, Strikis, Sun, Cai, arXiv:2609.17706, [timchan0/cliffordea](https://github.com/timchan0/cliffordea) `sim/stim_files/` at `27385c6` (MIT). S proxies, with S/S_DAG swapped for T/T_DAG as in `circuit_text.swap_t_and_s_gates`. The `_uncorrected` ones are the inputs of the paper's d=5 correction (`sim/d5-correction.md`). | -| `clifft_d5_sproxy.stim`, `clifft_d5_T*.stim` | Clifft, arXiv:2604.27058, [unitaryfoundation/clifft-paper](https://github.com/unitaryfoundation/clifft-paper) `magic_state_cultivation/convert_s_to_t.py` (Apache-2.0). Gidney's d=5 inject+cultivate S proxy; `_T_rule1` only swaps S for T, `_T_rule12` also applies the errata flips, `_T` is the full conversion with feedforward and detector healing. | -| `wan_clifft_d3_T.stim`, `wan_soft_d5_T.stim` | Wan and Zapirain, arXiv:2609.18922, [kh428/exact_ler_for_msc](https://github.com/kh428/exact_ler_for_msc) `data/inputs/` at `332bc04` (Apache-2.0): Clifft's d=3 and SOFT's d=5 native-T circuits. | +`chan_d5a19_uncorrected_T.stim`, for +`test/integration/test_determined_literature.py`, is a noiseless d=5 magic +state cultivation circuit from Chan, Strikis, Sun, Cai, arXiv:2609.17706, +[timchan0/cliffordea](https://github.com/timchan0/cliffordea) +`sim/stim_files/` at `27385c6` (MIT): an S proxy with S/S_DAG swapped for +T/T_DAG as in `circuit_text.swap_t_and_s_gates`, before the paper's d=5 +correction (`sim/d5-correction.md`). diff --git a/test/data/determined/chan_d5a19_T.stim b/test/data/determined/chan_d5a19_T.stim deleted file mode 100644 index 54bd68e5..00000000 --- a/test/data/determined/chan_d5a19_T.stim +++ /dev/null @@ -1,373 +0,0 @@ -QUBIT_COORDS(0, 0) 0 -QUBIT_COORDS(0, 1) 1 -QUBIT_COORDS(1, 0) 2 -QUBIT_COORDS(1, 1) 3 -QUBIT_COORDS(1, 2) 4 -QUBIT_COORDS(1, 3) 5 -QUBIT_COORDS(2, 0) 6 -QUBIT_COORDS(2, 1) 7 -QUBIT_COORDS(2, 2) 8 -QUBIT_COORDS(2, 3) 9 -QUBIT_COORDS(2, 4) 10 -QUBIT_COORDS(3, 0) 11 -QUBIT_COORDS(3, 1) 12 -QUBIT_COORDS(3, 2) 13 -QUBIT_COORDS(3, 3) 14 -QUBIT_COORDS(3, 4) 15 -QUBIT_COORDS(3, 5) 16 -QUBIT_COORDS(4, 0) 17 -QUBIT_COORDS(4, 1) 18 -QUBIT_COORDS(4, 2) 19 -QUBIT_COORDS(4, 3) 20 -QUBIT_COORDS(4, 4) 21 -QUBIT_COORDS(4, 5) 22 -QUBIT_COORDS(4, 6) 23 -QUBIT_COORDS(5, 0) 24 -QUBIT_COORDS(5, 1) 25 -QUBIT_COORDS(5, 2) 26 -QUBIT_COORDS(5, 3) 27 -QUBIT_COORDS(5, 4) 28 -QUBIT_COORDS(5, 5) 29 -QUBIT_COORDS(5, 6) 30 -QUBIT_COORDS(6, 0) 31 -QUBIT_COORDS(6, 1) 32 -QUBIT_COORDS(6, 2) 33 -QUBIT_COORDS(6, 3) 34 -QUBIT_COORDS(6, 4) 35 -QUBIT_COORDS(7, 0) 36 -QUBIT_COORDS(7, 1) 37 -QUBIT_COORDS(7, 2) 38 -QUBIT_COORDS(7, 3) 39 -QUBIT_COORDS(8, 0) 40 -QUBIT_COORDS(8, 1) 41 -R 12 8 6 -RX 7 11 13 3 2 4 18 0 5 17 -TICK -CX 7 12 11 6 13 8 -TICK -CX 7 8 11 12 -TICK -CX 7 6 13 12 -TICK -CX 2 6 4 8 18 12 -TICK -CX 6 2 8 4 12 18 -TICK -CX 3 4 17 18 -TICK -CX 3 2 18 17 -TICK -CX 4 3 -TICK -CX 2 3 -TICK -T 3 -TICK -CX 2 3 -TICK -CX 4 3 -TICK -CX 0 2 5 4 -TICK -CX 2 0 4 5 -TICK -R 6 18 8 9 -RX 2 12 4 -TICK -CX 2 6 4 8 5 9 12 18 -TICK -CX 2 0 6 11 8 13 9 5 12 7 -TICK -CX 2 3 6 7 8 9 12 13 -TICK -CX 4 3 8 7 12 11 18 17 -TICK -CX 3 4 7 8 11 12 17 18 -TICK -CX 0 2 7 12 11 6 13 8 -TICK -CX 3 2 7 6 9 8 13 12 -TICK -CX 2 6 4 8 12 18 -TICK -M 6 18 8 5 -MX 2 12 4 -DETECTOR(2, 0, 0) rec[-7] -DETECTOR(4, 1, 0) rec[-6] -DETECTOR(2, 2, 0) rec[-5] -DETECTOR(1, 3, 0) rec[-4] -DETECTOR(1, 0, 0) rec[-3] -DETECTOR(3, 1, 0) rec[-2] -DETECTOR(1, 2, 0) rec[-1] -TICK -RX 18 12 6 2 8 1 -TICK -T 3 11 13 -T_DAG 0 7 9 17 -TICK -CX 1 0 2 3 6 7 8 9 12 11 18 17 -TICK -CX 3 1 7 8 12 18 -TICK -CX 7 3 12 13 -TICK -CX 7 12 -TICK -MX 7 -DETECTOR(1, 2, 1) rec[-1] rec[-2] rec[-3] -TICK -RX 7 -TICK -CX 7 12 -TICK -CX 7 3 12 13 -TICK -CX 3 1 7 8 12 18 -TICK -CX 1 0 2 3 6 7 8 9 12 11 18 17 -TICK -T 0 7 9 17 -T_DAG 3 11 13 -TICK -MX 18 12 6 2 8 1 -DETECTOR(4, 1, 2) rec[-6] -DETECTOR(3, 1, 2) rec[-5] -DETECTOR(2, 1, 2) rec[-4] rec[-7] -DETECTOR(1, 0, 2) rec[-3] -DETECTOR(2, 2, 2) rec[-2] -DETECTOR(0, 1, 2) rec[-1] -TICK -R 19 25 32 38 40 23 15 22 21 29 34 -RX 26 33 36 16 28 27 -TICK -CX 16 22 26 19 27 34 28 21 33 38 36 40 -TICK -CX 16 15 22 23 26 25 28 29 33 32 -TICK -CX 15 16 23 22 25 26 29 28 32 33 -TICK -M 26 33 28 22 16 -DETECTOR(5, 2, 3) rec[-5] -DETECTOR(6, 2, 3) rec[-4] -DETECTOR(5, 4, 3) rec[-3] -DETECTOR(4, 5, 3) rec[-2] -DETECTOR(3, 5, 3) rec[-1] -TICK -R 41 35 33 31 22 20 18 8 6 -RX 37 28 26 24 16 14 12 4 2 -TICK -CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 -TICK -CX 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 -TICK -CX 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 -TICK -CX 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 -TICK -CX 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 -TICK -CX 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 -TICK -CX 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 -TICK -CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 -TICK -M 41 35 33 31 22 20 18 8 6 -MX 37 28 26 24 16 14 12 4 2 -DETECTOR(8, 1, 4) rec[-18] -DETECTOR(6, 4, 4) rec[-17] -DETECTOR(6, 2, 4) rec[-16] -DETECTOR(4, 5, 4) rec[-14] -DETECTOR(4, 1, 4) rec[-12] -DETECTOR(2, 2, 4) rec[-11] -DETECTOR(2, 0, 4) rec[-10] -DETECTOR(7, 1, 4) rec[-9] -DETECTOR(5, 4, 4) rec[-8] -DETECTOR(5, 2, 4) rec[-7] -DETECTOR(3, 5, 4) rec[-5] -DETECTOR(2, 1, 4) rec[-3] rec[-30] -DETECTOR(1, 2, 4) rec[-2] rec[-30] -DETECTOR(1, 0, 4) rec[-1] rec[-30] -TICK -CZ rec[-6] 36 rec[-6] 40 rec[-4] 15 rec[-4] 23 -CX rec[-15] 36 rec[-15] 40 rec[-15] 38 rec[-15] 40 rec[-16] 36 rec[-16] 40 rec[-12] 15 rec[-12] 23 rec[-13] 0 rec[-13] 11 rec[-13] 23 rec[-14] 15 rec[-14] 23 -R 41 35 33 31 22 20 18 8 6 -RX 37 28 26 24 16 14 12 4 2 -TICK -CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 -TICK -CX 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 -TICK -CX 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 -TICK -CX 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 -TICK -CX 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 -TICK -CX 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 -TICK -CX 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 -TICK -CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 -TICK -M 41 35 33 31 22 20 18 8 6 -MX 37 28 26 24 16 14 12 4 2 -DETECTOR(8, 1, 5) rec[-18] -DETECTOR(6, 2, 5) rec[-17] -DETECTOR(6, 0, 5) rec[-16] rec[-35] -DETECTOR(6, 0.5, 5) rec[-15] -DETECTOR(4, 3, 5) rec[-14] -DETECTOR(4, 1, 5) rec[-13] -DETECTOR(4, 2, 5) rec[-12] -DETECTOR(2, 0, 5) rec[-11] rec[-28] -DETECTOR(2, 2, 5) rec[-10] rec[-28] rec[-29] -DETECTOR(7, 1, 5) rec[-9] rec[-27] -DETECTOR(5, 4, 5) rec[-8] rec[-26] -DETECTOR(5, 2, 5) rec[-7] rec[-25] -DETECTOR(5, 0, 5) rec[-6] -DETECTOR(3, 5, 5) rec[-5] rec[-23] -DETECTOR(3, 3, 5) rec[-4] -DETECTOR(3, 1, 5) rec[-3] rec[-21] -DETECTOR(1, 2, 5) rec[-2] rec[-20] -DETECTOR(1, 0, 5) rec[-1] rec[-19] -TICK -R 41 35 33 31 22 20 18 8 6 -RX 37 28 26 24 16 14 12 4 2 -TICK -CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 -TICK -CX 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 -TICK -CX 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 -TICK -CX 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 -TICK -CX 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 -TICK -CX 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 -TICK -CX 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 -TICK -CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 -TICK -M 41 35 33 31 22 20 18 8 6 -MX 37 28 26 24 16 14 12 4 2 -DETECTOR(8, 1, 6) rec[-18] -DETECTOR(6, 2, 6) rec[-17] rec[-34] -DETECTOR(6, 0, 6) rec[-16] rec[-33] rec[-35] -DETECTOR(6, 0.5, 6) rec[-15] rec[-33] rec[-34] -DETECTOR(4, 3, 6) rec[-14] rec[-31] -DETECTOR(4, 1, 6) rec[-13] rec[-30] rec[-32] -DETECTOR(4, 2, 6) rec[-12] rec[-31] -DETECTOR(2, 0, 6) rec[-11] rec[-28] -DETECTOR(2, 2, 6) rec[-10] rec[-28] rec[-29] -DETECTOR(7, 1, 6) rec[-9] rec[-27] -DETECTOR(5, 4, 6) rec[-8] rec[-26] -DETECTOR(5, 2, 6) rec[-7] rec[-25] -DETECTOR(5, 0, 6) rec[-6] rec[-24] -DETECTOR(3, 5, 6) rec[-5] rec[-23] -DETECTOR(3, 3, 6) rec[-4] rec[-22] -DETECTOR(3, 1, 6) rec[-3] rec[-21] -DETECTOR(1, 2, 6) rec[-2] rec[-20] -DETECTOR(1, 0, 6) rec[-1] rec[-19] -TICK -RX 24 31 2 6 8 10 20 22 39 1 12 18 37 33 14 26 28 30 41 -TICK -T 3 11 13 25 15 27 29 36 38 -T_DAG 0 7 9 17 19 21 23 32 34 40 -TICK -CX 1 0 2 3 6 7 8 13 10 15 12 11 14 9 18 17 20 27 22 29 24 25 26 19 28 21 30 23 31 32 33 34 37 36 39 38 41 40 -TICK -CX 3 1 14 15 29 30 33 38 37 41 -TICK -CX 7 3 13 14 26 33 28 29 32 37 -TICK -CX 12 13 25 32 27 28 -TICK -CX 12 7 26 27 -TICK -CX 18 12 25 26 -TICK -CX 25 18 -TICK -MX 25 -DETECTOR(0, 1, 7) rec[-1] rec[-12] rec[-13] rec[-14] rec[-15] rec[-17] rec[-18] rec[-19] rec[-30] rec[-31] rec[-32] rec[-33] rec[-35] rec[-36] rec[-37] rec[-48] rec[-49] rec[-51] rec[-53] rec[-54] rec[-55] rec[-61] rec[-62] rec[-65] rec[-66] -TICK -RX 25 -TICK -CX 25 18 -TICK -CX 18 12 25 26 -TICK -CX 12 7 26 27 -TICK -CX 12 13 25 32 27 28 -TICK -CX 7 3 13 14 26 33 28 29 32 37 -TICK -CX 3 1 14 15 29 30 33 38 37 41 -TICK -CX 1 0 2 3 6 7 8 13 10 15 12 11 14 9 18 17 20 27 22 29 24 25 26 19 28 21 30 23 31 32 33 34 37 36 39 38 41 40 -TICK -T 0 7 9 17 19 21 23 32 34 40 -T_DAG 3 11 13 25 15 27 29 36 38 -TICK -MX 20 22 8 10 2 6 24 31 39 1 12 18 37 33 14 26 28 30 41 -DETECTOR(4, 3, 8) rec[-19] -DETECTOR(4, 5, 8) rec[-18] -DETECTOR(2, 2, 8) rec[-17] -DETECTOR(2, 4, 8) rec[-16] -DETECTOR(1, 0, 8) rec[-15] -DETECTOR(2, 0, 8) rec[-14] -DETECTOR(5, 1, 8) rec[-13] rec[-20] -DETECTOR(6, 0, 8) rec[-12] -DETECTOR(7, 3, 8) rec[-11] -DETECTOR(0, 1, 8) rec[-10] -DETECTOR(3, 1, 8) rec[-9] -DETECTOR(4, 1, 8) rec[-8] -DETECTOR(7, 1, 8) rec[-7] -DETECTOR(6, 2, 8) rec[-6] -DETECTOR(3, 3, 8) rec[-5] -DETECTOR(5, 2, 8) rec[-4] -DETECTOR(5, 4, 8) rec[-3] -DETECTOR(5, 6, 8) rec[-2] -DETECTOR(8, 1, 8) rec[-1] -TICK -T 3 11 13 25 15 27 29 36 38 -T_DAG 0 7 9 17 19 21 23 32 34 40 -TICK -MPP X0*X3*X7*X9*X11*X13*X15*X17*X19*X21*X23*X25*X27*X29*X32*X34*X36*X38*X40 -OBSERVABLE_INCLUDE(0) rec[-1] rec[-2] rec[-3] rec[-4] rec[-5] rec[-6] rec[-7] rec[-8] rec[-9] rec[-10] rec[-11] -TICK -T 0 7 9 17 19 21 23 32 34 40 -T_DAG 3 11 13 25 15 27 29 36 38 -TICK -MPP X0*X3*X7*X11 X9*X13*X15*X19*X21*X27 X17*X25*X32*X36 -DETECTOR(1, 0, 9) rec[-3] rec[-25] -DETECTOR(3, 3, 9) rec[-2] rec[-28] -DETECTOR(5, 0, 9) rec[-1] rec[-24] rec[-30] -TICK -MPP Z0*Z3*Z7*Z11 Z9*Z13*Z15*Z19*Z21*Z27 Z17*Z25*Z32*Z36 -DETECTOR(2, 0, 10) rec[-3] rec[-37] rec[-38] -DETECTOR(4, 1, 10) rec[-2] rec[-39] rec[-41] -DETECTOR(6, 0, 10) rec[-1] rec[-42] rec[-43] -TICK -MPP X3*X7*X9*X13 X15*X21*X23*X29 X19*X25*X27*X32*X34*X38 -DETECTOR(1, 2, 11) rec[-3] rec[-32] -DETECTOR(3, 5, 11) rec[-2] rec[-35] -DETECTOR(5, 2, 11) rec[-1] rec[-30] rec[-37] -TICK -MPP Z3*Z7*Z9*Z13 Z15*Z21*Z23*Z29 Z19*Z25*Z27*Z32*Z34*Z38 -DETECTOR(2, 0, 12) rec[-3] rec[-43] -DETECTOR(4, 3, 12) rec[-2] rec[-46] -DETECTOR(6, 0, 12) rec[-1] rec[-48] rec[-50] -TICK -MPP X7*X11*X13*X17*X19*X25 X21*X27*X29*X34 X32*X36*X38*X40 -DETECTOR(3, 1, 13) rec[-3] rec[-36] rec[-39] -DETECTOR(5, 4, 13) rec[-2] rec[-44] -DETECTOR(7, 1, 13) rec[-1] rec[-45] -TICK -MPP Z7*Z11*Z13*Z17*Z19*Z25 Z21*Z27*Z29*Z34 Z32*Z36*Z38*Z40 -DETECTOR(4, 3, 14) rec[-3] rec[-52] -DETECTOR(6, 2, 14) rec[-2] rec[-55] -DETECTOR(6, 1, 14) rec[-1] diff --git a/test/data/determined/chan_d5a19f13_T.stim b/test/data/determined/chan_d5a19f13_T.stim deleted file mode 100644 index 4acfcd9b..00000000 --- a/test/data/determined/chan_d5a19f13_T.stim +++ /dev/null @@ -1,421 +0,0 @@ -QUBIT_COORDS(0, 0) 0 -QUBIT_COORDS(0, 1) 1 -QUBIT_COORDS(1, 0) 2 -QUBIT_COORDS(1, 1) 3 -QUBIT_COORDS(1, 2) 4 -QUBIT_COORDS(1, 3) 5 -QUBIT_COORDS(1.5, 0.5) 6 -QUBIT_COORDS(2, 0) 7 -QUBIT_COORDS(2, 1) 8 -QUBIT_COORDS(2, 2) 9 -QUBIT_COORDS(2, 3) 10 -QUBIT_COORDS(2, 4) 11 -QUBIT_COORDS(2.5, 0.5) 12 -QUBIT_COORDS(2.5, 1.5) 13 -QUBIT_COORDS(2.5, 2.5) 14 -QUBIT_COORDS(3, 0) 15 -QUBIT_COORDS(3, 1) 16 -QUBIT_COORDS(3, 2) 17 -QUBIT_COORDS(3, 3) 18 -QUBIT_COORDS(3, 4) 19 -QUBIT_COORDS(3, 5) 20 -QUBIT_COORDS(3.5, 0.5) 21 -QUBIT_COORDS(4, 0) 22 -QUBIT_COORDS(4, 1) 23 -QUBIT_COORDS(4, 2) 24 -QUBIT_COORDS(4, 3) 25 -QUBIT_COORDS(4, 4) 26 -QUBIT_COORDS(4, 5) 27 -QUBIT_COORDS(4, 6) 28 -QUBIT_COORDS(4.5, 0.5) 29 -QUBIT_COORDS(4.5, 1.5) 30 -QUBIT_COORDS(4.5, 2.5) 31 -QUBIT_COORDS(4.5, 3.5) 32 -QUBIT_COORDS(4.5, 4.5) 33 -QUBIT_COORDS(5, 0) 34 -QUBIT_COORDS(5, 1) 35 -QUBIT_COORDS(5, 2) 36 -QUBIT_COORDS(5, 3) 37 -QUBIT_COORDS(5, 4) 38 -QUBIT_COORDS(5, 5) 39 -QUBIT_COORDS(5, 6) 40 -QUBIT_COORDS(5.5, 0.5) 41 -QUBIT_COORDS(5.5, 1.5) 42 -QUBIT_COORDS(6, 0) 43 -QUBIT_COORDS(6, 1) 44 -QUBIT_COORDS(6, 2) 45 -QUBIT_COORDS(6, 3) 46 -QUBIT_COORDS(6, 4) 47 -QUBIT_COORDS(6.5, 0.5) 48 -QUBIT_COORDS(7, 0) 49 -QUBIT_COORDS(7, 1) 50 -QUBIT_COORDS(7, 2) 51 -QUBIT_COORDS(7, 3) 52 -QUBIT_COORDS(8, 0) 53 -QUBIT_COORDS(8, 1) 54 -R 16 9 7 -RX 8 15 17 3 2 4 23 0 5 22 -TICK -CX 8 16 15 7 17 9 -TICK -CX 8 9 15 16 -TICK -CX 8 7 17 16 -TICK -CX 2 7 4 9 23 16 -TICK -CX 7 2 9 4 16 23 -TICK -CX 3 4 22 23 -TICK -CX 3 2 23 22 -TICK -CX 4 3 -TICK -CX 2 3 -TICK -T 3 -TICK -CX 2 3 -TICK -CX 4 3 -TICK -CX 0 2 5 4 -TICK -CX 2 0 4 5 -TICK -R 7 23 9 10 -RX 2 16 4 -TICK -CX 2 7 4 9 5 10 16 23 -TICK -CX 2 0 7 15 9 17 10 5 16 8 -TICK -CX 2 3 7 8 9 10 16 17 -TICK -CX 4 3 9 8 16 15 23 22 -TICK -CX 3 4 8 9 15 16 22 23 -TICK -CX 0 2 8 16 15 7 17 9 -TICK -CX 3 2 8 7 10 9 17 16 -TICK -CX 2 7 4 9 16 23 -TICK -M 7 23 9 5 -MX 2 16 4 -DETECTOR(2, 0, 0) rec[-7] -DETECTOR(4, 1, 0) rec[-6] -DETECTOR(2, 2, 0) rec[-5] -DETECTOR(1, 3, 0) rec[-4] -DETECTOR(1, 0, 0) rec[-3] -DETECTOR(3, 1, 0) rec[-2] -DETECTOR(1, 2, 0) rec[-1] -TICK -RX 23 16 7 2 9 1 -TICK -T 3 15 17 -T_DAG 0 8 10 22 -TICK -CX 1 0 2 3 7 8 9 10 16 15 23 22 -R 6 12 -TICK -CX 3 6 8 12 -TICK -CX 8 6 16 12 -TICK -CX 3 1 8 9 16 23 -TICK -CX 8 3 16 17 -TICK -CX 8 16 -TICK -MX 8 -DETECTOR(1, 2, 1) rec[-1] rec[-2] rec[-3] -TICK -RX 8 -TICK -CX 8 16 -TICK -CX 8 3 16 17 -TICK -CX 3 1 8 9 16 23 -TICK -CX 8 6 16 12 -TICK -CX 3 6 8 12 -TICK -CX 1 0 2 3 7 8 9 10 16 15 23 22 -M 6 12 -DETECTOR(1.5, 0.5, 2) rec[-2] -DETECTOR(2.5, 0.5, 2) rec[-1] -TICK -T 0 8 10 22 -T_DAG 3 15 17 -TICK -MX 23 16 7 2 9 1 -DETECTOR(4, 1, 3) rec[-6] -DETECTOR(3, 1, 3) rec[-5] -DETECTOR(2, 1, 3) rec[-4] rec[-9] -DETECTOR(1, 0, 3) rec[-3] -DETECTOR(2, 2, 3) rec[-2] -DETECTOR(0, 1, 3) rec[-1] -TICK -R 24 35 44 51 53 28 19 27 26 39 46 -RX 36 45 49 20 38 37 -TICK -CX 20 27 36 24 37 46 38 26 45 51 49 53 -TICK -CX 20 19 27 28 36 35 38 39 45 44 -TICK -CX 19 20 28 27 35 36 39 38 44 45 -TICK -M 36 45 38 27 20 -DETECTOR(5, 2, 4) rec[-5] -DETECTOR(6, 2, 4) rec[-4] -DETECTOR(5, 4, 4) rec[-3] -DETECTOR(4, 5, 4) rec[-2] -DETECTOR(3, 5, 4) rec[-1] -TICK -R 54 47 45 43 27 25 23 9 7 -RX 50 38 36 34 20 18 16 4 2 -TICK -CX 2 7 4 9 16 23 18 25 20 27 34 43 36 45 38 47 50 54 -TICK -CX 3 4 8 9 15 16 17 18 19 20 22 23 24 25 26 27 35 36 37 38 44 45 46 47 49 50 53 54 -TICK -CX 3 2 8 7 10 9 17 16 19 18 24 23 26 25 28 27 35 34 37 36 39 38 44 43 46 45 51 50 -TICK -CX 0 2 8 16 10 18 15 7 17 9 22 34 24 36 26 38 35 23 37 25 39 27 44 50 49 43 51 45 -TICK -CX 4 3 9 8 16 15 18 17 20 19 23 22 25 24 27 26 36 35 38 37 45 44 47 46 50 49 54 53 -TICK -CX 2 3 7 8 9 10 16 17 18 19 23 24 25 26 27 28 34 35 36 37 38 39 43 44 45 46 50 51 -TICK -CX 2 0 7 15 9 17 16 8 18 10 23 35 25 37 27 39 34 22 36 24 38 26 43 49 45 51 50 44 -TICK -CX 2 7 4 9 16 23 18 25 20 27 34 43 36 45 38 47 50 54 -TICK -M 54 47 45 43 27 25 23 9 7 -MX 50 38 36 34 20 18 16 4 2 -DETECTOR(8, 1, 5) rec[-18] -DETECTOR(6, 4, 5) rec[-17] -DETECTOR(6, 2, 5) rec[-16] -DETECTOR(4, 5, 5) rec[-14] -DETECTOR(4, 1, 5) rec[-12] -DETECTOR(2, 2, 5) rec[-11] -DETECTOR(2, 0, 5) rec[-10] -DETECTOR(7, 1, 5) rec[-9] -DETECTOR(5, 4, 5) rec[-8] -DETECTOR(5, 2, 5) rec[-7] -DETECTOR(3, 5, 5) rec[-5] -DETECTOR(2, 1, 5) rec[-3] rec[-32] -DETECTOR(1, 2, 5) rec[-2] rec[-32] -DETECTOR(1, 0, 5) rec[-1] rec[-32] -TICK -CZ rec[-6] 49 rec[-6] 53 rec[-4] 19 rec[-4] 28 -CX rec[-15] 49 rec[-15] 53 rec[-15] 51 rec[-15] 53 rec[-16] 49 rec[-16] 53 rec[-12] 19 rec[-12] 28 rec[-13] 0 rec[-13] 15 rec[-13] 28 rec[-14] 19 rec[-14] 28 -R 54 47 45 43 27 25 23 9 7 -RX 50 38 36 34 20 18 16 4 2 -TICK -CX 2 7 4 9 16 23 18 25 20 27 34 43 36 45 38 47 50 54 -TICK -CX 3 4 8 9 15 16 17 18 19 20 22 23 24 25 26 27 35 36 37 38 44 45 46 47 49 50 53 54 -TICK -CX 3 2 8 7 10 9 17 16 19 18 24 23 26 25 28 27 35 34 37 36 39 38 44 43 46 45 51 50 -TICK -CX 0 2 8 16 10 18 15 7 17 9 22 34 24 36 26 38 35 23 37 25 39 27 44 50 49 43 51 45 -TICK -CX 4 3 9 8 16 15 18 17 20 19 23 22 25 24 27 26 36 35 38 37 45 44 47 46 50 49 54 53 -TICK -CX 2 3 7 8 9 10 16 17 18 19 23 24 25 26 27 28 34 35 36 37 38 39 43 44 45 46 50 51 -TICK -CX 2 0 7 15 9 17 16 8 18 10 23 35 25 37 27 39 34 22 36 24 38 26 43 49 45 51 50 44 -TICK -CX 2 7 4 9 16 23 18 25 20 27 34 43 36 45 38 47 50 54 -TICK -M 54 47 45 43 27 25 23 9 7 -MX 50 38 36 34 20 18 16 4 2 -DETECTOR(8, 1, 6) rec[-18] -DETECTOR(6, 2, 6) rec[-17] -DETECTOR(6, 0, 6) rec[-16] rec[-35] -DETECTOR(6, 0.5, 6) rec[-15] -DETECTOR(4, 3, 6) rec[-14] -DETECTOR(4, 1, 6) rec[-13] -DETECTOR(4, 2, 6) rec[-12] -DETECTOR(2, 0, 6) rec[-11] rec[-28] -DETECTOR(2, 2, 6) rec[-10] rec[-28] rec[-29] -DETECTOR(7, 1, 6) rec[-9] rec[-27] -DETECTOR(5, 4, 6) rec[-8] rec[-26] -DETECTOR(5, 2, 6) rec[-7] rec[-25] -DETECTOR(5, 0, 6) rec[-6] -DETECTOR(3, 5, 6) rec[-5] rec[-23] -DETECTOR(3, 3, 6) rec[-4] -DETECTOR(3, 1, 6) rec[-3] rec[-21] -DETECTOR(1, 2, 6) rec[-2] rec[-20] -DETECTOR(1, 0, 6) rec[-1] rec[-19] -TICK -R 54 47 45 43 27 25 23 9 7 -RX 50 38 36 34 20 18 16 4 2 -TICK -CX 2 7 4 9 16 23 18 25 20 27 34 43 36 45 38 47 50 54 -TICK -CX 3 4 8 9 15 16 17 18 19 20 22 23 24 25 26 27 35 36 37 38 44 45 46 47 49 50 53 54 -TICK -CX 3 2 8 7 10 9 17 16 19 18 24 23 26 25 28 27 35 34 37 36 39 38 44 43 46 45 51 50 -TICK -CX 0 2 8 16 10 18 15 7 17 9 22 34 24 36 26 38 35 23 37 25 39 27 44 50 49 43 51 45 -TICK -CX 4 3 9 8 16 15 18 17 20 19 23 22 25 24 27 26 36 35 38 37 45 44 47 46 50 49 54 53 -TICK -CX 2 3 7 8 9 10 16 17 18 19 23 24 25 26 27 28 34 35 36 37 38 39 43 44 45 46 50 51 -TICK -CX 2 0 7 15 9 17 16 8 18 10 23 35 25 37 27 39 34 22 36 24 38 26 43 49 45 51 50 44 -TICK -CX 2 7 4 9 16 23 18 25 20 27 34 43 36 45 38 47 50 54 -TICK -M 54 47 45 43 27 25 23 9 7 -MX 50 38 36 34 20 18 16 4 2 -DETECTOR(8, 1, 7) rec[-18] -DETECTOR(6, 2, 7) rec[-17] rec[-34] -DETECTOR(6, 0, 7) rec[-16] rec[-33] rec[-35] -DETECTOR(6, 0.5, 7) rec[-15] rec[-33] rec[-34] -DETECTOR(4, 3, 7) rec[-14] rec[-31] -DETECTOR(4, 1, 7) rec[-13] rec[-30] rec[-32] -DETECTOR(4, 2, 7) rec[-12] rec[-31] -DETECTOR(2, 0, 7) rec[-11] rec[-28] -DETECTOR(2, 2, 7) rec[-10] rec[-28] rec[-29] -DETECTOR(7, 1, 7) rec[-9] rec[-27] -DETECTOR(5, 4, 7) rec[-8] rec[-26] -DETECTOR(5, 2, 7) rec[-7] rec[-25] -DETECTOR(5, 0, 7) rec[-6] rec[-24] -DETECTOR(3, 5, 7) rec[-5] rec[-23] -DETECTOR(3, 3, 7) rec[-4] rec[-22] -DETECTOR(3, 1, 7) rec[-3] rec[-21] -DETECTOR(1, 2, 7) rec[-2] rec[-20] -DETECTOR(1, 0, 7) rec[-1] rec[-19] -TICK -RX 34 43 2 7 9 11 25 27 52 1 16 23 50 45 18 36 38 40 54 -TICK -T 3 15 17 35 19 37 39 49 51 -T_DAG 0 8 10 22 24 26 28 44 46 53 -TICK -CX 1 0 2 3 7 8 9 17 11 19 16 15 18 10 23 22 25 37 27 39 34 35 36 24 38 26 40 28 43 44 45 46 50 49 52 51 54 53 -R 21 13 30 14 32 33 -TICK -CX 16 21 17 13 36 30 18 14 38 32 39 33 -R 6 12 48 41 42 31 -TICK -CX 18 19 39 40 3 6 8 12 16 13 17 14 35 30 36 31 37 32 38 33 45 42 44 41 50 48 -TICK -CX 17 18 38 39 3 1 50 54 45 51 8 6 16 12 37 31 35 41 44 48 36 42 -R 29 -TICK -CX 16 17 37 38 8 3 23 21 35 29 44 50 36 45 -TICK -CX 16 8 36 37 23 29 35 44 -TICK -CX 23 16 35 36 -TICK -CX 35 23 -TICK -MX 35 -DETECTOR(0, 1, 8) rec[-1] rec[-12] rec[-13] rec[-14] rec[-15] rec[-17] rec[-18] rec[-19] rec[-30] rec[-31] rec[-32] rec[-33] rec[-35] rec[-36] rec[-37] rec[-48] rec[-49] rec[-51] rec[-53] rec[-54] rec[-55] rec[-61] rec[-62] rec[-65] rec[-66] -TICK -RX 35 -TICK -CX 35 23 -TICK -CX 23 16 35 36 -TICK -CX 16 8 36 37 23 29 35 44 -TICK -CX 16 17 37 38 8 3 23 21 35 29 44 50 36 45 -TICK -CX 17 18 38 39 3 1 8 6 16 12 37 31 35 41 36 42 44 48 45 51 50 54 -M 29 -DETECTOR(4.5, 0.5, 9) rec[-1] -TICK -CX 18 19 39 40 3 6 8 12 16 13 17 14 35 30 36 31 37 32 38 33 45 42 44 41 50 48 -TICK -CX 16 21 17 13 18 14 36 30 38 32 39 33 -M 6 12 31 42 41 48 -DETECTOR(1.5, 0.5, 10) rec[-6] -DETECTOR(2.5, 0.5, 10) rec[-5] -DETECTOR(4.5, 2.5, 10) rec[-4] -DETECTOR(5.5, 1.5, 10) rec[-3] -DETECTOR(5.5, 0.5, 10) rec[-2] -DETECTOR(6.5, 0.5, 10) rec[-1] -TICK -CX 1 0 2 3 7 8 9 17 11 19 16 15 18 10 23 22 25 37 27 39 34 35 36 24 38 26 40 28 43 44 45 46 50 49 52 51 54 53 -M 21 13 30 14 32 33 -DETECTOR(3.5, 0.5, 11) rec[-6] -DETECTOR(2.5, 1.5, 11) rec[-5] -DETECTOR(4.5, 1.5, 11) rec[-4] -DETECTOR(2.5, 2.5, 11) rec[-3] -DETECTOR(4.5, 3.5, 11) rec[-2] -DETECTOR(4.5, 4.5, 11) rec[-1] -TICK -T 0 8 10 22 24 26 28 44 46 53 -T_DAG 3 15 17 35 19 37 39 49 51 -TICK -MX 25 27 9 11 2 7 34 43 52 1 16 23 50 45 18 36 38 40 54 -DETECTOR(4, 3, 12) rec[-19] -DETECTOR(4, 5, 12) rec[-18] -DETECTOR(2, 2, 12) rec[-17] -DETECTOR(2, 4, 12) rec[-16] -DETECTOR(1, 0, 12) rec[-15] -DETECTOR(2, 0, 12) rec[-14] -DETECTOR(5, 1, 12) rec[-13] rec[-33] -DETECTOR(6, 0, 12) rec[-12] -DETECTOR(7, 3, 12) rec[-11] -DETECTOR(0, 1, 12) rec[-10] -DETECTOR(3, 1, 12) rec[-9] -DETECTOR(4, 1, 12) rec[-8] -DETECTOR(7, 1, 12) rec[-7] -DETECTOR(6, 2, 12) rec[-6] -DETECTOR(3, 3, 12) rec[-5] -DETECTOR(5, 2, 12) rec[-4] -DETECTOR(5, 4, 12) rec[-3] -DETECTOR(5, 6, 12) rec[-2] -DETECTOR(8, 1, 12) rec[-1] -TICK -T 3 15 17 35 19 37 39 49 51 -T_DAG 0 8 10 22 24 26 28 44 46 53 -TICK -MPP X0*X3*X8*X10*X15*X17*X19*X22*X24*X26*X28*X35*X37*X39*X44*X46*X49*X51*X53 -OBSERVABLE_INCLUDE(0) rec[-1] rec[-2] rec[-3] rec[-4] rec[-5] rec[-6] rec[-7] rec[-8] rec[-9] rec[-10] rec[-11] -TICK -T 0 8 10 22 24 26 28 44 46 53 -T_DAG 3 15 17 35 19 37 39 49 51 -TICK -MPP X0*X3*X8*X15 X10*X17*X19*X24*X26*X37 X22*X35*X44*X49 -DETECTOR(1, 0, 13) rec[-3] rec[-38] -DETECTOR(3, 3, 13) rec[-2] rec[-41] -DETECTOR(5, 0, 13) rec[-1] rec[-37] rec[-43] -TICK -MPP Z0*Z3*Z8*Z15 Z10*Z17*Z19*Z24*Z26*Z37 Z22*Z35*Z44*Z49 -DETECTOR(2, 0, 14) rec[-3] rec[-50] rec[-51] -DETECTOR(4, 1, 14) rec[-2] rec[-52] rec[-54] -DETECTOR(6, 0, 14) rec[-1] rec[-55] rec[-56] -TICK -MPP X3*X8*X10*X17 X19*X26*X28*X39 X24*X35*X37*X44*X46*X51 -DETECTOR(1, 2, 15) rec[-3] rec[-45] -DETECTOR(3, 5, 15) rec[-2] rec[-48] -DETECTOR(5, 2, 15) rec[-1] rec[-43] rec[-50] -TICK -MPP Z3*Z8*Z10*Z17 Z19*Z26*Z28*Z39 Z24*Z35*Z37*Z44*Z46*Z51 -DETECTOR(2, 0, 16) rec[-3] rec[-56] -DETECTOR(4, 3, 16) rec[-2] rec[-59] -DETECTOR(6, 0, 16) rec[-1] rec[-61] rec[-63] -TICK -MPP X8*X15*X17*X22*X24*X35 X26*X37*X39*X46 X44*X49*X51*X53 -DETECTOR(3, 1, 17) rec[-3] rec[-49] rec[-52] -DETECTOR(5, 4, 17) rec[-2] rec[-57] -DETECTOR(7, 1, 17) rec[-1] rec[-58] -TICK -MPP Z8*Z15*Z17*Z22*Z24*Z35 Z26*Z37*Z39*Z46 Z44*Z49*Z51*Z53 -DETECTOR(4, 3, 18) rec[-3] rec[-65] -DETECTOR(6, 2, 18) rec[-2] rec[-68] -DETECTOR(6, 1, 18) rec[-1] diff --git a/test/data/determined/chan_d5a19f13_uncorrected_T.stim b/test/data/determined/chan_d5a19f13_uncorrected_T.stim deleted file mode 100644 index 7d11168d..00000000 --- a/test/data/determined/chan_d5a19f13_uncorrected_T.stim +++ /dev/null @@ -1,419 +0,0 @@ -QUBIT_COORDS(0, 0) 0 -QUBIT_COORDS(0, 1) 1 -QUBIT_COORDS(1, 0) 2 -QUBIT_COORDS(1, 1) 3 -QUBIT_COORDS(1, 2) 4 -QUBIT_COORDS(1, 3) 5 -QUBIT_COORDS(1.5, 0.5) 6 -QUBIT_COORDS(2, 0) 7 -QUBIT_COORDS(2, 1) 8 -QUBIT_COORDS(2, 2) 9 -QUBIT_COORDS(2, 3) 10 -QUBIT_COORDS(2, 4) 11 -QUBIT_COORDS(2.5, 0.5) 12 -QUBIT_COORDS(2.5, 1.5) 13 -QUBIT_COORDS(2.5, 2.5) 14 -QUBIT_COORDS(3, 0) 15 -QUBIT_COORDS(3, 1) 16 -QUBIT_COORDS(3, 2) 17 -QUBIT_COORDS(3, 3) 18 -QUBIT_COORDS(3, 4) 19 -QUBIT_COORDS(3, 5) 20 -QUBIT_COORDS(3.5, 0.5) 21 -QUBIT_COORDS(4, 0) 22 -QUBIT_COORDS(4, 1) 23 -QUBIT_COORDS(4, 2) 24 -QUBIT_COORDS(4, 3) 25 -QUBIT_COORDS(4, 4) 26 -QUBIT_COORDS(4, 5) 27 -QUBIT_COORDS(4, 6) 28 -QUBIT_COORDS(4.5, 0.5) 29 -QUBIT_COORDS(4.5, 1.5) 30 -QUBIT_COORDS(4.5, 2.5) 31 -QUBIT_COORDS(4.5, 3.5) 32 -QUBIT_COORDS(4.5, 4.5) 33 -QUBIT_COORDS(5, 0) 34 -QUBIT_COORDS(5, 1) 35 -QUBIT_COORDS(5, 2) 36 -QUBIT_COORDS(5, 3) 37 -QUBIT_COORDS(5, 4) 38 -QUBIT_COORDS(5, 5) 39 -QUBIT_COORDS(5, 6) 40 -QUBIT_COORDS(5.5, 0.5) 41 -QUBIT_COORDS(5.5, 1.5) 42 -QUBIT_COORDS(6, 0) 43 -QUBIT_COORDS(6, 1) 44 -QUBIT_COORDS(6, 2) 45 -QUBIT_COORDS(6, 3) 46 -QUBIT_COORDS(6, 4) 47 -QUBIT_COORDS(6.5, 0.5) 48 -QUBIT_COORDS(7, 0) 49 -QUBIT_COORDS(7, 1) 50 -QUBIT_COORDS(7, 2) 51 -QUBIT_COORDS(7, 3) 52 -QUBIT_COORDS(8, 0) 53 -QUBIT_COORDS(8, 1) 54 -R 16 9 7 -RX 8 15 17 3 2 4 23 0 5 22 -TICK -CX 8 16 15 7 17 9 -TICK -CX 8 9 15 16 -TICK -CX 8 7 17 16 -TICK -CX 2 7 4 9 23 16 -TICK -CX 7 2 9 4 16 23 -TICK -CX 3 4 22 23 -TICK -CX 3 2 23 22 -TICK -CX 4 3 -TICK -CX 2 3 -TICK -T 3 -TICK -CX 2 3 -TICK -CX 4 3 -TICK -CX 0 2 5 4 -TICK -CX 2 0 4 5 -TICK -R 7 23 9 10 -RX 2 16 4 -TICK -CX 2 7 4 9 5 10 16 23 -TICK -CX 2 0 7 15 9 17 10 5 16 8 -TICK -CX 2 3 7 8 9 10 16 17 -TICK -CX 4 3 9 8 16 15 23 22 -TICK -CX 3 4 8 9 15 16 22 23 -TICK -CX 0 2 8 16 15 7 17 9 -TICK -CX 3 2 8 7 10 9 17 16 -TICK -CX 2 7 4 9 16 23 -TICK -M 7 23 9 5 -MX 2 16 4 -DETECTOR(2, 0, 0) rec[-7] -DETECTOR(4, 1, 0) rec[-6] -DETECTOR(2, 2, 0) rec[-5] -DETECTOR(1, 3, 0) rec[-4] -DETECTOR(1, 0, 0) rec[-3] -DETECTOR(3, 1, 0) rec[-2] -DETECTOR(1, 2, 0) rec[-1] -TICK -RX 23 16 7 2 9 1 -TICK -T 3 15 17 -T_DAG 0 8 10 22 -TICK -CX 1 0 2 3 7 8 9 10 16 15 23 22 -R 6 12 -TICK -CX 3 6 8 12 -TICK -CX 8 6 16 12 -TICK -CX 3 1 8 9 16 23 -TICK -CX 8 3 16 17 -TICK -CX 8 16 -TICK -MX 8 -DETECTOR(1, 2, 1) rec[-1] rec[-2] rec[-3] -TICK -RX 8 -TICK -CX 8 16 -TICK -CX 8 3 16 17 -TICK -CX 3 1 8 9 16 23 -TICK -CX 8 6 16 12 -TICK -CX 3 6 8 12 -TICK -CX 1 0 2 3 7 8 9 10 16 15 23 22 -M 6 12 -DETECTOR(1.5, 0.5, 2) rec[-2] -DETECTOR(2.5, 0.5, 2) rec[-1] -TICK -T 0 8 10 22 -T_DAG 3 15 17 -TICK -MX 23 16 7 2 9 1 -DETECTOR(4, 1, 3) rec[-6] -DETECTOR(3, 1, 3) rec[-5] -DETECTOR(2, 1, 3) rec[-4] rec[-9] -DETECTOR(1, 0, 3) rec[-3] -DETECTOR(2, 2, 3) rec[-2] -DETECTOR(0, 1, 3) rec[-1] -TICK -R 24 35 44 51 53 28 19 27 26 39 46 -RX 36 45 49 20 38 37 -TICK -CX 20 27 36 24 37 46 38 26 45 51 49 53 -TICK -CX 20 19 27 28 36 35 38 39 45 44 -TICK -CX 19 20 28 27 35 36 39 38 44 45 -TICK -M 36 45 38 27 20 -DETECTOR(5, 2, 4) rec[-5] -DETECTOR(6, 2, 4) rec[-4] -DETECTOR(5, 4, 4) rec[-3] -DETECTOR(4, 5, 4) rec[-2] -DETECTOR(3, 5, 4) rec[-1] -TICK -R 54 47 45 43 27 25 23 9 7 -RX 50 38 36 34 20 18 16 4 2 -TICK -CX 2 7 4 9 16 23 18 25 20 27 34 43 36 45 38 47 50 54 -TICK -CX 3 4 8 9 15 16 17 18 19 20 22 23 24 25 26 27 35 36 37 38 44 45 46 47 49 50 53 54 -TICK -CX 3 2 8 7 10 9 17 16 19 18 24 23 26 25 28 27 35 34 37 36 39 38 44 43 46 45 51 50 -TICK -CX 0 2 8 16 10 18 15 7 17 9 22 34 24 36 26 38 35 23 37 25 39 27 44 50 49 43 51 45 -TICK -CX 4 3 9 8 16 15 18 17 20 19 23 22 25 24 27 26 36 35 38 37 45 44 47 46 50 49 54 53 -TICK -CX 2 3 7 8 9 10 16 17 18 19 23 24 25 26 27 28 34 35 36 37 38 39 43 44 45 46 50 51 -TICK -CX 2 0 7 15 9 17 16 8 18 10 23 35 25 37 27 39 34 22 36 24 38 26 43 49 45 51 50 44 -TICK -CX 2 7 4 9 16 23 18 25 20 27 34 43 36 45 38 47 50 54 -TICK -M 54 47 45 43 27 25 23 9 7 -MX 50 38 36 34 20 18 16 4 2 -DETECTOR(8, 1, 5) rec[-18] -DETECTOR(6, 4, 5) rec[-17] -DETECTOR(6, 2, 5) rec[-16] -DETECTOR(4, 5, 5) rec[-14] -DETECTOR(4, 1, 5) rec[-12] -DETECTOR(2, 2, 5) rec[-11] -DETECTOR(2, 0, 5) rec[-10] -DETECTOR(7, 1, 5) rec[-9] -DETECTOR(5, 4, 5) rec[-8] -DETECTOR(5, 2, 5) rec[-7] -DETECTOR(3, 5, 5) rec[-5] -DETECTOR(2, 1, 5) rec[-3] rec[-32] -DETECTOR(1, 2, 5) rec[-2] rec[-32] -DETECTOR(1, 0, 5) rec[-1] rec[-32] -TICK -R 54 47 45 43 27 25 23 9 7 -RX 50 38 36 34 20 18 16 4 2 -TICK -CX 2 7 4 9 16 23 18 25 20 27 34 43 36 45 38 47 50 54 -TICK -CX 3 4 8 9 15 16 17 18 19 20 22 23 24 25 26 27 35 36 37 38 44 45 46 47 49 50 53 54 -TICK -CX 3 2 8 7 10 9 17 16 19 18 24 23 26 25 28 27 35 34 37 36 39 38 44 43 46 45 51 50 -TICK -CX 0 2 8 16 10 18 15 7 17 9 22 34 24 36 26 38 35 23 37 25 39 27 44 50 49 43 51 45 -TICK -CX 4 3 9 8 16 15 18 17 20 19 23 22 25 24 27 26 36 35 38 37 45 44 47 46 50 49 54 53 -TICK -CX 2 3 7 8 9 10 16 17 18 19 23 24 25 26 27 28 34 35 36 37 38 39 43 44 45 46 50 51 -TICK -CX 2 0 7 15 9 17 16 8 18 10 23 35 25 37 27 39 34 22 36 24 38 26 43 49 45 51 50 44 -TICK -CX 2 7 4 9 16 23 18 25 20 27 34 43 36 45 38 47 50 54 -TICK -M 54 47 45 43 27 25 23 9 7 -MX 50 38 36 34 20 18 16 4 2 -DETECTOR(8, 1, 6) rec[-18] -DETECTOR(6, 2, 6) rec[-17] rec[-34] -DETECTOR(6, 0, 6) rec[-16] rec[-33] rec[-35] -DETECTOR(6, 0.5, 6) rec[-15] rec[-33] rec[-34] -DETECTOR(4, 3, 6) rec[-14] rec[-31] -DETECTOR(4, 1, 6) rec[-13] rec[-30] rec[-32] -DETECTOR(4, 2, 6) rec[-12] rec[-31] -DETECTOR(2, 0, 6) rec[-11] rec[-28] -DETECTOR(2, 2, 6) rec[-10] rec[-28] rec[-29] -DETECTOR(7, 1, 6) rec[-9] rec[-27] -DETECTOR(5, 4, 6) rec[-8] rec[-26] -DETECTOR(5, 2, 6) rec[-7] rec[-25] -DETECTOR(5, 0, 6) rec[-6] rec[-24] -DETECTOR(3, 5, 6) rec[-5] rec[-23] -DETECTOR(3, 3, 6) rec[-4] rec[-22] -DETECTOR(3, 1, 6) rec[-3] rec[-21] -DETECTOR(1, 2, 6) rec[-2] rec[-20] -DETECTOR(1, 0, 6) rec[-1] rec[-19] -TICK -R 54 47 45 43 27 25 23 9 7 -RX 50 38 36 34 20 18 16 4 2 -TICK -CX 2 7 4 9 16 23 18 25 20 27 34 43 36 45 38 47 50 54 -TICK -CX 3 4 8 9 15 16 17 18 19 20 22 23 24 25 26 27 35 36 37 38 44 45 46 47 49 50 53 54 -TICK -CX 3 2 8 7 10 9 17 16 19 18 24 23 26 25 28 27 35 34 37 36 39 38 44 43 46 45 51 50 -TICK -CX 0 2 8 16 10 18 15 7 17 9 22 34 24 36 26 38 35 23 37 25 39 27 44 50 49 43 51 45 -TICK -CX 4 3 9 8 16 15 18 17 20 19 23 22 25 24 27 26 36 35 38 37 45 44 47 46 50 49 54 53 -TICK -CX 2 3 7 8 9 10 16 17 18 19 23 24 25 26 27 28 34 35 36 37 38 39 43 44 45 46 50 51 -TICK -CX 2 0 7 15 9 17 16 8 18 10 23 35 25 37 27 39 34 22 36 24 38 26 43 49 45 51 50 44 -TICK -CX 2 7 4 9 16 23 18 25 20 27 34 43 36 45 38 47 50 54 -TICK -M 54 47 45 43 27 25 23 9 7 -MX 50 38 36 34 20 18 16 4 2 -DETECTOR(8, 1, 7) rec[-18] -DETECTOR(6, 2, 7) rec[-17] rec[-34] -DETECTOR(6, 0, 7) rec[-16] rec[-33] rec[-35] -DETECTOR(6, 0.5, 7) rec[-15] rec[-33] rec[-34] -DETECTOR(4, 3, 7) rec[-14] rec[-31] -DETECTOR(4, 1, 7) rec[-13] rec[-30] rec[-32] -DETECTOR(4, 2, 7) rec[-12] rec[-31] -DETECTOR(2, 0, 7) rec[-11] rec[-28] -DETECTOR(2, 2, 7) rec[-10] rec[-28] rec[-29] -DETECTOR(7, 1, 7) rec[-9] rec[-27] -DETECTOR(5, 4, 7) rec[-8] rec[-26] -DETECTOR(5, 2, 7) rec[-7] rec[-25] -DETECTOR(5, 0, 7) rec[-6] rec[-24] -DETECTOR(3, 5, 7) rec[-5] rec[-23] -DETECTOR(3, 3, 7) rec[-4] rec[-22] -DETECTOR(3, 1, 7) rec[-3] rec[-21] -DETECTOR(1, 2, 7) rec[-2] rec[-20] -DETECTOR(1, 0, 7) rec[-1] rec[-19] -TICK -RX 34 43 2 7 9 11 25 27 52 1 16 23 50 45 18 36 38 40 54 -TICK -T 3 15 17 35 19 37 39 49 51 -T_DAG 0 8 10 22 24 26 28 44 46 53 -TICK -CX 1 0 2 3 7 8 9 17 11 19 16 15 18 10 23 22 25 37 27 39 34 35 36 24 38 26 40 28 43 44 45 46 50 49 52 51 54 53 -R 21 13 30 14 32 33 -TICK -CX 16 21 17 13 36 30 18 14 38 32 39 33 -R 6 12 48 41 42 31 -TICK -CX 18 19 39 40 3 6 8 12 16 13 17 14 35 30 36 31 37 32 38 33 45 42 44 41 50 48 -TICK -CX 17 18 38 39 3 1 50 54 45 51 8 6 16 12 37 31 35 41 44 48 36 42 -R 29 -TICK -CX 16 17 37 38 8 3 23 21 35 29 44 50 36 45 -TICK -CX 16 8 36 37 23 29 35 44 -TICK -CX 23 16 35 36 -TICK -CX 35 23 -TICK -MX 35 -DETECTOR(0, 1, 8) rec[-1] rec[-12] rec[-13] rec[-14] rec[-15] rec[-17] rec[-18] rec[-19] rec[-30] rec[-31] rec[-32] rec[-33] rec[-35] rec[-36] rec[-37] rec[-48] rec[-49] rec[-50] rec[-51] rec[-53] rec[-54] rec[-55] rec[-61] rec[-62] rec[-65] rec[-66] -TICK -RX 35 -TICK -CX 35 23 -TICK -CX 23 16 35 36 -TICK -CX 16 8 36 37 23 29 35 44 -TICK -CX 16 17 37 38 8 3 23 21 35 29 44 50 36 45 -TICK -CX 17 18 38 39 3 1 8 6 16 12 37 31 35 41 36 42 44 48 45 51 50 54 -M 29 -DETECTOR(4.5, 0.5, 9) rec[-1] -TICK -CX 18 19 39 40 3 6 8 12 16 13 17 14 35 30 36 31 37 32 38 33 45 42 44 41 50 48 -TICK -CX 16 21 17 13 18 14 36 30 38 32 39 33 -M 6 12 31 42 41 48 -DETECTOR(1.5, 0.5, 10) rec[-6] -DETECTOR(2.5, 0.5, 10) rec[-5] -DETECTOR(4.5, 2.5, 10) rec[-4] -DETECTOR(5.5, 1.5, 10) rec[-3] -DETECTOR(5.5, 0.5, 10) rec[-2] -DETECTOR(6.5, 0.5, 10) rec[-1] -TICK -CX 1 0 2 3 7 8 9 17 11 19 16 15 18 10 23 22 25 37 27 39 34 35 36 24 38 26 40 28 43 44 45 46 50 49 52 51 54 53 -M 21 13 30 14 32 33 -DETECTOR(3.5, 0.5, 11) rec[-6] -DETECTOR(2.5, 1.5, 11) rec[-5] -DETECTOR(4.5, 1.5, 11) rec[-4] -DETECTOR(2.5, 2.5, 11) rec[-3] -DETECTOR(4.5, 3.5, 11) rec[-2] -DETECTOR(4.5, 4.5, 11) rec[-1] -TICK -T 0 8 10 22 24 26 28 44 46 53 -T_DAG 3 15 17 35 19 37 39 49 51 -TICK -MX 25 27 9 11 2 7 34 43 52 1 16 23 50 45 18 36 38 40 54 -DETECTOR(4, 3, 12) rec[-19] -DETECTOR(4, 5, 12) rec[-18] -DETECTOR(2, 2, 12) rec[-17] -DETECTOR(2, 4, 12) rec[-16] -DETECTOR(1, 0, 12) rec[-15] -DETECTOR(2, 0, 12) rec[-14] -DETECTOR(5, 1, 12) rec[-13] rec[-33] -DETECTOR(6, 0, 12) rec[-12] -DETECTOR(7, 3, 12) rec[-11] -DETECTOR(0, 1, 12) rec[-10] -DETECTOR(3, 1, 12) rec[-9] -DETECTOR(4, 1, 12) rec[-8] -DETECTOR(7, 1, 12) rec[-7] -DETECTOR(6, 2, 12) rec[-6] -DETECTOR(3, 3, 12) rec[-5] -DETECTOR(5, 2, 12) rec[-4] -DETECTOR(5, 4, 12) rec[-3] -DETECTOR(5, 6, 12) rec[-2] -DETECTOR(8, 1, 12) rec[-1] -TICK -T 3 15 17 35 19 37 39 49 51 -T_DAG 0 8 10 22 24 26 28 44 46 53 -TICK -MPP X0*X3*X8*X10*X15*X17*X19*X22*X24*X26*X28*X35*X37*X39*X44*X46*X49*X51*X53 -OBSERVABLE_INCLUDE(0) rec[-1] rec[-2] rec[-3] rec[-4] rec[-5] rec[-6] rec[-7] rec[-8] rec[-9] rec[-10] rec[-11] -TICK -T 0 8 10 22 24 26 28 44 46 53 -T_DAG 3 15 17 35 19 37 39 49 51 -TICK -MPP X0*X3*X8*X15 X10*X17*X19*X24*X26*X37 X22*X35*X44*X49 -DETECTOR(1, 0, 13) rec[-3] rec[-38] -DETECTOR(3, 3, 13) rec[-2] rec[-41] -DETECTOR(5, 0, 13) rec[-1] rec[-37] rec[-43] -TICK -MPP Z0*Z3*Z8*Z15 Z10*Z17*Z19*Z24*Z26*Z37 Z22*Z35*Z44*Z49 -DETECTOR(2, 0, 14) rec[-3] rec[-50] rec[-51] -DETECTOR(4, 1, 14) rec[-2] rec[-52] rec[-54] -DETECTOR(6, 0, 14) rec[-1] rec[-55] rec[-56] -TICK -MPP X3*X8*X10*X17 X19*X26*X28*X39 X24*X35*X37*X44*X46*X51 -DETECTOR(1, 2, 15) rec[-3] rec[-45] -DETECTOR(3, 5, 15) rec[-2] rec[-48] -DETECTOR(5, 2, 15) rec[-1] rec[-43] rec[-50] -TICK -MPP Z3*Z8*Z10*Z17 Z19*Z26*Z28*Z39 Z24*Z35*Z37*Z44*Z46*Z51 -DETECTOR(2, 0, 16) rec[-3] rec[-56] -DETECTOR(4, 3, 16) rec[-2] rec[-59] -DETECTOR(6, 0, 16) rec[-1] rec[-61] rec[-63] -TICK -MPP X8*X15*X17*X22*X24*X35 X26*X37*X39*X46 X44*X49*X51*X53 -DETECTOR(3, 1, 17) rec[-3] rec[-49] rec[-52] -DETECTOR(5, 4, 17) rec[-2] rec[-57] -DETECTOR(7, 1, 17) rec[-1] rec[-58] -TICK -MPP Z8*Z15*Z17*Z22*Z24*Z35 Z26*Z37*Z39*Z46 Z44*Z49*Z51*Z53 -DETECTOR(4, 3, 18) rec[-3] rec[-65] -DETECTOR(6, 2, 18) rec[-2] rec[-68] -DETECTOR(6, 1, 18) rec[-1] diff --git a/test/data/determined/clifft_d5_T.stim b/test/data/determined/clifft_d5_T.stim deleted file mode 100644 index 8317f64c..00000000 --- a/test/data/determined/clifft_d5_T.stim +++ /dev/null @@ -1,359 +0,0 @@ -QUBIT_COORDS(0, 0) 0 -QUBIT_COORDS(0, 1) 1 -QUBIT_COORDS(1, 0) 2 -QUBIT_COORDS(1, 1) 3 -QUBIT_COORDS(1, 2) 4 -QUBIT_COORDS(1, 3) 5 -QUBIT_COORDS(2, 0) 6 -QUBIT_COORDS(2, 1) 7 -QUBIT_COORDS(2, 2) 8 -QUBIT_COORDS(2, 3) 9 -QUBIT_COORDS(2, 4) 10 -QUBIT_COORDS(3, 0) 11 -QUBIT_COORDS(3, 1) 12 -QUBIT_COORDS(3, 2) 13 -QUBIT_COORDS(3, 3) 14 -QUBIT_COORDS(3, 4) 15 -QUBIT_COORDS(3, 5) 16 -QUBIT_COORDS(4, 0) 17 -QUBIT_COORDS(4, 1) 18 -QUBIT_COORDS(4, 2) 19 -QUBIT_COORDS(4, 3) 20 -QUBIT_COORDS(4, 4) 21 -QUBIT_COORDS(4, 5) 22 -QUBIT_COORDS(4, 6) 23 -QUBIT_COORDS(5, 0) 24 -QUBIT_COORDS(5, 1) 25 -QUBIT_COORDS(5, 2) 26 -QUBIT_COORDS(5, 3) 27 -QUBIT_COORDS(5, 4) 28 -QUBIT_COORDS(5, 5) 29 -QUBIT_COORDS(5, 6) 30 -QUBIT_COORDS(6, 0) 31 -QUBIT_COORDS(6, 1) 32 -QUBIT_COORDS(6, 2) 33 -QUBIT_COORDS(6, 3) 34 -QUBIT_COORDS(6, 4) 35 -QUBIT_COORDS(7, 0) 36 -QUBIT_COORDS(7, 1) 37 -QUBIT_COORDS(7, 2) 38 -QUBIT_COORDS(7, 3) 39 -QUBIT_COORDS(8, 0) 40 -QUBIT_COORDS(8, 1) 41 -RX 7 11 13 3 2 4 18 0 5 17 -R 12 8 6 -TICK -CX 7 12 11 6 13 8 -TICK -CX 7 8 11 12 -TICK -CX 7 6 13 12 -TICK -CX 2 6 4 8 18 12 -TICK -CX 6 2 8 4 12 18 -TICK -CX 3 4 17 18 -TICK -CX 3 2 18 17 -TICK -CX 4 3 -TICK -CX 2 3 -TICK -T_DAG 3 -TICK -CX 2 3 -TICK -CX 4 3 -TICK -CX 0 2 5 4 -TICK -CX 2 0 4 5 -TICK -RX 2 12 4 -R 6 18 8 9 -TICK -CX 2 6 4 8 5 9 12 18 -TICK -CX 2 0 6 11 8 13 9 5 12 7 -TICK -CX 2 3 6 7 8 9 12 13 -TICK -CX 4 3 8 7 12 11 18 17 -TICK -CX 3 4 7 8 11 12 17 18 -TICK -CX 0 2 7 12 11 6 13 8 -TICK -CX 3 2 7 6 9 8 13 12 -TICK -CX 2 6 4 8 12 18 -TICK -M 6 18 8 5 -MX 2 12 4 -DETECTOR(2, 0, 0) rec[-7] -DETECTOR(4, 1, 0) rec[-6] -DETECTOR(2, 2, 0) rec[-5] -DETECTOR(1, 3, 0) rec[-4] -DETECTOR(1, 0, 0) rec[-3] -DETECTOR(3, 1, 0) rec[-2] -DETECTOR(1, 2, 0) rec[-1] -TICK -RX 18 12 6 2 8 1 -TICK -T_DAG 0 3 7 9 11 13 17 -TICK -CX 1 0 2 3 6 7 8 9 12 11 18 17 -TICK -CX 3 1 7 8 12 18 -TICK -CX 7 3 12 13 -TICK -CX 7 12 -TICK -MX 7 -TICK -RX 7 -TICK -CX 7 12 -TICK -CX 7 3 12 13 -TICK -CX 3 1 7 8 12 18 -TICK -CX 1 0 2 3 6 7 8 9 12 11 18 17 -TICK -T 0 3 7 9 11 13 17 -TICK -MX 18 12 6 2 8 1 -DETECTOR(2.14286, 1, 1, -1, -9) rec[-9] rec[-8] rec[-7] -DETECTOR(4, 1, 2) rec[-6] -DETECTOR(3, 1, 2) rec[-5] -DETECTOR(2, 1, 2) rec[-4] rec[-7] -DETECTOR(1, 0, 2) rec[-3] -DETECTOR(2, 2, 2) rec[-2] -DETECTOR(0, 1, 2) rec[-1] -TICK -RX 26 33 36 16 28 27 -R 19 25 32 38 40 23 15 22 21 29 34 -TICK -CX 16 22 26 19 27 34 28 21 33 38 36 40 -TICK -CX 16 15 22 23 26 25 28 29 33 32 -TICK -CX 15 16 23 22 25 26 29 28 32 33 -TICK -M 26 33 28 22 16 -DETECTOR(5, 2, 4) rec[-5] -DETECTOR(6, 2, 4) rec[-4] -DETECTOR(5, 4, 4) rec[-3] -DETECTOR(4, 5, 4) rec[-2] -DETECTOR(3, 5, 4) rec[-1] -TICK -RX 37 28 26 24 16 14 12 4 2 -R 41 35 33 31 22 20 18 8 6 -TICK -CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 -TICK -CX 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 -TICK -CX 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 -TICK -CX 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 -TICK -CX 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 -TICK -CX 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 -TICK -CX 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 -TICK -CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 -TICK -M 41 35 33 31 22 20 18 8 6 -MX 37 28 26 24 16 14 12 4 2 -DETECTOR(1.25, 0.25, 5, -1, -9) rec[-30] rec[-1] -DETECTOR(1.5, 1.875, 5, -1, -9) rec[-30] rec[-2] -DETECTOR(1.75, 0.25, 5, -1, -9) rec[-10] -DETECTOR(2, 1.875, 5, -1, -9) rec[-11] -DETECTOR(3.075, 0.9125, 5, -1, -9) rec[-30] rec[-3] -DETECTOR(3.5, 4.875, 5, -1, -9) rec[-5] -DETECTOR(3.575, 0.9125, 5, -1, -9) rec[-12] -DETECTOR(4, 4.875, 5, -1, -9) rec[-14] -DETECTOR(5.25, 2, 5, -1, -9) rec[-7] -DETECTOR(5, 3.875, 5, -1, -9) rec[-8] -DETECTOR(5.75, 2, 5, -1, -9) rec[-16] -DETECTOR(5.5, 3.875, 5, -1, -9) rec[-17] -DETECTOR(7, 0.875, 5, -1, -9) rec[-9] -DETECTOR(7.5, 0.875, 5, -1, -9) rec[-18] -TICK -CZ rec[-6] 36 rec[-6] 40 rec[-4] 15 rec[-4] 23 -CX rec[-15] 36 rec[-15] 40 rec[-15] 38 rec[-15] 40 rec[-16] 36 rec[-16] 40 rec[-12] 15 rec[-12] 23 rec[-13] 0 rec[-13] 11 rec[-13] 23 rec[-14] 15 rec[-14] 23 -RX 37 28 26 24 16 14 12 4 2 -R 41 35 33 31 22 20 18 8 6 -TICK -CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 -TICK -CX 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 -TICK -CX 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 -TICK -CX 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 -TICK -CX 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 -TICK -CX 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 -TICK -CX 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 -TICK -CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 -TICK -M 41 35 33 31 22 20 18 8 6 -MX 37 28 26 24 16 14 12 4 2 -DETECTOR(1, 0, 6, -1, -9) rec[-19] rec[-1] -DETECTOR(1, 2, 6, -1, -9) rec[-20] rec[-2] -DETECTOR(2, 0, 6, -1, -9) rec[-29] rec[-28] rec[-10] -DETECTOR(2, 2, 6, -1, -9) rec[-28] rec[-11] -DETECTOR(3, 1, 6, -1, -9) rec[-21] rec[-3] -DETECTOR(3, 3, 6, -1, -9) rec[-4] -DETECTOR(3, 5, 6, -1, -9) rec[-23] rec[-5] -DETECTOR(4, 1, 6, -1, -9) rec[-12] -DETECTOR(4, 3, 6, -1, -9) rec[-13] -DETECTOR(4, 5, 6, -1, -9) rec[-14] -DETECTOR(5, 0, 6, -1, -9) rec[-6] -DETECTOR(5, 2, 6, -1, -9) rec[-25] rec[-7] -DETECTOR(5, 4, 6, -1, -9) rec[-26] rec[-8] -DETECTOR(6, 0, 6, -1, -9) rec[-15] -DETECTOR(6, 2, 6, -1, -9) rec[-35] rec[-16] -DETECTOR(6, 4, 6, -1, -9) rec[-17] -DETECTOR(7, 1, 6, -1, -9) rec[-27] rec[-9] -DETECTOR(8, 1, 6, -1, -9) rec[-18] -TICK -RX 37 28 26 24 16 14 12 4 2 -R 41 35 33 31 22 20 18 8 6 -TICK -CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 -TICK -CX 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 -TICK -CX 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 -TICK -CX 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 -TICK -CX 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 -TICK -CX 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 -TICK -CX 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 -TICK -CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 -TICK -M 41 35 33 31 22 20 18 8 6 -MX 37 28 26 24 16 14 12 4 2 -DETECTOR(1, 0, 7, -1, -9) rec[-19] rec[-1] -DETECTOR(1, 2, 7, -1, -9) rec[-20] rec[-2] -DETECTOR(2, 0, 7, -1, -9) rec[-29] rec[-28] rec[-10] -DETECTOR(2, 2, 7, -1, -9) rec[-28] rec[-11] -DETECTOR(3, 1, 7, -1, -9) rec[-21] rec[-3] -DETECTOR(3, 3, 7, -1, -9) rec[-22] rec[-4] -DETECTOR(3, 5, 7, -1, -9) rec[-23] rec[-5] -DETECTOR(4, 1, 7, -1, -9) rec[-31] rec[-12] -DETECTOR(4, 3, 7, -1, -9) rec[-32] rec[-30] rec[-13] -DETECTOR(4, 5, 7, -1, -9) rec[-31] rec[-14] -DETECTOR(5, 0, 7, -1, -9) rec[-24] rec[-6] -DETECTOR(5, 2, 7, -1, -9) rec[-25] rec[-7] -DETECTOR(5, 4, 7, -1, -9) rec[-26] rec[-8] -DETECTOR(6, 0, 7, -1, -9) rec[-34] rec[-33] rec[-15] -DETECTOR(6, 2, 7, -1, -9) rec[-35] rec[-33] rec[-16] -DETECTOR(6, 4, 7, -1, -9) rec[-34] rec[-17] -DETECTOR(7, 1, 7, -1, -9) rec[-27] rec[-9] -DETECTOR(8, 1, 7, -1, -9) rec[-18] -TICK -RX 24 31 2 6 8 10 20 22 39 1 12 18 37 33 14 26 28 30 41 -TICK -T_DAG 3 7 9 13 15 21 23 25 27 29 32 34 38 -T 0 11 17 19 36 40 -TICK -CX 1 0 2 3 6 7 8 13 10 15 12 11 14 9 18 17 20 27 22 29 24 25 26 19 28 21 30 23 31 32 33 34 37 36 39 38 41 40 -TICK -CX 3 1 14 15 29 30 33 38 37 41 -TICK -CX 7 3 13 14 26 33 28 29 32 37 -TICK -CX 12 13 25 32 27 28 -TICK -CX 12 7 26 27 -TICK -CX 18 12 25 26 -TICK -CX 25 18 -TICK -MX 25 -TICK -RX 25 -TICK -CX 25 18 -TICK -CX 18 12 25 26 -TICK -CX 12 7 26 27 -TICK -CX 12 13 25 32 27 28 -TICK -CX 7 3 13 14 26 33 28 29 32 37 -TICK -CX 3 1 14 15 29 30 33 38 37 41 -TICK -CX 1 0 2 3 6 7 8 13 10 15 12 11 14 9 18 17 20 27 22 29 24 25 26 19 28 21 30 23 31 32 33 34 37 36 39 38 41 40 -TICK -T 3 7 9 13 15 21 23 25 27 29 32 34 38 -T_DAG 0 11 17 19 36 40 -TICK -MX 20 22 8 10 2 6 24 31 39 1 12 18 37 33 14 26 28 30 41 -OBSERVABLE_INCLUDE(0) rec[-10] rec[-9] rec[-8] rec[-7] rec[-6] rec[-5] rec[-4] rec[-3] rec[-2] rec[-1] -DETECTOR(2.25889, 1.08534, 8, -1, -9) rec[-85] rec[-84] rec[-81] rec[-80] rec[-74] rec[-73] rec[-72] rec[-70] rec[-68] rec[-67] rec[-56] rec[-55] rec[-54] rec[-52] rec[-51] rec[-50] rec[-49] rec[-38] rec[-37] rec[-36] rec[-34] rec[-33] rec[-32] rec[-31] rec[-20] -DETECTOR(4, 3, 9) rec[-19] -DETECTOR(4, 5, 9) rec[-18] -DETECTOR(2, 2, 9) rec[-17] -DETECTOR(2, 4, 9) rec[-16] -DETECTOR(1, 0, 9) rec[-15] -DETECTOR(2, 0, 9) rec[-14] -DETECTOR(5, 1, 9) rec[-13] rec[-20] -DETECTOR(6, 0, 9) rec[-12] -DETECTOR(7, 3, 9) rec[-11] -DETECTOR(0, 1, 9) rec[-10] -DETECTOR(3, 1, 9) rec[-9] -DETECTOR(4, 1, 9) rec[-8] -DETECTOR(7, 1, 9) rec[-7] -DETECTOR(6, 2, 9) rec[-6] -DETECTOR(3, 3, 9) rec[-5] -DETECTOR(5, 2, 9) rec[-4] -DETECTOR(5, 4, 9) rec[-3] -DETECTOR(5, 6, 9) rec[-2] -DETECTOR(8, 1, 9) rec[-1] -TICK -T 3 7 9 13 15 21 23 25 27 29 32 34 38 -T_DAG 0 11 17 19 36 40 -MPP Y0*Y3*Y7*Y9*Y11*Y13*Y15*Y17*Y19*Y21*Y23*Y25*Y27*Y29*Y32*Y34*Y36*Y38*Y40 -T_DAG 3 7 9 13 15 21 23 25 27 29 32 34 38 -T 0 11 17 19 36 40 -MPP X0*X3*X7*X11 X9*X13*X15*X19*X21*X27 X17*X25*X32*X36 Z0*Z3*Z7*Z11 Z9*Z13*Z15*Z19*Z21*Z27 Z17*Z25*Z32*Z36 X3*X7*X9*X13 X15*X21*X23*X29 X19*X25*X27*X32*X34*X38 Z3*Z7*Z9*Z13 Z15*Z21*Z23*Z29 Z19*Z25*Z27*Z32*Z34*Z38 X7*X11*X13*X17*X19*X25 X21*X27*X29*X34 X32*X36*X38*X40 Z7*Z11*Z13*Z17*Z19*Z25 Z21*Z27*Z29*Z34 Z32*Z36*Z38*Z40 -OBSERVABLE_INCLUDE(0) rec[-19] -DETECTOR(0.625, 0.125, 11, -1, -9) rec[-40] rec[-18] -DETECTOR(0.875, 0.125, 11, -1, -9) rec[-50] rec[-49] rec[-15] -DETECTOR(1.25, 1.4375, 11, -1, -9) rec[-41] rec[-12] -DETECTOR(1.5, 1.4375, 11, -1, -9) rec[-49] rec[-9] -DETECTOR(2.625, 1, 11, -1, -9) rec[-42] rec[-39] rec[-6] -DETECTOR(2.875, 1, 11, -1, -9) rec[-52] rec[-3] -DETECTOR(2.625, 3, 11, -1, -9) rec[-43] rec[-17] -DETECTOR(2.875, 3, 11, -1, -9) rec[-53] rec[-51] rec[-14] -DETECTOR(3.25, 4.4375, 11, -1, -9) rec[-44] rec[-11] -DETECTOR(3.5, 4.4375, 11, -1, -9) rec[-52] rec[-8] -DETECTOR(4.625, 0.125, 11, -1, -9) rec[-45] rec[-39] rec[-16] -DETECTOR(4.875, 0.125, 11, -1, -9) rec[-55] rec[-54] rec[-13] -DETECTOR(4.625, 2, 11, -1, -9) rec[-46] rec[-39] rec[-10] -DETECTOR(4.875, 2, 11, -1, -9) rec[-56] rec[-54] rec[-7] -DETECTOR(4.5, 3.9375, 11, -1, -9) rec[-47] rec[-5] -DETECTOR(4.75, 3.9375, 11, -1, -9) rec[-55] rec[-2] -DETECTOR(6.5, 0.9375, 11, -1, -9) rec[-48] rec[-4] -DETECTOR(6.75, 0.9375, 11, -1, -9) rec[-1] diff --git a/test/data/determined/clifft_d5_T_rule1.stim b/test/data/determined/clifft_d5_T_rule1.stim deleted file mode 100644 index 1838ffab..00000000 --- a/test/data/determined/clifft_d5_T_rule1.stim +++ /dev/null @@ -1,353 +0,0 @@ -QUBIT_COORDS(0, 0) 0 -QUBIT_COORDS(0, 1) 1 -QUBIT_COORDS(1, 0) 2 -QUBIT_COORDS(1, 1) 3 -QUBIT_COORDS(1, 2) 4 -QUBIT_COORDS(1, 3) 5 -QUBIT_COORDS(2, 0) 6 -QUBIT_COORDS(2, 1) 7 -QUBIT_COORDS(2, 2) 8 -QUBIT_COORDS(2, 3) 9 -QUBIT_COORDS(2, 4) 10 -QUBIT_COORDS(3, 0) 11 -QUBIT_COORDS(3, 1) 12 -QUBIT_COORDS(3, 2) 13 -QUBIT_COORDS(3, 3) 14 -QUBIT_COORDS(3, 4) 15 -QUBIT_COORDS(3, 5) 16 -QUBIT_COORDS(4, 0) 17 -QUBIT_COORDS(4, 1) 18 -QUBIT_COORDS(4, 2) 19 -QUBIT_COORDS(4, 3) 20 -QUBIT_COORDS(4, 4) 21 -QUBIT_COORDS(4, 5) 22 -QUBIT_COORDS(4, 6) 23 -QUBIT_COORDS(5, 0) 24 -QUBIT_COORDS(5, 1) 25 -QUBIT_COORDS(5, 2) 26 -QUBIT_COORDS(5, 3) 27 -QUBIT_COORDS(5, 4) 28 -QUBIT_COORDS(5, 5) 29 -QUBIT_COORDS(5, 6) 30 -QUBIT_COORDS(6, 0) 31 -QUBIT_COORDS(6, 1) 32 -QUBIT_COORDS(6, 2) 33 -QUBIT_COORDS(6, 3) 34 -QUBIT_COORDS(6, 4) 35 -QUBIT_COORDS(7, 0) 36 -QUBIT_COORDS(7, 1) 37 -QUBIT_COORDS(7, 2) 38 -QUBIT_COORDS(7, 3) 39 -QUBIT_COORDS(8, 0) 40 -QUBIT_COORDS(8, 1) 41 -RX 7 11 13 3 2 4 18 0 5 17 -R 12 8 6 -TICK -CX 7 12 11 6 13 8 -TICK -CX 7 8 11 12 -TICK -CX 7 6 13 12 -TICK -CX 2 6 4 8 18 12 -TICK -CX 6 2 8 4 12 18 -TICK -CX 3 4 17 18 -TICK -CX 3 2 18 17 -TICK -CX 4 3 -TICK -CX 2 3 -TICK -T_DAG 3 -TICK -CX 2 3 -TICK -CX 4 3 -TICK -CX 0 2 5 4 -TICK -CX 2 0 4 5 -TICK -RX 2 12 4 -R 6 18 8 9 -TICK -CX 2 6 4 8 5 9 12 18 -TICK -CX 2 0 6 11 8 13 9 5 12 7 -TICK -CX 2 3 6 7 8 9 12 13 -TICK -CX 4 3 8 7 12 11 18 17 -TICK -CX 3 4 7 8 11 12 17 18 -TICK -CX 0 2 7 12 11 6 13 8 -TICK -CX 3 2 7 6 9 8 13 12 -TICK -CX 2 6 4 8 12 18 -TICK -M 6 18 8 5 -MX 2 12 4 -DETECTOR(2, 0, 0) rec[-7] -DETECTOR(4, 1, 0) rec[-6] -DETECTOR(2, 2, 0) rec[-5] -DETECTOR(1, 3, 0) rec[-4] -DETECTOR(1, 0, 0) rec[-3] -DETECTOR(3, 1, 0) rec[-2] -DETECTOR(1, 2, 0) rec[-1] -TICK -RX 18 12 6 2 8 1 -TICK -T_DAG 0 3 7 9 11 13 17 -TICK -CX 1 0 2 3 6 7 8 9 12 11 18 17 -TICK -CX 3 1 7 8 12 18 -TICK -CX 7 3 12 13 -TICK -CX 7 12 -TICK -MX 7 -TICK -RX 7 -TICK -CX 7 12 -TICK -CX 7 3 12 13 -TICK -CX 3 1 7 8 12 18 -TICK -CX 1 0 2 3 6 7 8 9 12 11 18 17 -TICK -T 0 3 7 9 11 13 17 -TICK -MX 18 12 6 2 8 1 -DETECTOR(2.14286, 1, 1, -1, -9) rec[-9] rec[-8] rec[-7] -DETECTOR(4, 1, 2) rec[-6] -DETECTOR(3, 1, 2) rec[-5] -DETECTOR(2, 1, 2) rec[-4] rec[-7] -DETECTOR(1, 0, 2) rec[-3] -DETECTOR(2, 2, 2) rec[-2] -DETECTOR(0, 1, 2) rec[-1] -TICK -RX 26 33 36 16 28 27 -R 19 25 32 38 40 23 15 22 21 29 34 -TICK -CX 16 22 26 19 27 34 28 21 33 38 36 40 -TICK -CX 16 15 22 23 26 25 28 29 33 32 -TICK -CX 15 16 23 22 25 26 29 28 32 33 -TICK -M 26 33 28 22 16 -DETECTOR(5, 2, 4) rec[-5] -DETECTOR(6, 2, 4) rec[-4] -DETECTOR(5, 4, 4) rec[-3] -DETECTOR(4, 5, 4) rec[-2] -DETECTOR(3, 5, 4) rec[-1] -TICK -RX 37 28 26 24 16 14 12 4 2 -R 41 35 33 31 22 20 18 8 6 -TICK -CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 -TICK -CX 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 -TICK -CX 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 -TICK -CX 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 -TICK -CX 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 -TICK -CX 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 -TICK -CX 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 -TICK -CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 -TICK -M 41 35 33 31 22 20 18 8 6 -MX 37 28 26 24 16 14 12 4 2 -DETECTOR(1.25, 0.25, 5, -1, -9) rec[-30] rec[-1] -DETECTOR(1.5, 1.875, 5, -1, -9) rec[-30] rec[-2] -DETECTOR(1.75, 0.25, 5, -1, -9) rec[-10] -DETECTOR(2, 1.875, 5, -1, -9) rec[-11] -DETECTOR(3.075, 0.9125, 5, -1, -9) rec[-30] rec[-3] -DETECTOR(3.5, 4.875, 5, -1, -9) rec[-5] -DETECTOR(3.575, 0.9125, 5, -1, -9) rec[-12] -DETECTOR(4, 4.875, 5, -1, -9) rec[-14] -DETECTOR(5.25, 2, 5, -1, -9) rec[-7] -DETECTOR(5, 3.875, 5, -1, -9) rec[-8] -DETECTOR(5.75, 2, 5, -1, -9) rec[-16] -DETECTOR(5.5, 3.875, 5, -1, -9) rec[-17] -DETECTOR(7, 0.875, 5, -1, -9) rec[-9] -DETECTOR(7.5, 0.875, 5, -1, -9) rec[-18] -TICK -RX 37 28 26 24 16 14 12 4 2 -R 41 35 33 31 22 20 18 8 6 -TICK -CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 -TICK -CX 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 -TICK -CX 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 -TICK -CX 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 -TICK -CX 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 -TICK -CX 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 -TICK -CX 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 -TICK -CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 -TICK -M 41 35 33 31 22 20 18 8 6 -MX 37 28 26 24 16 14 12 4 2 -DETECTOR(1, 0, 6, -1, -9) rec[-19] rec[-1] -DETECTOR(1, 2, 6, -1, -9) rec[-20] rec[-2] -DETECTOR(2, 0, 6, -1, -9) rec[-29] rec[-28] rec[-10] -DETECTOR(2, 2, 6, -1, -9) rec[-28] rec[-11] -DETECTOR(3, 1, 6, -1, -9) rec[-21] rec[-3] -DETECTOR(3, 3, 6, -1, -9) rec[-22] rec[-4] -DETECTOR(3, 5, 6, -1, -9) rec[-23] rec[-5] -DETECTOR(4, 1, 6, -1, -9) rec[-31] rec[-12] -DETECTOR(4, 3, 6, -1, -9) rec[-32] rec[-30] rec[-13] -DETECTOR(4, 5, 6, -1, -9) rec[-31] rec[-14] -DETECTOR(5, 0, 6, -1, -9) rec[-24] rec[-6] -DETECTOR(5, 2, 6, -1, -9) rec[-25] rec[-7] -DETECTOR(5, 4, 6, -1, -9) rec[-26] rec[-8] -DETECTOR(6, 0, 6, -1, -9) rec[-34] rec[-33] rec[-15] -DETECTOR(6, 2, 6, -1, -9) rec[-35] rec[-33] rec[-16] -DETECTOR(6, 4, 6, -1, -9) rec[-34] rec[-17] -DETECTOR(7, 1, 6, -1, -9) rec[-27] rec[-9] -DETECTOR(8, 1, 6, -1, -9) rec[-18] -TICK -RX 37 28 26 24 16 14 12 4 2 -R 41 35 33 31 22 20 18 8 6 -TICK -CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 -TICK -CX 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 -TICK -CX 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 -TICK -CX 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 -TICK -CX 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 -TICK -CX 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 -TICK -CX 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 -TICK -CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 -TICK -M 41 35 33 31 22 20 18 8 6 -MX 37 28 26 24 16 14 12 4 2 -DETECTOR(1, 0, 7, -1, -9) rec[-19] rec[-1] -DETECTOR(1, 2, 7, -1, -9) rec[-20] rec[-2] -DETECTOR(2, 0, 7, -1, -9) rec[-29] rec[-28] rec[-10] -DETECTOR(2, 2, 7, -1, -9) rec[-28] rec[-11] -DETECTOR(3, 1, 7, -1, -9) rec[-21] rec[-3] -DETECTOR(3, 3, 7, -1, -9) rec[-22] rec[-4] -DETECTOR(3, 5, 7, -1, -9) rec[-23] rec[-5] -DETECTOR(4, 1, 7, -1, -9) rec[-31] rec[-12] -DETECTOR(4, 3, 7, -1, -9) rec[-32] rec[-30] rec[-13] -DETECTOR(4, 5, 7, -1, -9) rec[-31] rec[-14] -DETECTOR(5, 0, 7, -1, -9) rec[-24] rec[-6] -DETECTOR(5, 2, 7, -1, -9) rec[-25] rec[-7] -DETECTOR(5, 4, 7, -1, -9) rec[-26] rec[-8] -DETECTOR(6, 0, 7, -1, -9) rec[-34] rec[-33] rec[-15] -DETECTOR(6, 2, 7, -1, -9) rec[-35] rec[-33] rec[-16] -DETECTOR(6, 4, 7, -1, -9) rec[-34] rec[-17] -DETECTOR(7, 1, 7, -1, -9) rec[-27] rec[-9] -DETECTOR(8, 1, 7, -1, -9) rec[-18] -TICK -RX 24 31 2 6 8 10 20 22 39 1 12 18 37 33 14 26 28 30 41 -TICK -T_DAG 0 3 7 9 11 13 15 17 19 21 23 25 27 29 32 34 36 38 40 -TICK -CX 1 0 2 3 6 7 8 13 10 15 12 11 14 9 18 17 20 27 22 29 24 25 26 19 28 21 30 23 31 32 33 34 37 36 39 38 41 40 -TICK -CX 3 1 14 15 29 30 33 38 37 41 -TICK -CX 7 3 13 14 26 33 28 29 32 37 -TICK -CX 12 13 25 32 27 28 -TICK -CX 12 7 26 27 -TICK -CX 18 12 25 26 -TICK -CX 25 18 -TICK -MX 25 -TICK -RX 25 -TICK -CX 25 18 -TICK -CX 18 12 25 26 -TICK -CX 12 7 26 27 -TICK -CX 12 13 25 32 27 28 -TICK -CX 7 3 13 14 26 33 28 29 32 37 -TICK -CX 3 1 14 15 29 30 33 38 37 41 -TICK -CX 1 0 2 3 6 7 8 13 10 15 12 11 14 9 18 17 20 27 22 29 24 25 26 19 28 21 30 23 31 32 33 34 37 36 39 38 41 40 -TICK -T 0 3 7 9 11 13 15 17 19 21 23 25 27 29 32 34 36 38 40 -TICK -MX 20 22 8 10 2 6 24 31 39 1 12 18 37 33 14 26 28 30 41 -OBSERVABLE_INCLUDE(0) rec[-10] rec[-9] rec[-8] rec[-7] rec[-6] rec[-5] rec[-4] rec[-3] rec[-2] rec[-1] -DETECTOR(2.25889, 1.08534, 8, -1, -9) rec[-85] rec[-84] rec[-81] rec[-80] rec[-74] rec[-73] rec[-72] rec[-70] rec[-69] rec[-68] rec[-67] rec[-56] rec[-55] rec[-54] rec[-52] rec[-51] rec[-50] rec[-49] rec[-38] rec[-37] rec[-36] rec[-34] rec[-33] rec[-32] rec[-31] rec[-20] -DETECTOR(4, 3, 9) rec[-19] -DETECTOR(4, 5, 9) rec[-18] -DETECTOR(2, 2, 9) rec[-17] -DETECTOR(2, 4, 9) rec[-16] -DETECTOR(1, 0, 9) rec[-15] -DETECTOR(2, 0, 9) rec[-14] -DETECTOR(5, 1, 9) rec[-13] rec[-20] -DETECTOR(6, 0, 9) rec[-12] -DETECTOR(7, 3, 9) rec[-11] -DETECTOR(0, 1, 9) rec[-10] -DETECTOR(3, 1, 9) rec[-9] -DETECTOR(4, 1, 9) rec[-8] -DETECTOR(7, 1, 9) rec[-7] -DETECTOR(6, 2, 9) rec[-6] -DETECTOR(3, 3, 9) rec[-5] -DETECTOR(5, 2, 9) rec[-4] -DETECTOR(5, 4, 9) rec[-3] -DETECTOR(5, 6, 9) rec[-2] -DETECTOR(8, 1, 9) rec[-1] -TICK -T 0 3 7 9 11 13 15 17 19 21 23 25 27 29 32 34 36 38 40 -MPP Y0*Y3*Y7*Y9*Y11*Y13*Y15*Y17*Y19*Y21*Y23*Y25*Y27*Y29*Y32*Y34*Y36*Y38*Y40 -T_DAG 0 3 7 9 11 13 15 17 19 21 23 25 27 29 32 34 36 38 40 -MPP X0*X3*X7*X11 X9*X13*X15*X19*X21*X27 X17*X25*X32*X36 Z0*Z3*Z7*Z11 Z9*Z13*Z15*Z19*Z21*Z27 Z17*Z25*Z32*Z36 X3*X7*X9*X13 X15*X21*X23*X29 X19*X25*X27*X32*X34*X38 Z3*Z7*Z9*Z13 Z15*Z21*Z23*Z29 Z19*Z25*Z27*Z32*Z34*Z38 X7*X11*X13*X17*X19*X25 X21*X27*X29*X34 X32*X36*X38*X40 Z7*Z11*Z13*Z17*Z19*Z25 Z21*Z27*Z29*Z34 Z32*Z36*Z38*Z40 -OBSERVABLE_INCLUDE(0) rec[-19] -DETECTOR(0.625, 0.125, 11, -1, -9) rec[-40] rec[-18] -DETECTOR(0.875, 0.125, 11, -1, -9) rec[-50] rec[-49] rec[-15] -DETECTOR(1.25, 1.4375, 11, -1, -9) rec[-41] rec[-12] -DETECTOR(1.5, 1.4375, 11, -1, -9) rec[-49] rec[-9] -DETECTOR(2.625, 1, 11, -1, -9) rec[-42] rec[-39] rec[-6] -DETECTOR(2.875, 1, 11, -1, -9) rec[-52] rec[-3] -DETECTOR(2.625, 3, 11, -1, -9) rec[-43] rec[-17] -DETECTOR(2.875, 3, 11, -1, -9) rec[-53] rec[-51] rec[-14] -DETECTOR(3.25, 4.4375, 11, -1, -9) rec[-44] rec[-11] -DETECTOR(3.5, 4.4375, 11, -1, -9) rec[-52] rec[-8] -DETECTOR(4.625, 0.125, 11, -1, -9) rec[-45] rec[-39] rec[-16] -DETECTOR(4.875, 0.125, 11, -1, -9) rec[-55] rec[-54] rec[-13] -DETECTOR(4.625, 2, 11, -1, -9) rec[-46] rec[-39] rec[-10] -DETECTOR(4.875, 2, 11, -1, -9) rec[-56] rec[-54] rec[-7] -DETECTOR(4.5, 3.9375, 11, -1, -9) rec[-47] rec[-5] -DETECTOR(4.75, 3.9375, 11, -1, -9) rec[-55] rec[-2] -DETECTOR(6.5, 0.9375, 11, -1, -9) rec[-48] rec[-4] -DETECTOR(6.75, 0.9375, 11, -1, -9) rec[-1] diff --git a/test/data/determined/clifft_d5_T_rule12.stim b/test/data/determined/clifft_d5_T_rule12.stim deleted file mode 100644 index 53083ec1..00000000 --- a/test/data/determined/clifft_d5_T_rule12.stim +++ /dev/null @@ -1,357 +0,0 @@ -QUBIT_COORDS(0, 0) 0 -QUBIT_COORDS(0, 1) 1 -QUBIT_COORDS(1, 0) 2 -QUBIT_COORDS(1, 1) 3 -QUBIT_COORDS(1, 2) 4 -QUBIT_COORDS(1, 3) 5 -QUBIT_COORDS(2, 0) 6 -QUBIT_COORDS(2, 1) 7 -QUBIT_COORDS(2, 2) 8 -QUBIT_COORDS(2, 3) 9 -QUBIT_COORDS(2, 4) 10 -QUBIT_COORDS(3, 0) 11 -QUBIT_COORDS(3, 1) 12 -QUBIT_COORDS(3, 2) 13 -QUBIT_COORDS(3, 3) 14 -QUBIT_COORDS(3, 4) 15 -QUBIT_COORDS(3, 5) 16 -QUBIT_COORDS(4, 0) 17 -QUBIT_COORDS(4, 1) 18 -QUBIT_COORDS(4, 2) 19 -QUBIT_COORDS(4, 3) 20 -QUBIT_COORDS(4, 4) 21 -QUBIT_COORDS(4, 5) 22 -QUBIT_COORDS(4, 6) 23 -QUBIT_COORDS(5, 0) 24 -QUBIT_COORDS(5, 1) 25 -QUBIT_COORDS(5, 2) 26 -QUBIT_COORDS(5, 3) 27 -QUBIT_COORDS(5, 4) 28 -QUBIT_COORDS(5, 5) 29 -QUBIT_COORDS(5, 6) 30 -QUBIT_COORDS(6, 0) 31 -QUBIT_COORDS(6, 1) 32 -QUBIT_COORDS(6, 2) 33 -QUBIT_COORDS(6, 3) 34 -QUBIT_COORDS(6, 4) 35 -QUBIT_COORDS(7, 0) 36 -QUBIT_COORDS(7, 1) 37 -QUBIT_COORDS(7, 2) 38 -QUBIT_COORDS(7, 3) 39 -QUBIT_COORDS(8, 0) 40 -QUBIT_COORDS(8, 1) 41 -RX 7 11 13 3 2 4 18 0 5 17 -R 12 8 6 -TICK -CX 7 12 11 6 13 8 -TICK -CX 7 8 11 12 -TICK -CX 7 6 13 12 -TICK -CX 2 6 4 8 18 12 -TICK -CX 6 2 8 4 12 18 -TICK -CX 3 4 17 18 -TICK -CX 3 2 18 17 -TICK -CX 4 3 -TICK -CX 2 3 -TICK -T_DAG 3 -TICK -CX 2 3 -TICK -CX 4 3 -TICK -CX 0 2 5 4 -TICK -CX 2 0 4 5 -TICK -RX 2 12 4 -R 6 18 8 9 -TICK -CX 2 6 4 8 5 9 12 18 -TICK -CX 2 0 6 11 8 13 9 5 12 7 -TICK -CX 2 3 6 7 8 9 12 13 -TICK -CX 4 3 8 7 12 11 18 17 -TICK -CX 3 4 7 8 11 12 17 18 -TICK -CX 0 2 7 12 11 6 13 8 -TICK -CX 3 2 7 6 9 8 13 12 -TICK -CX 2 6 4 8 12 18 -TICK -M 6 18 8 5 -MX 2 12 4 -DETECTOR(2, 0, 0) rec[-7] -DETECTOR(4, 1, 0) rec[-6] -DETECTOR(2, 2, 0) rec[-5] -DETECTOR(1, 3, 0) rec[-4] -DETECTOR(1, 0, 0) rec[-3] -DETECTOR(3, 1, 0) rec[-2] -DETECTOR(1, 2, 0) rec[-1] -TICK -RX 18 12 6 2 8 1 -TICK -T_DAG 0 3 7 9 11 13 17 -TICK -CX 1 0 2 3 6 7 8 9 12 11 18 17 -TICK -CX 3 1 7 8 12 18 -TICK -CX 7 3 12 13 -TICK -CX 7 12 -TICK -MX 7 -TICK -RX 7 -TICK -CX 7 12 -TICK -CX 7 3 12 13 -TICK -CX 3 1 7 8 12 18 -TICK -CX 1 0 2 3 6 7 8 9 12 11 18 17 -TICK -T 0 3 7 9 11 13 17 -TICK -MX 18 12 6 2 8 1 -DETECTOR(2.14286, 1, 1, -1, -9) rec[-9] rec[-8] rec[-7] -DETECTOR(4, 1, 2) rec[-6] -DETECTOR(3, 1, 2) rec[-5] -DETECTOR(2, 1, 2) rec[-4] rec[-7] -DETECTOR(1, 0, 2) rec[-3] -DETECTOR(2, 2, 2) rec[-2] -DETECTOR(0, 1, 2) rec[-1] -TICK -RX 26 33 36 16 28 27 -R 19 25 32 38 40 23 15 22 21 29 34 -TICK -CX 16 22 26 19 27 34 28 21 33 38 36 40 -TICK -CX 16 15 22 23 26 25 28 29 33 32 -TICK -CX 15 16 23 22 25 26 29 28 32 33 -TICK -M 26 33 28 22 16 -DETECTOR(5, 2, 4) rec[-5] -DETECTOR(6, 2, 4) rec[-4] -DETECTOR(5, 4, 4) rec[-3] -DETECTOR(4, 5, 4) rec[-2] -DETECTOR(3, 5, 4) rec[-1] -TICK -RX 37 28 26 24 16 14 12 4 2 -R 41 35 33 31 22 20 18 8 6 -TICK -CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 -TICK -CX 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 -TICK -CX 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 -TICK -CX 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 -TICK -CX 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 -TICK -CX 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 -TICK -CX 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 -TICK -CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 -TICK -M 41 35 33 31 22 20 18 8 6 -MX 37 28 26 24 16 14 12 4 2 -DETECTOR(1.25, 0.25, 5, -1, -9) rec[-30] rec[-1] -DETECTOR(1.5, 1.875, 5, -1, -9) rec[-30] rec[-2] -DETECTOR(1.75, 0.25, 5, -1, -9) rec[-10] -DETECTOR(2, 1.875, 5, -1, -9) rec[-11] -DETECTOR(3.075, 0.9125, 5, -1, -9) rec[-30] rec[-3] -DETECTOR(3.5, 4.875, 5, -1, -9) rec[-5] -DETECTOR(3.575, 0.9125, 5, -1, -9) rec[-12] -DETECTOR(4, 4.875, 5, -1, -9) rec[-14] -DETECTOR(5.25, 2, 5, -1, -9) rec[-7] -DETECTOR(5, 3.875, 5, -1, -9) rec[-8] -DETECTOR(5.75, 2, 5, -1, -9) rec[-16] -DETECTOR(5.5, 3.875, 5, -1, -9) rec[-17] -DETECTOR(7, 0.875, 5, -1, -9) rec[-9] -DETECTOR(7.5, 0.875, 5, -1, -9) rec[-18] -TICK -RX 37 28 26 24 16 14 12 4 2 -R 41 35 33 31 22 20 18 8 6 -TICK -CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 -TICK -CX 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 -TICK -CX 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 -TICK -CX 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 -TICK -CX 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 -TICK -CX 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 -TICK -CX 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 -TICK -CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 -TICK -M 41 35 33 31 22 20 18 8 6 -MX 37 28 26 24 16 14 12 4 2 -DETECTOR(1, 0, 6, -1, -9) rec[-19] rec[-1] -DETECTOR(1, 2, 6, -1, -9) rec[-20] rec[-2] -DETECTOR(2, 0, 6, -1, -9) rec[-29] rec[-28] rec[-10] -DETECTOR(2, 2, 6, -1, -9) rec[-28] rec[-11] -DETECTOR(3, 1, 6, -1, -9) rec[-21] rec[-3] -DETECTOR(3, 3, 6, -1, -9) rec[-22] rec[-4] -DETECTOR(3, 5, 6, -1, -9) rec[-23] rec[-5] -DETECTOR(4, 1, 6, -1, -9) rec[-31] rec[-12] -DETECTOR(4, 3, 6, -1, -9) rec[-32] rec[-30] rec[-13] -DETECTOR(4, 5, 6, -1, -9) rec[-31] rec[-14] -DETECTOR(5, 0, 6, -1, -9) rec[-24] rec[-6] -DETECTOR(5, 2, 6, -1, -9) rec[-25] rec[-7] -DETECTOR(5, 4, 6, -1, -9) rec[-26] rec[-8] -DETECTOR(6, 0, 6, -1, -9) rec[-34] rec[-33] rec[-15] -DETECTOR(6, 2, 6, -1, -9) rec[-35] rec[-33] rec[-16] -DETECTOR(6, 4, 6, -1, -9) rec[-34] rec[-17] -DETECTOR(7, 1, 6, -1, -9) rec[-27] rec[-9] -DETECTOR(8, 1, 6, -1, -9) rec[-18] -TICK -RX 37 28 26 24 16 14 12 4 2 -R 41 35 33 31 22 20 18 8 6 -TICK -CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 -TICK -CX 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 -TICK -CX 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 -TICK -CX 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 -TICK -CX 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 -TICK -CX 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 -TICK -CX 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 -TICK -CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 -TICK -M 41 35 33 31 22 20 18 8 6 -MX 37 28 26 24 16 14 12 4 2 -DETECTOR(1, 0, 7, -1, -9) rec[-19] rec[-1] -DETECTOR(1, 2, 7, -1, -9) rec[-20] rec[-2] -DETECTOR(2, 0, 7, -1, -9) rec[-29] rec[-28] rec[-10] -DETECTOR(2, 2, 7, -1, -9) rec[-28] rec[-11] -DETECTOR(3, 1, 7, -1, -9) rec[-21] rec[-3] -DETECTOR(3, 3, 7, -1, -9) rec[-22] rec[-4] -DETECTOR(3, 5, 7, -1, -9) rec[-23] rec[-5] -DETECTOR(4, 1, 7, -1, -9) rec[-31] rec[-12] -DETECTOR(4, 3, 7, -1, -9) rec[-32] rec[-30] rec[-13] -DETECTOR(4, 5, 7, -1, -9) rec[-31] rec[-14] -DETECTOR(5, 0, 7, -1, -9) rec[-24] rec[-6] -DETECTOR(5, 2, 7, -1, -9) rec[-25] rec[-7] -DETECTOR(5, 4, 7, -1, -9) rec[-26] rec[-8] -DETECTOR(6, 0, 7, -1, -9) rec[-34] rec[-33] rec[-15] -DETECTOR(6, 2, 7, -1, -9) rec[-35] rec[-33] rec[-16] -DETECTOR(6, 4, 7, -1, -9) rec[-34] rec[-17] -DETECTOR(7, 1, 7, -1, -9) rec[-27] rec[-9] -DETECTOR(8, 1, 7, -1, -9) rec[-18] -TICK -RX 24 31 2 6 8 10 20 22 39 1 12 18 37 33 14 26 28 30 41 -TICK -T_DAG 3 7 9 13 15 21 23 25 27 29 32 34 38 -T 0 11 17 19 36 40 -TICK -CX 1 0 2 3 6 7 8 13 10 15 12 11 14 9 18 17 20 27 22 29 24 25 26 19 28 21 30 23 31 32 33 34 37 36 39 38 41 40 -TICK -CX 3 1 14 15 29 30 33 38 37 41 -TICK -CX 7 3 13 14 26 33 28 29 32 37 -TICK -CX 12 13 25 32 27 28 -TICK -CX 12 7 26 27 -TICK -CX 18 12 25 26 -TICK -CX 25 18 -TICK -MX 25 -TICK -RX 25 -TICK -CX 25 18 -TICK -CX 18 12 25 26 -TICK -CX 12 7 26 27 -TICK -CX 12 13 25 32 27 28 -TICK -CX 7 3 13 14 26 33 28 29 32 37 -TICK -CX 3 1 14 15 29 30 33 38 37 41 -TICK -CX 1 0 2 3 6 7 8 13 10 15 12 11 14 9 18 17 20 27 22 29 24 25 26 19 28 21 30 23 31 32 33 34 37 36 39 38 41 40 -TICK -T 3 7 9 13 15 21 23 25 27 29 32 34 38 -T_DAG 0 11 17 19 36 40 -TICK -MX 20 22 8 10 2 6 24 31 39 1 12 18 37 33 14 26 28 30 41 -OBSERVABLE_INCLUDE(0) rec[-10] rec[-9] rec[-8] rec[-7] rec[-6] rec[-5] rec[-4] rec[-3] rec[-2] rec[-1] -DETECTOR(2.25889, 1.08534, 8, -1, -9) rec[-85] rec[-84] rec[-81] rec[-80] rec[-74] rec[-73] rec[-72] rec[-70] rec[-69] rec[-68] rec[-67] rec[-56] rec[-55] rec[-54] rec[-52] rec[-51] rec[-50] rec[-49] rec[-38] rec[-37] rec[-36] rec[-34] rec[-33] rec[-32] rec[-31] rec[-20] -DETECTOR(4, 3, 9) rec[-19] -DETECTOR(4, 5, 9) rec[-18] -DETECTOR(2, 2, 9) rec[-17] -DETECTOR(2, 4, 9) rec[-16] -DETECTOR(1, 0, 9) rec[-15] -DETECTOR(2, 0, 9) rec[-14] -DETECTOR(5, 1, 9) rec[-13] rec[-20] -DETECTOR(6, 0, 9) rec[-12] -DETECTOR(7, 3, 9) rec[-11] -DETECTOR(0, 1, 9) rec[-10] -DETECTOR(3, 1, 9) rec[-9] -DETECTOR(4, 1, 9) rec[-8] -DETECTOR(7, 1, 9) rec[-7] -DETECTOR(6, 2, 9) rec[-6] -DETECTOR(3, 3, 9) rec[-5] -DETECTOR(5, 2, 9) rec[-4] -DETECTOR(5, 4, 9) rec[-3] -DETECTOR(5, 6, 9) rec[-2] -DETECTOR(8, 1, 9) rec[-1] -TICK -T 3 7 9 13 15 21 23 25 27 29 32 34 38 -T_DAG 0 11 17 19 36 40 -MPP Y0*Y3*Y7*Y9*Y11*Y13*Y15*Y17*Y19*Y21*Y23*Y25*Y27*Y29*Y32*Y34*Y36*Y38*Y40 -T_DAG 3 7 9 13 15 21 23 25 27 29 32 34 38 -T 0 11 17 19 36 40 -MPP X0*X3*X7*X11 X9*X13*X15*X19*X21*X27 X17*X25*X32*X36 Z0*Z3*Z7*Z11 Z9*Z13*Z15*Z19*Z21*Z27 Z17*Z25*Z32*Z36 X3*X7*X9*X13 X15*X21*X23*X29 X19*X25*X27*X32*X34*X38 Z3*Z7*Z9*Z13 Z15*Z21*Z23*Z29 Z19*Z25*Z27*Z32*Z34*Z38 X7*X11*X13*X17*X19*X25 X21*X27*X29*X34 X32*X36*X38*X40 Z7*Z11*Z13*Z17*Z19*Z25 Z21*Z27*Z29*Z34 Z32*Z36*Z38*Z40 -OBSERVABLE_INCLUDE(0) rec[-19] -DETECTOR(0.625, 0.125, 11, -1, -9) rec[-40] rec[-18] -DETECTOR(0.875, 0.125, 11, -1, -9) rec[-50] rec[-49] rec[-15] -DETECTOR(1.25, 1.4375, 11, -1, -9) rec[-41] rec[-12] -DETECTOR(1.5, 1.4375, 11, -1, -9) rec[-49] rec[-9] -DETECTOR(2.625, 1, 11, -1, -9) rec[-42] rec[-39] rec[-6] -DETECTOR(2.875, 1, 11, -1, -9) rec[-52] rec[-3] -DETECTOR(2.625, 3, 11, -1, -9) rec[-43] rec[-17] -DETECTOR(2.875, 3, 11, -1, -9) rec[-53] rec[-51] rec[-14] -DETECTOR(3.25, 4.4375, 11, -1, -9) rec[-44] rec[-11] -DETECTOR(3.5, 4.4375, 11, -1, -9) rec[-52] rec[-8] -DETECTOR(4.625, 0.125, 11, -1, -9) rec[-45] rec[-39] rec[-16] -DETECTOR(4.875, 0.125, 11, -1, -9) rec[-55] rec[-54] rec[-13] -DETECTOR(4.625, 2, 11, -1, -9) rec[-46] rec[-39] rec[-10] -DETECTOR(4.875, 2, 11, -1, -9) rec[-56] rec[-54] rec[-7] -DETECTOR(4.5, 3.9375, 11, -1, -9) rec[-47] rec[-5] -DETECTOR(4.75, 3.9375, 11, -1, -9) rec[-55] rec[-2] -DETECTOR(6.5, 0.9375, 11, -1, -9) rec[-48] rec[-4] -DETECTOR(6.75, 0.9375, 11, -1, -9) rec[-1] diff --git a/test/data/determined/clifft_d5_sproxy.stim b/test/data/determined/clifft_d5_sproxy.stim deleted file mode 100644 index 3f8530fa..00000000 --- a/test/data/determined/clifft_d5_sproxy.stim +++ /dev/null @@ -1,350 +0,0 @@ -QUBIT_COORDS(0, 0) 0 -QUBIT_COORDS(0, 1) 1 -QUBIT_COORDS(1, 0) 2 -QUBIT_COORDS(1, 1) 3 -QUBIT_COORDS(1, 2) 4 -QUBIT_COORDS(1, 3) 5 -QUBIT_COORDS(2, 0) 6 -QUBIT_COORDS(2, 1) 7 -QUBIT_COORDS(2, 2) 8 -QUBIT_COORDS(2, 3) 9 -QUBIT_COORDS(2, 4) 10 -QUBIT_COORDS(3, 0) 11 -QUBIT_COORDS(3, 1) 12 -QUBIT_COORDS(3, 2) 13 -QUBIT_COORDS(3, 3) 14 -QUBIT_COORDS(3, 4) 15 -QUBIT_COORDS(3, 5) 16 -QUBIT_COORDS(4, 0) 17 -QUBIT_COORDS(4, 1) 18 -QUBIT_COORDS(4, 2) 19 -QUBIT_COORDS(4, 3) 20 -QUBIT_COORDS(4, 4) 21 -QUBIT_COORDS(4, 5) 22 -QUBIT_COORDS(4, 6) 23 -QUBIT_COORDS(5, 0) 24 -QUBIT_COORDS(5, 1) 25 -QUBIT_COORDS(5, 2) 26 -QUBIT_COORDS(5, 3) 27 -QUBIT_COORDS(5, 4) 28 -QUBIT_COORDS(5, 5) 29 -QUBIT_COORDS(5, 6) 30 -QUBIT_COORDS(6, 0) 31 -QUBIT_COORDS(6, 1) 32 -QUBIT_COORDS(6, 2) 33 -QUBIT_COORDS(6, 3) 34 -QUBIT_COORDS(6, 4) 35 -QUBIT_COORDS(7, 0) 36 -QUBIT_COORDS(7, 1) 37 -QUBIT_COORDS(7, 2) 38 -QUBIT_COORDS(7, 3) 39 -QUBIT_COORDS(8, 0) 40 -QUBIT_COORDS(8, 1) 41 -RX 7 11 13 3 2 4 18 0 5 17 -R 12 8 6 -TICK -CX 7 12 11 6 13 8 -TICK -CX 7 8 11 12 -TICK -CX 7 6 13 12 -TICK -CX 2 6 4 8 18 12 -TICK -CX 6 2 8 4 12 18 -TICK -CX 3 4 17 18 -TICK -CX 3 2 18 17 -TICK -CX 4 3 -TICK -CX 2 3 -TICK -S_DAG 3 -TICK -CX 2 3 -TICK -CX 4 3 -TICK -CX 0 2 5 4 -TICK -CX 2 0 4 5 -TICK -RX 2 12 4 -R 6 18 8 9 -TICK -CX 2 6 4 8 5 9 12 18 -TICK -CX 2 0 6 11 8 13 9 5 12 7 -TICK -CX 2 3 6 7 8 9 12 13 -TICK -CX 4 3 8 7 12 11 18 17 -TICK -CX 3 4 7 8 11 12 17 18 -TICK -CX 0 2 7 12 11 6 13 8 -TICK -CX 3 2 7 6 9 8 13 12 -TICK -CX 2 6 4 8 12 18 -TICK -M 6 18 8 5 -MX 2 12 4 -DETECTOR(2, 0, 0) rec[-7] -DETECTOR(4, 1, 0) rec[-6] -DETECTOR(2, 2, 0) rec[-5] -DETECTOR(1, 3, 0) rec[-4] -DETECTOR(1, 0, 0) rec[-3] -DETECTOR(3, 1, 0) rec[-2] -DETECTOR(1, 2, 0) rec[-1] -TICK -RX 18 12 6 2 8 1 -TICK -S_DAG 0 3 7 9 11 13 17 -TICK -CX 1 0 2 3 6 7 8 9 12 11 18 17 -TICK -CX 3 1 7 8 12 18 -TICK -CX 7 3 12 13 -TICK -CX 7 12 -TICK -MX 7 -TICK -RX 7 -TICK -CX 7 12 -TICK -CX 7 3 12 13 -TICK -CX 3 1 7 8 12 18 -TICK -CX 1 0 2 3 6 7 8 9 12 11 18 17 -TICK -S 0 3 7 9 11 13 17 -TICK -MX 18 12 6 2 8 1 -DETECTOR(2.14286, 1, 1, -1, -9) rec[-9] rec[-8] rec[-7] -DETECTOR(4, 1, 2) rec[-6] -DETECTOR(3, 1, 2) rec[-5] -DETECTOR(2, 1, 2) rec[-4] rec[-7] -DETECTOR(1, 0, 2) rec[-3] -DETECTOR(2, 2, 2) rec[-2] -DETECTOR(0, 1, 2) rec[-1] -TICK -RX 26 33 36 16 28 27 -R 19 25 32 38 40 23 15 22 21 29 34 -TICK -CX 16 22 26 19 27 34 28 21 33 38 36 40 -TICK -CX 16 15 22 23 26 25 28 29 33 32 -TICK -CX 15 16 23 22 25 26 29 28 32 33 -TICK -M 26 33 28 22 16 -DETECTOR(5, 2, 4) rec[-5] -DETECTOR(6, 2, 4) rec[-4] -DETECTOR(5, 4, 4) rec[-3] -DETECTOR(4, 5, 4) rec[-2] -DETECTOR(3, 5, 4) rec[-1] -TICK -RX 37 28 26 24 16 14 12 4 2 -R 41 35 33 31 22 20 18 8 6 -TICK -CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 -TICK -CX 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 -TICK -CX 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 -TICK -CX 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 -TICK -CX 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 -TICK -CX 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 -TICK -CX 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 -TICK -CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 -TICK -M 41 35 33 31 22 20 18 8 6 -MX 37 28 26 24 16 14 12 4 2 -DETECTOR(1.25, 0.25, 5, -1, -9) rec[-30] rec[-1] -DETECTOR(1.5, 1.875, 5, -1, -9) rec[-30] rec[-2] -DETECTOR(1.75, 0.25, 5, -1, -9) rec[-10] -DETECTOR(2, 1.875, 5, -1, -9) rec[-11] -DETECTOR(3.075, 0.9125, 5, -1, -9) rec[-30] rec[-3] -DETECTOR(3.5, 4.875, 5, -1, -9) rec[-5] -DETECTOR(3.575, 0.9125, 5, -1, -9) rec[-12] -DETECTOR(4, 4.875, 5, -1, -9) rec[-14] -DETECTOR(5.25, 2, 5, -1, -9) rec[-7] -DETECTOR(5, 3.875, 5, -1, -9) rec[-8] -DETECTOR(5.75, 2, 5, -1, -9) rec[-16] -DETECTOR(5.5, 3.875, 5, -1, -9) rec[-17] -DETECTOR(7, 0.875, 5, -1, -9) rec[-9] -DETECTOR(7.5, 0.875, 5, -1, -9) rec[-18] -TICK -RX 37 28 26 24 16 14 12 4 2 -R 41 35 33 31 22 20 18 8 6 -TICK -CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 -TICK -CX 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 -TICK -CX 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 -TICK -CX 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 -TICK -CX 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 -TICK -CX 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 -TICK -CX 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 -TICK -CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 -TICK -M 41 35 33 31 22 20 18 8 6 -MX 37 28 26 24 16 14 12 4 2 -DETECTOR(1, 0, 6, -1, -9) rec[-19] rec[-1] -DETECTOR(1, 2, 6, -1, -9) rec[-20] rec[-2] -DETECTOR(2, 0, 6, -1, -9) rec[-29] rec[-28] rec[-10] -DETECTOR(2, 2, 6, -1, -9) rec[-28] rec[-11] -DETECTOR(3, 1, 6, -1, -9) rec[-21] rec[-3] -DETECTOR(3, 3, 6, -1, -9) rec[-22] rec[-4] -DETECTOR(3, 5, 6, -1, -9) rec[-23] rec[-5] -DETECTOR(4, 1, 6, -1, -9) rec[-31] rec[-12] -DETECTOR(4, 3, 6, -1, -9) rec[-32] rec[-30] rec[-13] -DETECTOR(4, 5, 6, -1, -9) rec[-31] rec[-14] -DETECTOR(5, 0, 6, -1, -9) rec[-24] rec[-6] -DETECTOR(5, 2, 6, -1, -9) rec[-25] rec[-7] -DETECTOR(5, 4, 6, -1, -9) rec[-26] rec[-8] -DETECTOR(6, 0, 6, -1, -9) rec[-34] rec[-33] rec[-15] -DETECTOR(6, 2, 6, -1, -9) rec[-35] rec[-33] rec[-16] -DETECTOR(6, 4, 6, -1, -9) rec[-34] rec[-17] -DETECTOR(7, 1, 6, -1, -9) rec[-27] rec[-9] -DETECTOR(8, 1, 6, -1, -9) rec[-18] -TICK -RX 37 28 26 24 16 14 12 4 2 -R 41 35 33 31 22 20 18 8 6 -TICK -CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 -TICK -CX 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 -TICK -CX 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 -TICK -CX 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 -TICK -CX 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 -TICK -CX 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 -TICK -CX 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 -TICK -CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 -TICK -M 41 35 33 31 22 20 18 8 6 -MX 37 28 26 24 16 14 12 4 2 -DETECTOR(1, 0, 7, -1, -9) rec[-19] rec[-1] -DETECTOR(1, 2, 7, -1, -9) rec[-20] rec[-2] -DETECTOR(2, 0, 7, -1, -9) rec[-29] rec[-28] rec[-10] -DETECTOR(2, 2, 7, -1, -9) rec[-28] rec[-11] -DETECTOR(3, 1, 7, -1, -9) rec[-21] rec[-3] -DETECTOR(3, 3, 7, -1, -9) rec[-22] rec[-4] -DETECTOR(3, 5, 7, -1, -9) rec[-23] rec[-5] -DETECTOR(4, 1, 7, -1, -9) rec[-31] rec[-12] -DETECTOR(4, 3, 7, -1, -9) rec[-32] rec[-30] rec[-13] -DETECTOR(4, 5, 7, -1, -9) rec[-31] rec[-14] -DETECTOR(5, 0, 7, -1, -9) rec[-24] rec[-6] -DETECTOR(5, 2, 7, -1, -9) rec[-25] rec[-7] -DETECTOR(5, 4, 7, -1, -9) rec[-26] rec[-8] -DETECTOR(6, 0, 7, -1, -9) rec[-34] rec[-33] rec[-15] -DETECTOR(6, 2, 7, -1, -9) rec[-35] rec[-33] rec[-16] -DETECTOR(6, 4, 7, -1, -9) rec[-34] rec[-17] -DETECTOR(7, 1, 7, -1, -9) rec[-27] rec[-9] -DETECTOR(8, 1, 7, -1, -9) rec[-18] -TICK -RX 24 31 2 6 8 10 20 22 39 1 12 18 37 33 14 26 28 30 41 -TICK -S_DAG 0 3 7 9 11 13 15 17 19 21 23 25 27 29 32 34 36 38 40 -TICK -CX 1 0 2 3 6 7 8 13 10 15 12 11 14 9 18 17 20 27 22 29 24 25 26 19 28 21 30 23 31 32 33 34 37 36 39 38 41 40 -TICK -CX 3 1 14 15 29 30 33 38 37 41 -TICK -CX 7 3 13 14 26 33 28 29 32 37 -TICK -CX 12 13 25 32 27 28 -TICK -CX 12 7 26 27 -TICK -CX 18 12 25 26 -TICK -CX 25 18 -TICK -MX 25 -TICK -RX 25 -TICK -CX 25 18 -TICK -CX 18 12 25 26 -TICK -CX 12 7 26 27 -TICK -CX 12 13 25 32 27 28 -TICK -CX 7 3 13 14 26 33 28 29 32 37 -TICK -CX 3 1 14 15 29 30 33 38 37 41 -TICK -CX 1 0 2 3 6 7 8 13 10 15 12 11 14 9 18 17 20 27 22 29 24 25 26 19 28 21 30 23 31 32 33 34 37 36 39 38 41 40 -TICK -S 0 3 7 9 11 13 15 17 19 21 23 25 27 29 32 34 36 38 40 -TICK -MX 20 22 8 10 2 6 24 31 39 1 12 18 37 33 14 26 28 30 41 -OBSERVABLE_INCLUDE(0) rec[-10] rec[-9] rec[-8] rec[-7] rec[-6] rec[-5] rec[-4] rec[-3] rec[-2] rec[-1] -DETECTOR(2.25889, 1.08534, 8, -1, -9) rec[-85] rec[-84] rec[-81] rec[-80] rec[-74] rec[-73] rec[-72] rec[-70] rec[-69] rec[-68] rec[-67] rec[-56] rec[-55] rec[-54] rec[-52] rec[-51] rec[-50] rec[-49] rec[-38] rec[-37] rec[-36] rec[-34] rec[-33] rec[-32] rec[-31] rec[-20] -DETECTOR(4, 3, 9) rec[-19] -DETECTOR(4, 5, 9) rec[-18] -DETECTOR(2, 2, 9) rec[-17] -DETECTOR(2, 4, 9) rec[-16] -DETECTOR(1, 0, 9) rec[-15] -DETECTOR(2, 0, 9) rec[-14] -DETECTOR(5, 1, 9) rec[-13] rec[-20] -DETECTOR(6, 0, 9) rec[-12] -DETECTOR(7, 3, 9) rec[-11] -DETECTOR(0, 1, 9) rec[-10] -DETECTOR(3, 1, 9) rec[-9] -DETECTOR(4, 1, 9) rec[-8] -DETECTOR(7, 1, 9) rec[-7] -DETECTOR(6, 2, 9) rec[-6] -DETECTOR(3, 3, 9) rec[-5] -DETECTOR(5, 2, 9) rec[-4] -DETECTOR(5, 4, 9) rec[-3] -DETECTOR(5, 6, 9) rec[-2] -DETECTOR(8, 1, 9) rec[-1] -TICK -MPP Y0*Y3*Y7*Y9*Y11*Y13*Y15*Y17*Y19*Y21*Y23*Y25*Y27*Y29*Y32*Y34*Y36*Y38*Y40 X0*X3*X7*X11 X9*X13*X15*X19*X21*X27 X17*X25*X32*X36 Z0*Z3*Z7*Z11 Z9*Z13*Z15*Z19*Z21*Z27 Z17*Z25*Z32*Z36 X3*X7*X9*X13 X15*X21*X23*X29 X19*X25*X27*X32*X34*X38 Z3*Z7*Z9*Z13 Z15*Z21*Z23*Z29 Z19*Z25*Z27*Z32*Z34*Z38 X7*X11*X13*X17*X19*X25 X21*X27*X29*X34 X32*X36*X38*X40 Z7*Z11*Z13*Z17*Z19*Z25 Z21*Z27*Z29*Z34 Z32*Z36*Z38*Z40 -OBSERVABLE_INCLUDE(0) rec[-19] -DETECTOR(0.625, 0.125, 11, -1, -9) rec[-40] rec[-18] -DETECTOR(0.875, 0.125, 11, -1, -9) rec[-50] rec[-49] rec[-15] -DETECTOR(1.25, 1.4375, 11, -1, -9) rec[-41] rec[-12] -DETECTOR(1.5, 1.4375, 11, -1, -9) rec[-49] rec[-9] -DETECTOR(2.625, 1, 11, -1, -9) rec[-42] rec[-39] rec[-6] -DETECTOR(2.875, 1, 11, -1, -9) rec[-52] rec[-3] -DETECTOR(2.625, 3, 11, -1, -9) rec[-43] rec[-17] -DETECTOR(2.875, 3, 11, -1, -9) rec[-53] rec[-51] rec[-14] -DETECTOR(3.25, 4.4375, 11, -1, -9) rec[-44] rec[-11] -DETECTOR(3.5, 4.4375, 11, -1, -9) rec[-52] rec[-8] -DETECTOR(4.625, 0.125, 11, -1, -9) rec[-45] rec[-39] rec[-16] -DETECTOR(4.875, 0.125, 11, -1, -9) rec[-55] rec[-54] rec[-13] -DETECTOR(4.625, 2, 11, -1, -9) rec[-46] rec[-39] rec[-10] -DETECTOR(4.875, 2, 11, -1, -9) rec[-56] rec[-54] rec[-7] -DETECTOR(4.5, 3.9375, 11, -1, -9) rec[-47] rec[-5] -DETECTOR(4.75, 3.9375, 11, -1, -9) rec[-55] rec[-2] -DETECTOR(6.5, 0.9375, 11, -1, -9) rec[-48] rec[-4] -DETECTOR(6.75, 0.9375, 11, -1, -9) rec[-1] diff --git a/test/data/determined/wan_clifft_d3_T.stim b/test/data/determined/wan_clifft_d3_T.stim deleted file mode 100644 index 129a7375..00000000 --- a/test/data/determined/wan_clifft_d3_T.stim +++ /dev/null @@ -1,124 +0,0 @@ -QUBIT_COORDS(0, 0) 0 -QUBIT_COORDS(0, 1) 1 -QUBIT_COORDS(1, 0) 2 -QUBIT_COORDS(1, 1) 3 -QUBIT_COORDS(1, 2) 4 -QUBIT_COORDS(1, 3) 5 -QUBIT_COORDS(2, 0) 6 -QUBIT_COORDS(2, 1) 7 -QUBIT_COORDS(2, 2) 8 -QUBIT_COORDS(2, 3) 9 -QUBIT_COORDS(3, 0) 10 -QUBIT_COORDS(3, 1) 11 -QUBIT_COORDS(3, 2) 12 -QUBIT_COORDS(4, 0) 13 -QUBIT_COORDS(4, 1) 14 -RX 7 10 12 3 2 4 14 0 5 13 -R 11 8 6 -TICK -CX 7 11 10 6 12 8 -TICK -CX 7 8 10 11 -TICK -CX 7 6 12 11 -TICK -CX 2 6 4 8 14 11 -TICK -CX 6 2 8 4 11 14 -TICK -CX 3 4 13 14 -TICK -CX 3 2 14 13 -TICK -CX 4 3 -TICK -CX 2 3 -TICK -T_DAG 3 -TICK -CX 2 3 -TICK -CX 4 3 -TICK -CX 0 2 5 4 -TICK -CX 2 0 4 5 -TICK -RX 2 11 4 -R 6 14 8 9 -TICK -CX 2 6 4 8 5 9 11 14 -TICK -CX 2 0 6 10 8 12 9 5 11 7 -TICK -CX 2 3 6 7 8 9 11 12 -TICK -CX 4 3 8 7 11 10 14 13 -TICK -CX 3 4 7 8 10 11 13 14 -TICK -CX 0 2 7 11 10 6 12 8 -TICK -CX 3 2 7 6 9 8 12 11 -TICK -CX 2 6 4 8 11 14 -TICK -M 6 14 8 5 -MX 2 11 4 -DETECTOR(2, 0, 0) rec[-7] -DETECTOR(4, 1, 0) rec[-6] -DETECTOR(2, 2, 0) rec[-5] -DETECTOR(1, 3, 0) rec[-4] -DETECTOR(1, 0, 0) rec[-3] -DETECTOR(3, 1, 0) rec[-2] -DETECTOR(1, 2, 0) rec[-1] -SHIFT_COORDS(0, 0, 1) -TICK -RX 14 11 6 2 8 1 -TICK -T_DAG 0 3 7 9 10 12 13 -TICK -CX 1 0 2 3 6 7 8 9 11 10 14 13 -TICK -CX 3 1 7 8 11 14 -TICK -CX 7 3 11 12 -TICK -CX 7 11 -TICK -MX 7 -TICK -RX 7 -TICK -CX 7 11 -TICK -CX 7 3 11 12 -TICK -CX 3 1 7 8 11 14 -TICK -CX 1 0 2 3 6 7 8 9 11 10 14 13 -TICK -T 0 3 7 9 10 12 13 -TICK -MX 14 11 6 2 8 1 -OBSERVABLE_INCLUDE(0) rec[-6] rec[-5] rec[-2] rec[-1] -DETECTOR(2.14286, 1, 0, -1, -9) rec[-9] rec[-8] rec[-7] -DETECTOR(4, 1, 1) rec[-6] -DETECTOR(3, 1, 1) rec[-5] -DETECTOR(2, 1, 1) rec[-4] rec[-7] -DETECTOR(1, 0, 1) rec[-3] -DETECTOR(2, 2, 1) rec[-2] -DETECTOR(0, 1, 1) rec[-1] -SHIFT_COORDS(0, 0, 3) -TICK -T 0 3 7 9 10 12 13 -MPP Y0*Y3*Y7*Y9*Y10*Y12*Y13 -T_DAG 0 3 7 9 10 12 13 -OBSERVABLE_INCLUDE(0) rec[-1] -MPP X0*X3*X7*X10 Z0*Z3*Z7*Z10 X3*X7*X9*X12 Z3*Z7*Z9*Z12 X7*X10*X12*X13 Z7*Z10*Z12*Z13 -DETECTOR(0.75, 0.25, 0, -1, -9) rec[-14] rec[-6] -DETECTOR(0.75, 0.25, 1, -1, -9) rec[-5] -DETECTOR(1.5, 1.375, 0, -1, -9) rec[-14] rec[-4] -DETECTOR(1.5, 1.375, 1, -1, -9) rec[-3] -DETECTOR(2.5, 0.875, 0, -1, -9) rec[-14] rec[-2] -DETECTOR(2.5, 0.875, 1, -1, -9) rec[-1] diff --git a/test/data/determined/wan_soft_d5_T.stim b/test/data/determined/wan_soft_d5_T.stim deleted file mode 100644 index 860627fa..00000000 --- a/test/data/determined/wan_soft_d5_T.stim +++ /dev/null @@ -1,211 +0,0 @@ -QUBIT_COORDS(0, 0) 0 -QUBIT_COORDS(0, 1) 1 -QUBIT_COORDS(1, 0) 2 -QUBIT_COORDS(1, 1) 3 -QUBIT_COORDS(1, 2) 4 -QUBIT_COORDS(1, 3) 5 -QUBIT_COORDS(2, 0) 6 -QUBIT_COORDS(2, 1) 7 -QUBIT_COORDS(2, 2) 8 -QUBIT_COORDS(2, 3) 9 -QUBIT_COORDS(2, 4) 10 -QUBIT_COORDS(3, 0) 11 -QUBIT_COORDS(3, 1) 12 -QUBIT_COORDS(3, 2) 13 -QUBIT_COORDS(3, 3) 14 -QUBIT_COORDS(3, 4) 15 -QUBIT_COORDS(3, 5) 16 -QUBIT_COORDS(4, 0) 17 -QUBIT_COORDS(4, 1) 18 -QUBIT_COORDS(4, 2) 19 -QUBIT_COORDS(4, 3) 20 -QUBIT_COORDS(4, 4) 21 -QUBIT_COORDS(4, 5) 22 -QUBIT_COORDS(4, 6) 23 -QUBIT_COORDS(5, 0) 24 -QUBIT_COORDS(5, 1) 25 -QUBIT_COORDS(5, 2) 26 -QUBIT_COORDS(5, 3) 27 -QUBIT_COORDS(5, 4) 28 -QUBIT_COORDS(5, 5) 29 -QUBIT_COORDS(5, 6) 30 -QUBIT_COORDS(6, 0) 31 -QUBIT_COORDS(6, 1) 32 -QUBIT_COORDS(6, 2) 33 -QUBIT_COORDS(6, 3) 34 -QUBIT_COORDS(6, 4) 35 -QUBIT_COORDS(7, 0) 36 -QUBIT_COORDS(7, 1) 37 -QUBIT_COORDS(7, 2) 38 -QUBIT_COORDS(7, 3) 39 -QUBIT_COORDS(8, 0) 40 -QUBIT_COORDS(8, 1) 41 -RX 7 11 13 3 2 4 18 0 5 17 -R 12 8 6 -CX 7 12 11 6 13 8 7 8 11 12 7 6 13 12 2 6 4 8 18 12 6 2 8 4 12 18 3 4 17 18 3 2 18 17 4 3 2 3 -T_DAG 3 -CX 2 3 4 3 0 2 5 4 2 0 4 5 -RX 2 12 4 -R 6 18 8 9 -CX 2 6 4 8 5 9 12 18 2 0 6 11 8 13 9 5 12 7 2 3 6 7 8 9 12 13 4 3 8 7 12 11 18 17 3 4 7 8 11 12 17 18 0 2 7 12 11 6 13 8 3 2 7 6 9 8 13 12 2 6 4 8 12 18 -M 6 18 8 5 -MX 2 12 4 -DETECTOR(2, 0, 0) rec[-7] -DETECTOR(4, 1, 0) rec[-6] -DETECTOR(2, 2, 0) rec[-5] -DETECTOR(1, 3, 0) rec[-4] -DETECTOR(1, 0, 0) rec[-3] -DETECTOR(3, 1, 0) rec[-2] -DETECTOR(1, 2, 0) rec[-1] -SHIFT_COORDS(0, 0, 1) -RX 18 12 6 2 8 1 -T_DAG 0 3 7 9 11 13 17 -CX 1 0 2 3 6 7 8 9 12 11 18 17 3 1 7 8 12 18 7 3 12 13 7 12 -MX 7 -RX 7 -CX 7 12 7 3 12 13 3 1 7 8 12 18 1 0 2 3 6 7 8 9 12 11 18 17 -T 0 3 7 9 11 13 17 -MX 18 12 6 2 8 1 -DETECTOR(2.14286, 1, 0, -1, -9) rec[-9] rec[-8] rec[-7] -DETECTOR(4, 1, 1) rec[-6] -DETECTOR(3, 1, 1) rec[-5] -DETECTOR(2, 1, 1) rec[-4] rec[-7] -DETECTOR(1, 0, 1) rec[-3] -DETECTOR(2, 2, 1) rec[-2] -DETECTOR(0, 1, 1) rec[-1] -SHIFT_COORDS(0, 0, 3) -RX 26 33 36 16 28 27 -R 19 25 32 38 40 23 15 22 21 29 34 -CX 16 22 26 19 27 34 28 21 33 38 36 40 16 15 22 23 26 25 28 29 33 32 15 16 23 22 25 26 29 28 32 33 -M 26 33 28 22 16 -DETECTOR(5, 2, 0) rec[-5] -DETECTOR(6, 2, 0) rec[-4] -DETECTOR(5, 4, 0) rec[-3] -DETECTOR(4, 5, 0) rec[-2] -DETECTOR(3, 5, 0) rec[-1] -SHIFT_COORDS(0, 0, 1) -RX 37 28 26 24 16 14 12 4 2 -R 41 35 33 31 22 20 18 8 6 -CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 -M 41 35 33 31 22 20 18 8 6 -MX 37 28 26 24 16 14 12 4 2 -DETECTOR(1.25, 0.25, 0, -1, -9) rec[-30] rec[-1] -DETECTOR(1.5, 1.875, 0, -1, -9) rec[-30] rec[-2] -DETECTOR(1.75, 0.25, 0, -1, -9) rec[-10] -DETECTOR(2, 1.875, 0, -1, -9) rec[-11] -DETECTOR(3.075, 0.9125, 0, -1, -9) rec[-30] rec[-3] -DETECTOR(3.5, 4.875, 0, -1, -9) rec[-5] -DETECTOR(3.575, 0.9125, 0, -1, -9) rec[-12] -DETECTOR(4, 4.875, 0, -1, -9) rec[-14] -DETECTOR(5.25, 2, 0, -1, -9) rec[-7] -DETECTOR(5, 3.875, 0, -1, -9) rec[-8] -DETECTOR(5.75, 2, 0, -1, -9) rec[-16] -DETECTOR(5.5, 3.875, 0, -1, -9) rec[-17] -DETECTOR(7, 0.875, 0, -1, -9) rec[-9] -DETECTOR(7.5, 0.875, 0, -1, -9) rec[-18] -SHIFT_COORDS(0, 0, 1) -CZ rec[-6] 36 rec[-6] 40 rec[-4] 15 rec[-4] 23 -CX rec[-15] 36 rec[-15] 40 rec[-15] 38 rec[-15] 40 rec[-16] 36 rec[-16] 40 rec[-12] 15 rec[-12] 23 rec[-13] 0 rec[-13] 11 rec[-13] 23 rec[-14] 15 rec[-14] 23 -RX 37 28 26 24 16 14 12 4 2 -R 41 35 33 31 22 20 18 8 6 -CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 -M 41 35 33 31 22 20 18 8 6 -MX 37 28 26 24 16 14 12 4 2 -DETECTOR(1, 0, 0, -1, -9) rec[-19] rec[-1] -DETECTOR(1, 2, 0, -1, -9) rec[-20] rec[-2] -DETECTOR(2, 0, 0, -1, -9) rec[-29] rec[-28] rec[-10] -DETECTOR(2, 2, 0, -1, -9) rec[-28] rec[-11] -DETECTOR(3, 1, 0, -1, -9) rec[-21] rec[-3] -DETECTOR(3, 3, 0, -1, -9) rec[-4] -DETECTOR(3, 5, 0, -1, -9) rec[-23] rec[-5] -DETECTOR(4, 1, 0, -1, -9) rec[-12] -DETECTOR(4, 3, 0, -1, -9) rec[-13] -DETECTOR(4, 5, 0, -1, -9) rec[-14] -DETECTOR(5, 0, 0, -1, -9) rec[-6] -DETECTOR(5, 2, 0, -1, -9) rec[-25] rec[-7] -DETECTOR(5, 4, 0, -1, -9) rec[-26] rec[-8] -DETECTOR(6, 0, 0, -1, -9) rec[-15] -DETECTOR(6, 2, 0, -1, -9) rec[-16] -DETECTOR(6, 4, 0, -1, -9) rec[-34] rec[-17] -DETECTOR(7, 1, 0, -1, -9) rec[-27] rec[-9] -DETECTOR(8, 1, 0, -1, -9) rec[-18] -SHIFT_COORDS(0, 0, 1) -RX 37 28 26 24 16 14 12 4 2 -R 41 35 33 31 22 20 18 8 6 -CX 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 3 4 7 8 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 28 32 33 34 35 36 37 40 41 3 2 7 6 9 8 13 12 15 14 19 18 21 20 23 22 25 24 27 26 29 28 32 31 34 33 38 37 0 2 7 12 9 14 11 6 13 8 17 24 19 26 21 28 25 18 27 20 29 22 32 37 36 31 38 33 4 3 8 7 12 11 14 13 16 15 18 17 20 19 22 21 26 25 28 27 33 32 35 34 37 36 41 40 2 3 6 7 8 9 12 13 14 15 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 37 38 2 0 6 11 8 13 12 7 14 9 18 25 20 27 22 29 24 17 26 19 28 21 31 36 33 38 37 32 2 6 4 8 12 18 14 20 16 22 24 31 26 33 28 35 37 41 -M 41 35 33 31 22 20 18 8 6 -MX 37 28 26 24 16 14 12 4 2 -DETECTOR(1, 0, 0, -1, -9) rec[-19] rec[-1] -DETECTOR(1, 2, 0, -1, -9) rec[-20] rec[-2] -DETECTOR(2, 0, 0, -1, -9) rec[-29] rec[-28] rec[-10] -DETECTOR(2, 2, 0, -1, -9) rec[-28] rec[-11] -DETECTOR(3, 1, 0, -1, -9) rec[-21] rec[-3] -DETECTOR(3, 3, 0, -1, -9) rec[-22] rec[-4] -DETECTOR(3, 5, 0, -1, -9) rec[-23] rec[-5] -DETECTOR(4, 1, 0, -1, -9) rec[-31] rec[-12] -DETECTOR(4, 3, 0, -1, -9) rec[-32] rec[-30] rec[-13] -DETECTOR(4, 5, 0, -1, -9) rec[-31] rec[-14] -DETECTOR(5, 0, 0, -1, -9) rec[-24] rec[-6] -DETECTOR(5, 2, 0, -1, -9) rec[-25] rec[-7] -DETECTOR(5, 4, 0, -1, -9) rec[-26] rec[-8] -DETECTOR(6, 0, 0, -1, -9) rec[-34] rec[-33] rec[-15] -DETECTOR(6, 2, 0, -1, -9) rec[-35] rec[-33] rec[-16] -DETECTOR(6, 4, 0, -1, -9) rec[-34] rec[-17] -DETECTOR(7, 1, 0, -1, -9) rec[-27] rec[-9] -DETECTOR(8, 1, 0, -1, -9) rec[-18] -SHIFT_COORDS(0, 0, 1) -RX 24 31 2 6 8 10 20 22 39 1 12 18 37 33 14 26 28 30 41 -T 0 11 17 19 36 40 -T_DAG 3 7 9 13 15 21 23 25 27 29 32 34 38 -CX 1 0 2 3 6 7 8 13 10 15 12 11 14 9 18 17 20 27 22 29 24 25 26 19 28 21 30 23 31 32 33 34 37 36 39 38 41 40 3 1 14 15 29 30 33 38 37 41 7 3 13 14 26 33 28 29 32 37 12 13 25 32 27 28 12 7 26 27 18 12 25 26 25 18 -MX 25 -RX 25 -CX 25 18 18 12 25 26 12 7 26 27 12 13 25 32 27 28 7 3 13 14 26 33 28 29 32 37 3 1 14 15 29 30 33 38 37 41 1 0 2 3 6 7 8 13 10 15 12 11 14 9 18 17 20 27 22 29 24 25 26 19 28 21 30 23 31 32 33 34 37 36 39 38 41 40 -T_DAG 0 11 17 19 36 40 -T 3 7 9 13 15 21 23 25 27 29 32 34 38 -MX 20 22 8 10 2 6 24 31 39 1 12 18 37 33 14 26 28 30 41 -OBSERVABLE_INCLUDE(0) rec[-10] rec[-9] rec[-8] rec[-7] rec[-6] rec[-5] rec[-4] rec[-3] rec[-2] rec[-1] -DETECTOR(2.25889, 1.08534, 0, -1, -9) rec[-85] rec[-84] rec[-81] rec[-80] rec[-74] rec[-73] rec[-72] rec[-70] rec[-68] rec[-67] rec[-56] rec[-55] rec[-54] rec[-52] rec[-51] rec[-50] rec[-49] rec[-38] rec[-37] rec[-36] rec[-34] rec[-33] rec[-32] rec[-31] rec[-20] -DETECTOR(4, 3, 1) rec[-19] -DETECTOR(4, 5, 1) rec[-18] -DETECTOR(2, 2, 1) rec[-17] -DETECTOR(2, 4, 1) rec[-16] -DETECTOR(1, 0, 1) rec[-15] -DETECTOR(2, 0, 1) rec[-14] -DETECTOR(5, 1, 1) rec[-13] rec[-20] -DETECTOR(6, 0, 1) rec[-12] -DETECTOR(7, 3, 1) rec[-11] -DETECTOR(0, 1, 1) rec[-10] -DETECTOR(3, 1, 1) rec[-9] -DETECTOR(4, 1, 1) rec[-8] -DETECTOR(7, 1, 1) rec[-7] -DETECTOR(6, 2, 1) rec[-6] -DETECTOR(3, 3, 1) rec[-5] -DETECTOR(5, 2, 1) rec[-4] -DETECTOR(5, 4, 1) rec[-3] -DETECTOR(5, 6, 1) rec[-2] -DETECTOR(8, 1, 1) rec[-1] -SHIFT_COORDS(0, 0, 3) -MPP X0*X3*X7*X11 X9*X13*X15*X19*X21*X27 X17*X25*X32*X36 Z0*Z3*Z7*Z11 Z9*Z13*Z15*Z19*Z21*Z27 Z17*Z25*Z32*Z36 X3*X7*X9*X13 X15*X21*X23*X29 X19*X25*X27*X32*X34*X38 Z3*Z7*Z9*Z13 Z15*Z21*Z23*Z29 Z19*Z25*Z27*Z32*Z34*Z38 X7*X11*X13*X17*X19*X25 X21*X27*X29*X34 X32*X36*X38*X40 Z7*Z11*Z13*Z17*Z19*Z25 Z21*Z27*Z29*Z34 Z32*Z36*Z38*Z40 -DETECTOR(0.625, 0.125, 0, -1, -9) rec[-39] rec[-18] -DETECTOR(0.875, 0.125, 0, -1, -9) rec[-49] rec[-48] rec[-15] -DETECTOR(1.25, 1.4375, 0, -1, -9) rec[-40] rec[-12] -DETECTOR(1.5, 1.4375, 0, -1, -9) rec[-48] rec[-9] -DETECTOR(2.625, 1, 0, -1, -9) rec[-41] rec[-38] rec[-6] -DETECTOR(2.875, 1, 0, -1, -9) rec[-51] rec[-3] -DETECTOR(2.625, 3, 0, -1, -9) rec[-42] rec[-17] -DETECTOR(2.875, 3, 0, -1, -9) rec[-52] rec[-50] rec[-14] -DETECTOR(3.25, 4.4375, 0, -1, -9) rec[-43] rec[-11] -DETECTOR(3.5, 4.4375, 0, -1, -9) rec[-51] rec[-8] -DETECTOR(4.625, 0.125, 0, -1, -9) rec[-44] rec[-38] rec[-16] -DETECTOR(4.875, 0.125, 0, -1, -9) rec[-54] rec[-53] rec[-13] -DETECTOR(4.625, 2, 0, -1, -9) rec[-45] rec[-38] rec[-10] -DETECTOR(4.875, 2, 0, -1, -9) rec[-55] rec[-53] rec[-7] -DETECTOR(4.5, 3.9375, 0, -1, -9) rec[-46] rec[-5] -DETECTOR(4.75, 3.9375, 0, -1, -9) rec[-54] rec[-2] -DETECTOR(6.5, 0.9375, 0, -1, -9) rec[-47] rec[-4] -DETECTOR(6.75, 0.9375, 0, -1, -9) rec[-1] -T_DAG 0 11 17 19 36 40 -T 3 7 9 13 15 21 23 25 27 29 32 34 38 -MPP Y0*Y3*Y7*Y9*Y11*Y13*Y15*Y17*Y19*Y21*Y23*Y25*Y27*Y29*Y32*Y34*Y36*Y38*Y40 -OBSERVABLE_INCLUDE(0) rec[-1] diff --git a/test/integration/test_determined_literature.py b/test/integration/test_determined_literature.py index f86c02a5..36ffed43 100644 --- a/test/integration/test_determined_literature.py +++ b/test/integration/test_determined_literature.py @@ -1,142 +1,38 @@ -"""Determined measurements of published cultivation circuits with T gates. +"""Determined measurements of a published cultivation circuit with T gates. -The circuits and their sources are in ``test/data/determined``. +The circuit and its source are in ``test/data/determined``. """ -from itertools import combinations from pathlib import Path -import numpy as np import pytest import stim from tsim.circuit import Circuit from tsim.determined import ( - _Declared, count_determined_measurements, missing_detectors, nondeterministic_detectors, ) -from tsim.utils.gf2_span import unpack -DATA = Path(__file__).parent.parent / "data" / "determined" +CIRCUIT = Path(__file__).parent.parent / "data" / "determined" +CIRCUIT = CIRCUIT / "chan_d5a19_uncorrected_T.stim" -def _circuit(name: str) -> Circuit: - return Circuit((DATA / f"{name}.stim").read_text()) - - -def _detectors(*indices: int) -> list[stim.DemTarget]: - return [stim.target_relative_detector_id(i) for i in indices] - - -def _healed(circuit: Circuit) -> list[set[int]]: - """Return each missing detector as the random detectors whose XOR it is.""" - num_m = circuit.num_measurements - declared = unpack(_Declared(circuit.stim_circuit).words, num_m).astype(np.int64) - random = [target.val for target in nondeterministic_detectors(circuit)] - result = [] - for instruction in missing_detectors(circuit): - assert isinstance(instruction, stim.CircuitInstruction) - parity = np.zeros(num_m, dtype=np.int64) - for target in instruction.targets_copy(): - parity[num_m + target.value] ^= 1 - found = [ - set(subset) - for size in (2, 3) - for subset in combinations(random, size) - if np.array_equal(declared[list(subset)].sum(axis=0) % 2, parity) - ] - result.append(found[0] if found else set()) - return result - - -@pytest.mark.parametrize( - "name, num_detectors", - [ - ("chan_d5a19_T", 107), - ("chan_d5a19f13_T", 122), - ("clifft_d5_T", 107), - ("wan_clifft_d3_T", 20), - ("wan_soft_d5_T", 107), - ], -) @pytest.mark.parametrize("shots", [None, 2000]) -def test_published_t_circuits_have_every_detector_determined( - name, num_detectors, shots -): - # NOTE: Chan et al. (arXiv:2609.17706) and Clifft (arXiv:2604.27058) build - # these from S proxies with feedforward and detector healing; Wan and - # Zapirain (arXiv:2609.18922) use them as given. Each has one observable. - circuit = _circuit(name) - assert circuit.num_detectors == num_detectors - assert count_determined_measurements(circuit, shots=shots, seed=0) == ( - num_detectors + 1 - ) - assert nondeterministic_detectors(circuit, shots=shots, seed=0) == [] - assert len(missing_detectors(circuit, shots=shots, seed=0)) == 0 - - -def test_chan_uncorrected_d5_circuits_have_random_detectors(): +def test_chan_uncorrected_d5_circuit_has_random_detectors(shots): # NOTE: Chan et al. sim/d5-correction.md: "Bell growth leaves seven # first-round check results that control a Pauli frame", so swapping S for - # T needs feedforward first. - circuit = _circuit("chan_d5a19_uncorrected_T") - assert count_determined_measurements(circuit) == 106 - assert nondeterministic_detectors(circuit) == _detectors(69, 91, 97, 102) - assert _healed(circuit) == [{91, 97}, {91, 102}] - flagged = _circuit("chan_d5a19f13_uncorrected_T") - assert count_determined_measurements(flagged) == 121 - assert nondeterministic_detectors(flagged) == _detectors(71, 106, 112, 117) - assert _healed(flagged) == [{106, 112}, {106, 117}] - - -def test_each_clifft_conversion_rule_heals_detectors(): - # NOTE: Clifft's convert_s_to_t.py: rule 1 swaps S for T, rule 2 flips six - # T gates (Gidney et al.'s erratum), rules 3 and 4 add feedforward and heal - # the detectors. - proxy = _circuit("clifft_d5_sproxy") - assert count_determined_measurements(proxy) == ( - proxy.stim_circuit.count_determined_measurements() - ) - assert count_determined_measurements(proxy) == 108 - swapped = _circuit("clifft_d5_T_rule1") - assert count_determined_measurements(swapped) == 105 - assert nondeterministic_detectors(swapped) == _detectors(69, 93, 95, 99, 101, 103) - flipped = _circuit("clifft_d5_T_rule12") - assert count_determined_measurements(flipped) == 106 - assert nondeterministic_detectors(flipped) == _detectors(69, 99, 101, 103) - assert _healed(flipped) == [{99, 101}, {99, 103}] - assert nondeterministic_detectors(_circuit("clifft_d5_T")) == [] - - -def _feedforward_sources(circuit: stim.Circuit) -> list[int]: - measured, sources = 0, set() - for instruction in circuit.flattened(): - assert isinstance(instruction, stim.CircuitInstruction) - if instruction.name in ("CX", "CZ"): - for target in instruction.targets_copy(): - if target.is_measurement_record_target: - sources.add(measured + target.value) - measured += instruction.num_measurements - return sorted(sources) - - -def test_three_of_clifft_feedforward_sources_are_determined(): - # NOTE: convert_s_to_t.py rule 3 says that seven growth-check measurements - # "become random with T gates (they were deterministic with S)", but rule 4 - # that the (4,1), (4,5), (6,2) ones are "deterministically 0". Alone, those - # three are determined and the other four random, with S and with T. - circuit = _circuit("clifft_d5_T") - sources = _feedforward_sources(circuit.stim_circuit) - assert len(sources) == 7 - num_m = circuit.num_measurements - for name in ("clifft_d5_sproxy", "clifft_d5_T_rule12", "clifft_d5_T"): - alone = Circuit( - str(_circuit(name).stim_circuit.without_noise()) - + "\n" - + "\n".join(f"DETECTOR rec[{m - num_m}]" for m in sources) - ) - first = alone.num_detectors - len(sources) - random = [t.val - first for t in nondeterministic_detectors(alone)] - assert [sources[i] for i in range(7) if i not in random] == [21, 23, 25] + # T needs feedforward first. Without it, four detectors are random, and + # D91^D97 and D91^D102 are the determined parities of them. + circuit = Circuit(CIRCUIT.read_text()) + assert circuit.num_measurements == 112 + assert count_determined_measurements(circuit, shots=shots, seed=0) == 106 + assert nondeterministic_detectors(circuit, shots=shots, seed=0) == [ + stim.target_relative_detector_id(i) for i in (69, 91, 97, 102) + ] + missing = missing_detectors(circuit, shots=shots, seed=0) + assert str(missing) == str(stim.Circuit(""" + DETECTOR rec[-46] rec[-45] rec[-16] rec[-10] + DETECTOR rec[-47] rec[-45] rec[-39] rec[-16] rec[-5] + """)) From 1fbcca741c123aee1d0c68666c9b9081a346ea7f Mon Sep 17 00:00:00 2001 From: Rafael Haenel Date: Wed, 18 Nov 2026 16:50:21 -0700 Subject: [PATCH 4/6] Cache the directions of determined measurements; sample missing detectors with a reference sample Each public function compiles the circuit; cache the span by the noiseless circuit text (not for shots without a seed) so calling all three compiles once. The missing-detector docstring and test sample with use_detector_reference_sample=True, since a Tsim detector is its raw parity. Co-Authored-By: Claude Opus 5.5 --- src/tsim/determined.py | 29 ++++++++++++++++++++++------- test/unit/test_determined.py | 23 +++++++++++++++++++++-- 2 files changed, 43 insertions(+), 9 deletions(-) diff --git a/src/tsim/determined.py b/src/tsim/determined.py index 142afeee..71d5b926 100644 --- a/src/tsim/determined.py +++ b/src/tsim/determined.py @@ -31,6 +31,7 @@ from __future__ import annotations +import functools import warnings from itertools import product from typing import TYPE_CHECKING @@ -117,8 +118,8 @@ def missing_detectors( result is no particularly good basis otherwise. A Tsim detector is its raw parity, so a returned one whose noiseless value - is 1 fires in every shot unless the sampler XORs in a reference sample - (``use_detector_reference_sample=True``). + is 1 fires in every shot: sample with + ``sample(..., use_detector_reference_sample=True)``. Args: circuit: The circuit. Its noise is ignored. @@ -267,18 +268,32 @@ def _overlaps( def _directions( circuit: Circuit, unknown_input: bool, shots: int | None, seed: int | None ) -> Span: - """Return the span of ``m + m₀`` over the noiseless records ``m``.""" + """Return the span of ``m + m₀`` over the noiseless records ``m``. + + The span is cached, since every function here needs it and compiling is + slow, but not from shots without a seed. Callers must not change it. + """ + if shots is not None and shots < 1: + raise ValueError(f"shots must be at least 1, not {shots}") + text = str(circuit.without_noise().without_annotations().stim_circuit) + if shots is not None and seed is None: + return _directions_of.__wrapped__(text, unknown_input, shots, seed) + return _directions_of(text, unknown_input, shots, seed) + + +@functools.lru_cache(maxsize=8) +def _directions_of( + text: str, unknown_input: bool, shots: int | None, seed: int | None +) -> Span: from tsim.circuit import Circuit - noiseless = circuit.without_noise().without_annotations() + noiseless = Circuit(stim.Circuit(text)) if unknown_input and noiseless.num_qubits: mixed = stim.Circuit() mixed.append("X_ERROR", range(noiseless.num_qubits), 0.5) noiseless = Circuit.from_stim_program(mixed) + noiseless if shots is None: return _exact_directions(noiseless) - if shots < 1: - raise ValueError(f"shots must be at least 1, not {shots}") return _sampled_directions(noiseless, shots, seed) @@ -304,7 +319,7 @@ def _sampled_directions(circuit: Circuit, shots: int, seed: int | None) -> Span: warnings.warn( f"shot {last_growth} of {shots} still found a new direction, so some " "parities that look determined may be random; use more shots", - stacklevel=4, + stacklevel=5, ) return span diff --git a/test/unit/test_determined.py b/test/unit/test_determined.py index f33e389c..9c4f8b99 100644 --- a/test/unit/test_determined.py +++ b/test/unit/test_determined.py @@ -6,11 +6,20 @@ from tsim.circuit import Circuit from tsim.determined import ( + _directions_of, count_determined_measurements, missing_detectors, nondeterministic_detectors, ) + +@pytest.fixture(autouse=True) +def _uncached(): + # NOTE: some tests change the limits of the exact walk, which the cached + # directions do not see. + _directions_of.cache_clear() + + STIM_EXAMPLES = [ "R 0\nM 0", "R 0\nH 0\nM 0", @@ -78,8 +87,8 @@ def test_the_missing_detectors_are_determined_in_every_shot(text): bare = Circuit(text).without_noise().without_annotations() missing = missing_detectors(bare) assert len(missing) == count_determined_measurements(bare) - samples = (bare + missing).compile_detector_sampler(seed=1).sample(500) - assert (samples == samples[0]).all() + sampler = (bare + missing).compile_detector_sampler(seed=1) + assert not sampler.sample(500, use_detector_reference_sample=True).any() def test_t_gates_randomize_a_measurement_and_t4_is_z(): @@ -242,6 +251,7 @@ def test_unknown_inputs_that_set_rotation_signs_match_many_shots(text, monkeypat ) assert exact == sampled monkeypatch.setattr("tsim.determined.MAX_SIGN_BITS", 0) + _directions_of.cache_clear() with pytest.raises(ValueError, match="independent rotation signs"): count_determined_measurements(circuit, unknown_input=True) @@ -289,3 +299,12 @@ def test_padded_measurements_are_determined(): def test_a_circuit_without_measurements(): assert count_determined_measurements(Circuit("H 0\nT 0")) == 0 assert len(missing_detectors(Circuit("H 0\nT 0"))) == 0 + + +def test_the_directions_are_cached_unless_shots_have_no_seed(): + circuit = Circuit("R 0\nH 0\nT 0\nH 0\nM 0\nDETECTOR rec[-1]") + count_determined_measurements(circuit) + nondeterministic_detectors(circuit) + assert _directions_of.cache_info().hits == 1 + count_determined_measurements(circuit, shots=10) + assert _directions_of.cache_info().currsize == 1 From 6f6b1a2aca14f757108a1df168d5b1f3321304fe Mon Sep 17 00:00:00 2001 From: Rafael Haenel Date: Wed, 18 Nov 2026 20:09:58 -0700 Subject: [PATCH 5/6] Fix review issues in determined measurements - Warn about too few shots after the cache lookup, so a cache hit warns too. - Ignore the seed in the exact path's cache key. - Drop the exact path's single-pass batch loop and Span.contains. - Build declarations from record sets; share the random-declaration helper. - Suggest sampling when the exact walk exceeds its branch limit. - Compute each lane's weight once in Branches; test properties, not pivots. Co-Authored-By: Claude Opus 5.5 --- src/tsim/determined.py | 104 +++++++++--------- src/tsim/statevector/branches.py | 6 +- src/tsim/utils/gf2_span.py | 22 ---- .../integration/test_determined_literature.py | 11 +- test/unit/statevector/test_branches.py | 7 +- test/unit/test_determined.py | 8 +- test/unit/utils/test_gf2_span.py | 10 +- 7 files changed, 76 insertions(+), 92 deletions(-) diff --git a/src/tsim/determined.py b/src/tsim/determined.py index 71d5b926..d2874321 100644 --- a/src/tsim/determined.py +++ b/src/tsim/determined.py @@ -33,7 +33,6 @@ import functools import warnings -from itertools import product from typing import TYPE_CHECKING import numba @@ -53,7 +52,7 @@ """Most independent rotation signs that unknown inputs may set, exactly.""" BATCH = 1 << 16 -"""Shots drawn, or combinations of unknown inputs tried, at a time.""" +"""Shots drawn at a time.""" def count_determined_measurements( @@ -89,7 +88,8 @@ def count_determined_measurements( Raises: ValueError: If the exact walk follows more than - ``Branches.MAX_BRANCHES`` branches per combination of inputs, or + ``tsim.statevector.branches.MAX_BRANCHES`` branches per + combination of inputs, or unknown inputs set more than ``MAX_SIGN_BITS`` independent rotation signs. Sampling avoids both. @@ -134,8 +134,7 @@ def missing_detectors( num_m = circuit.num_measurements directions = _directions(circuit, unknown_input, shots, seed) declared = _Declared(circuit.stim_circuit) - overlaps = declared.overlaps(directions.basis()) - random = np.flatnonzero(overlaps.any(axis=1)) + overlaps, random = declared.random(directions) covered = Span(num_m) covered.insert(np.delete(declared.words, random, axis=0)) # NOTE: a parity of random declarations is determined when it overlaps no @@ -182,7 +181,7 @@ def nondeterministic_detectors( """ directions = _directions(circuit, unknown_input, shots, seed) - overlaps = _Declared(circuit.stim_circuit).overlaps(directions.basis()) + _, random = _Declared(circuit.stim_circuit).random(directions) num_detectors = circuit.num_detectors return [ ( @@ -190,7 +189,7 @@ def nondeterministic_detectors( if index < num_detectors else stim.target_logical_observable_id(index - num_detectors) ) - for index in np.flatnonzero(overlaps.any(axis=1)).tolist() + for index in random.tolist() ] @@ -208,7 +207,10 @@ class _Declared: def __init__(self, circuit: stim.Circuit) -> None: num_m = circuit.num_measurements num_detectors = circuit.num_detectors - rows, records = [], [] + # NOTE: a measurement that a declaration names twice cancels. + members: list[set[int]] = [ + set() for _ in range(num_detectors + circuit.num_observables) + ] measured = detector = 0 for instruction in circuit.flattened(): assert isinstance(instruction, stim.CircuitInstruction) @@ -226,27 +228,23 @@ def __init__(self, circuit: stim.Circuit) -> None: f"{instruction.name} with a non-record target ({target}) " "is not supported" ) - rows.append(row) - records.append(measured + target.value) - # NOTE: a measurement that a declaration names twice cancels. - keys, counts = np.unique( - np.array(rows, dtype=np.int64) * num_m + np.array(records, dtype=np.int64), - return_counts=True, + members[row] ^= {measured + target.value} + sizes = [len(records) for records in members] + self.starts = np.cumsum([0, *sizes], dtype=np.int64) + self.records = np.array( + [m for records in members for m in sorted(records)], dtype=np.int64 ) - keys = keys[counts % 2 == 1] - row, self.records = np.divmod(keys, max(num_m, 1)) - count = num_detectors + circuit.num_observables - self.starts = np.searchsorted(row, np.arange(count + 1)) - self.words = np.zeros((count, num_words(num_m)), dtype=np.uint64) + self.words = np.zeros((len(members), num_words(num_m)), dtype=np.uint64) np.bitwise_or.at( self.words, - (row, self.records // 64), + (np.repeat(np.arange(len(members)), sizes), self.records // 64), np.uint64(1) << (self.records % 64).astype(np.uint64), ) - def overlaps(self, directions: np.ndarray) -> np.ndarray: - """Return, packed, which of the packed ``directions`` each declaration flips.""" - return _overlaps(np.ascontiguousarray(directions), self.starts, self.records) + def random(self, directions: Span) -> tuple[np.ndarray, np.ndarray]: + """Return which directions each declaration flips, packed, and the random ones.""" + overlaps = _overlaps(directions.basis(), self.starts, self.records) + return overlaps, np.flatnonzero(overlaps.any(axis=1)) @numba.njit(cache=True) @@ -273,18 +271,27 @@ def _directions( The span is cached, since every function here needs it and compiling is slow, but not from shots without a seed. Callers must not change it. """ - if shots is not None and shots < 1: - raise ValueError(f"shots must be at least 1, not {shots}") text = str(circuit.without_noise().without_annotations().stim_circuit) - if shots is not None and seed is None: - return _directions_of.__wrapped__(text, unknown_input, shots, seed) - return _directions_of(text, unknown_input, shots, seed) + if shots is None: + return _directions_of(text, unknown_input, None, None)[0] + if shots < 1: + raise ValueError(f"shots must be at least 1, not {shots}") + find = _directions_of if seed is not None else _directions_of.__wrapped__ + span, last_growth = find(text, unknown_input, shots, seed) + if last_growth > shots // 2: + warnings.warn( + f"shot {last_growth} of {shots} still found a new direction, so some " + "parities that look determined may be random; use more shots", + stacklevel=3, + ) + return span @functools.lru_cache(maxsize=8) def _directions_of( text: str, unknown_input: bool, shots: int | None, seed: int | None -) -> Span: +) -> tuple[Span, int]: + """Return the directions, and the last shot that grew them, if sampled.""" from tsim.circuit import Circuit noiseless = Circuit(stim.Circuit(text)) @@ -293,12 +300,17 @@ def _directions_of( mixed.append("X_ERROR", range(noiseless.num_qubits), 0.5) noiseless = Circuit.from_stim_program(mixed) + noiseless if shots is None: - return _exact_directions(noiseless) + return _exact_directions(noiseless), 0 return _sampled_directions(noiseless, shots, seed) -def _sampled_directions(circuit: Circuit, shots: int, seed: int | None) -> Span: - """Return the span of ``m + m₀`` over ``shots`` noiseless shots ``m``.""" +def _sampled_directions( + circuit: Circuit, shots: int, seed: int | None +) -> tuple[Span, int]: + """Return the span of ``m + m₀`` over ``shots`` noiseless shots ``m``. + + Also return the last shot that grew it. + """ num_m = circuit.num_measurements span = Span(num_m) sampler = circuit.compile_sampler(seed=seed) @@ -315,13 +327,7 @@ def _sampled_directions(circuit: Circuit, shots: int, seed: int | None) -> Span: grew = span.insert(rows[order]) if grew.any(): last_growth = done + int(first[order][grew].max()) + 1 - if last_growth > shots // 2: - warnings.warn( - f"shot {last_growth} of {shots} still found a new direction, so some " - "parities that look determined may be random; use more shots", - stacklevel=5, - ) - return span + return span, last_growth def _exact_directions(circuit: Circuit) -> Span: @@ -363,7 +369,7 @@ def _exact_directions(circuit: Circuit) -> Span: f"than {MAX_SIGN_BITS}; pass shots to sample instead" ) f = np.zeros((1 << len(choices), num_f), dtype=np.uint8) - f[:, choices] = list(product((0, 1), repeat=len(choices))) + f[:, choices] = np.arange(len(f))[:, None] >> np.arange(len(choices)) & 1 # NOTE: a tape's outputs are its f-bits' flips XOR a value that depends # only on its rotation signs: walk each distinct signs once. @@ -371,22 +377,20 @@ def _exact_directions(circuit: Circuit) -> Span: for branches, outputs in tapes: local = f[:, branches.f_selection] first, inverse = _groups(gf2_product(local, branches.sign_rows)) - row, values = branches.support(local[first]) + try: + row, values = branches.support(local[first]) + except ValueError as error: + raise ValueError(f"{error}; pass shots to sample instead") from error firsts = values[np.searchsorted(row, np.arange(len(first)))] within = Span(len(outputs)) within.insert_bits(values ^ firsts[row]) span.insert_bits(_embed(unpack(within.basis(), len(outputs)), outputs, num_m)) base = firsts ^ gf2_product(local[first], branches.output_rows) bases.append((inverse, base, outputs)) - reference = None - for start in range(0, len(f), BATCH): - chunk = slice(start, start + BATCH) - points = gf2_product(f[chunk], output_map) ^ constant - for inverse, base, outputs in bases: - points[:, outputs] ^= base[inverse[chunk]] - if reference is None: - reference = points[0].copy() - span.insert_bits(points ^ reference) + points = gf2_product(f, output_map) ^ constant + for inverse, base, outputs in bases: + points[:, outputs] ^= base[inverse] + span.insert_bits(points ^ points[0]) return span diff --git a/src/tsim/statevector/branches.py b/src/tsim/statevector/branches.py index 9b3db051..d8b56dd1 100644 --- a/src/tsim/statevector/branches.py +++ b/src/tsim/statevector/branches.py @@ -259,14 +259,16 @@ def _walk( ) continue children = [] + weight = _weights(amps) for outcome in (0, 1): if tape.kind[a] == MEASURE_DORMANT: kept, child = np.arange(len(row)), amps * np.sqrt(0.5) else: moved = amps[:, source] * phase projected = (amps - moved if outcome else amps + moved) / 2 - # NOTE: relative to the lane's weight, as ``shared._cut``. - possible = _weights(projected) > IMPOSSIBLE * _weights(amps) + # NOTE: an outcome is impossible given the lane, whatever + # the lane's own weight. + possible = _weights(projected) > IMPOSSIBLE * weight kept = np.flatnonzero(possible) projected = projected[kept] # NOTE: the planner moved the measured Pauli onto the pivot, diff --git a/src/tsim/utils/gf2_span.py b/src/tsim/utils/gf2_span.py index 905db77c..1072c719 100644 --- a/src/tsim/utils/gf2_span.py +++ b/src/tsim/utils/gf2_span.py @@ -79,24 +79,6 @@ def _insert(basis: np.ndarray, has: np.ndarray, rows: np.ndarray) -> np.ndarray: return grew -@numba.njit(cache=True) -def _contains(basis: np.ndarray, has: np.ndarray, rows: np.ndarray) -> np.ndarray: - """Return, for each of ``rows``, whether it is in the span.""" - inside = np.ones(len(rows), dtype=np.bool_) - v = np.empty(basis.shape[1], dtype=np.uint64) - for i in range(len(rows)): - v[:] = rows[i] - while True: - p = _lowest(v) - if p < 0: - break - if not has[p]: - inside[i] = False - break - v ^= basis[p] - return inside - - @numba.njit(cache=True) def _annihilator(basis: np.ndarray, has: np.ndarray) -> np.ndarray: """Return, per column j that is no pivot, e_j plus the pivots before it, packed.""" @@ -154,10 +136,6 @@ def insert_bits(self, bits: np.ndarray) -> np.ndarray: bits = np.asarray(bits, dtype=np.uint8) return self.insert(pack(bits[None] if bits.ndim == 1 else bits)) - def contains(self, words: np.ndarray) -> np.ndarray: - """Return, for each packed vector, whether it is in the span.""" - return _contains(self._basis, self._has, self._rows(words)) - def annihilator(self) -> np.ndarray: """Return a basis of the vectors orthogonal to the span, packed. diff --git a/test/integration/test_determined_literature.py b/test/integration/test_determined_literature.py index 36ffed43..45188b3d 100644 --- a/test/integration/test_determined_literature.py +++ b/test/integration/test_determined_literature.py @@ -10,10 +10,12 @@ from tsim.circuit import Circuit from tsim.determined import ( + _Declared, count_determined_measurements, missing_detectors, nondeterministic_detectors, ) +from tsim.utils.gf2_span import Span CIRCUIT = Path(__file__).parent.parent / "data" / "determined" CIRCUIT = CIRCUIT / "chan_d5a19_uncorrected_T.stim" @@ -32,7 +34,8 @@ def test_chan_uncorrected_d5_circuit_has_random_detectors(shots): stim.target_relative_detector_id(i) for i in (69, 91, 97, 102) ] missing = missing_detectors(circuit, shots=shots, seed=0) - assert str(missing) == str(stim.Circuit(""" - DETECTOR rec[-46] rec[-45] rec[-16] rec[-10] - DETECTOR rec[-47] rec[-45] rec[-39] rec[-16] rec[-5] - """)) + assert len(missing) == 2 + words = _Declared((circuit + missing).stim_circuit).words + span = Span(circuit.num_measurements) + span.insert(words[[107, 108]]) + assert not span.insert(words[[91, 91]] ^ words[[97, 102]]).any() diff --git a/test/unit/statevector/test_branches.py b/test/unit/statevector/test_branches.py index 9e8685ae..6834c022 100644 --- a/test/unit/statevector/test_branches.py +++ b/test/unit/statevector/test_branches.py @@ -141,10 +141,9 @@ def test_the_support_with_its_coins_is_every_possible_outcome(name): dtype=np.uint8, ).reshape(-1, coins.shape[1]) expected = [set() for _ in f] - for r, weight, out in branches._leaves(f): - for i, w, o in zip(r.tolist(), weight.tolist(), out.tolist(), strict=True): - if w > 1e-12: - expected[i].add(tuple(o)) + for r, _, out in branches._leaves(f): + for i, o in zip(r.tolist(), out.tolist(), strict=True): + expected[i].add(tuple(o)) got = [set() for _ in f] for i, v in zip(row.tolist(), values, strict=True): got[i] |= {tuple(int(b) for b in v ^ flip) for flip in flips} diff --git a/test/unit/test_determined.py b/test/unit/test_determined.py index 9c4f8b99..e8cc053f 100644 --- a/test/unit/test_determined.py +++ b/test/unit/test_determined.py @@ -283,8 +283,10 @@ def test_too_few_shots_warn(): circuit = Circuit( "R 0 1 2 3 4 5 6 7 8 9\nH 0 1 2 3 4 5 6 7 8 9\nM 0 1 2 3 4 5 6 7 8 9" ) - with pytest.warns(UserWarning, match="use more shots"): - count_determined_measurements(circuit, shots=12, seed=0) + for function in (count_determined_measurements, missing_detectors): + with pytest.warns(UserWarning, match="use more shots") as record: + function(circuit, shots=12, seed=0) + assert record[0].filename == __file__ with pytest.raises(ValueError, match="at least 1"): count_determined_measurements(circuit, shots=0) @@ -304,7 +306,7 @@ def test_a_circuit_without_measurements(): def test_the_directions_are_cached_unless_shots_have_no_seed(): circuit = Circuit("R 0\nH 0\nT 0\nH 0\nM 0\nDETECTOR rec[-1]") count_determined_measurements(circuit) - nondeterministic_detectors(circuit) + nondeterministic_detectors(circuit, seed=3) assert _directions_of.cache_info().hits == 1 count_determined_measurements(circuit, shots=10) assert _directions_of.cache_info().currsize == 1 diff --git a/test/unit/utils/test_gf2_span.py b/test/unit/utils/test_gf2_span.py index bf84afde..51b102f3 100644 --- a/test/unit/utils/test_gf2_span.py +++ b/test/unit/utils/test_gf2_span.py @@ -48,13 +48,9 @@ def test_the_annihilator_is_the_orthogonal_complement(seed): assert ends == sorted(set(ends)) -def test_contains(): +def test_the_basis_has_one_vector_per_pivot(): span = Span(3) - vectors = pack(np.array([[0, 0, 0], [1, 1, 0], [0, 1, 1], [1, 0, 1]])) - assert span.contains(vectors).tolist() == [True, False, False, False] - span.insert(vectors[1]) - assert span.contains(vectors).tolist() == [True, True, False, False] - span.insert(vectors[2]) - assert span.contains(vectors).tolist() == [True, True, True, True] + grew = span.insert(pack(np.array([[0, 0, 0], [1, 1, 0], [0, 1, 1], [1, 0, 1]]))) + assert grew.tolist() == [False, True, True, False] assert span.rank == 2 assert unpack(span.basis(), 3).tolist() == [[1, 1, 0], [0, 1, 1]] From 1c82b67d35d1291712114b53dee3762c016fc28a Mon Sep 17 00:00:00 2001 From: Rafael Haenel Date: Wed, 18 Nov 2026 20:22:03 -0700 Subject: [PATCH 6/6] test: cover the numba kernels of determined measurements as Python Coverage cannot trace numba kernels, so the GF(2) span tests and one determined-measurement test also run them through py_func. Also test refused Pauli declarations and the support walk with split lanes. Co-Authored-By: Claude Opus 5.5 --- test/unit/statevector/test_branches.py | 6 +++++- test/unit/test_determined.py | 24 ++++++++++++++++++++++++ test/unit/utils/test_gf2_span.py | 10 ++++++++++ 3 files changed, 39 insertions(+), 1 deletion(-) diff --git a/test/unit/statevector/test_branches.py b/test/unit/statevector/test_branches.py index 6834c022..53a4d2b3 100644 --- a/test/unit/statevector/test_branches.py +++ b/test/unit/statevector/test_branches.py @@ -124,8 +124,12 @@ def test_a_random_noiseless_output_has_no_reference(): assert Branches(compiled, num_detectors=1).reference is not None +@pytest.mark.parametrize("split", [False, True]) @pytest.mark.parametrize("name", sorted(CIRCUITS)) -def test_the_support_with_its_coins_is_every_possible_outcome(name): +def test_the_support_with_its_coins_is_every_possible_outcome(name, split, monkeypatch): + if split: + # NOTE: two-row lanes, so the walk splits them. + monkeypatch.setattr("tsim.statevector.branches.MAX_BYTES", 64) for compiled, ops in _components(CIRCUITS[name], sample_detectors=False): branches = Branches(compiled, num_detectors=len(compiled.output_indices)) f = np.array(f_patterns(ops.num_f, limit=4), dtype=np.uint8) diff --git a/test/unit/test_determined.py b/test/unit/test_determined.py index e8cc053f..c4943695 100644 --- a/test/unit/test_determined.py +++ b/test/unit/test_determined.py @@ -310,3 +310,27 @@ def test_the_directions_are_cached_unless_shots_have_no_seed(): assert _directions_of.cache_info().hits == 1 count_determined_measurements(circuit, shots=10) assert _directions_of.cache_info().currsize == 1 + + +def test_declarations_of_paulis_are_refused(): + circuit = Circuit("R 0\nM 0\nOBSERVABLE_INCLUDE(0) X0") + with pytest.raises(ValueError, match="non-record target"): + missing_detectors(circuit) + + +def test_the_kernels_as_python_give_the_same_results(monkeypatch): + # NOTE: coverage cannot see inside numba kernels, so run them as Python too. + import tsim.determined + import tsim.utils.gf2_span + + circuit = Circuit("R 0 1 2\nH 0\nT 0\nCX 0 1\nH 0\nM 0 1\nDETECTOR rec[-1]\nM 2") + expected = str(missing_detectors(circuit)), nondeterministic_detectors(circuit) + for module, names in ( + (tsim.determined, ["_overlaps"]), + (tsim.utils.gf2_span, ["_lowest", "_has_bit", "_insert", "_annihilator"]), + ): + for name in names: + monkeypatch.setattr(module, name, getattr(module, name).py_func) + _directions_of.cache_clear() + got = str(missing_detectors(circuit)), nondeterministic_detectors(circuit) + assert got == expected diff --git a/test/unit/utils/test_gf2_span.py b/test/unit/utils/test_gf2_span.py index 51b102f3..d4b68fdd 100644 --- a/test/unit/utils/test_gf2_span.py +++ b/test/unit/utils/test_gf2_span.py @@ -3,9 +3,19 @@ import numpy as np import pytest +import tsim.utils.gf2_span from tsim.utils.gf2_span import Span, pack, pack_bytes, unpack +@pytest.fixture(autouse=True, params=["numba", "python"]) +def _kernels(request, monkeypatch): + # NOTE: coverage cannot see inside numba kernels, so run them as Python too. + if request.param == "python": + for name in ("_lowest", "_has_bit", "_insert", "_annihilator"): + kernel = getattr(tsim.utils.gf2_span, name) + monkeypatch.setattr(tsim.utils.gf2_span, name, kernel.py_func) + + def _rank(matrix: np.ndarray) -> int: matrix = matrix.copy() % 2 rank = 0