qLDPC 0.3.0__tar.gz → 0.3.2__tar.gz

{qldpc-0.3.0 → qldpc-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qLDPC
-Version: 0.3.0
+Version: 0.3.2
 Summary: Tools for constructing and analyzing quantum low density parity check (qLDPC) codes.
 Keywords: quantum computing,quantum error correction,low density parity check codes,LDPC
 Author: Michael A. Perlin
@@ -24,15 +24,18 @@ Requires-Dist: scipy>=1.14.1
 Requires-Dist: sinter>=1.16.0
 Requires-Dist: stim>=1.16.0
 Requires-Dist: sympy>=1.12
+Requires-Dist: bloqade-tsim>=0.1.4 ; extra == 'dev'
 Requires-Dist: checks-superstaq>=0.5.62 ; extra == 'dev'
 Requires-Dist: jupyter>=1.1.1 ; extra == 'dev'
 Requires-Dist: python-lsp-server[all]>=1.14.0 ; extra == 'dev'
 Requires-Dist: relay-bp[stim]==0.2.1 ; extra == 'dev'
 Requires-Dist: relay-bp[stim]==0.2.1 ; extra == 'relay-bp'
+Requires-Dist: bloqade-tsim>=0.1.4 ; extra == 'tsim'
 Requires-Python: >=3.10
 Project-URL: Repository, https://github.com/qLDPCOrg/qLDPC
 Provides-Extra: dev
 Provides-Extra: relay-bp
+Provides-Extra: tsim
 Description-Content-Type: text/markdown
 
 # qLDPC

{qldpc-0.3.0 → qldpc-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "qLDPC"
-version = "0.3.0"
+version = "0.3.2"
 description = "Tools for constructing and analyzing quantum low density parity check (qLDPC) codes."
 readme = "README.md"
 license = "Apache-2.0"
@@ -38,12 +38,14 @@ dependencies = [
 
 [project.optional-dependencies]
 dev = [
+  "bloqade-tsim>=0.1.4",
   "checks-superstaq>=0.5.62",
   "jupyter>=1.1.1",
   "python-lsp-server[all]>=1.14.0",
   "relay-bp[stim]==0.2.1",
 ]
 relay-bp = ["relay-bp[stim]==0.2.1"]
+tsim = ["bloqade-tsim>=0.1.4"]
 
 [project.urls]
 Repository = "https://github.com/qLDPCOrg/qLDPC"
@@ -56,7 +58,8 @@ build-backend = "uv_build"
 
 [tool.ruff]
 line-length = 100
-lint.extend-select = ["I"]
+lint.extend-select = ["I", "W505"]
+lint.pycodestyle.max-doc-length = 100
 
 [tool.mypy]
 pretty = true

{qldpc-0.3.0 → qldpc-0.3.2}/src/qldpc/abstract/__init__.py

@@ -1,5 +1,4 @@
 from .groups import (
-    GF2,
     PSL,
     SL,
     AbelianGroup,

{qldpc-0.3.0 → qldpc-0.3.2}/src/qldpc/abstract/groups.py

@@ -48,15 +48,13 @@ import sympy.core
 
 from qldpc import external
 
-GF2: type[galois.FieldArray] = galois.GF(2)
-
 
 def resolve_field(
     field: int | type[galois.FieldArray] | None,
 ) -> type[galois.FieldArray]:  # pragma: no cover
     """Parse a finite field argument to obtain an actual finite field."""
     if field is None:
-        return GF2
+        return galois.GF2
     if isinstance(field, int):
         return galois.GF(field)
     return field
@@ -921,7 +919,7 @@ class ProjectiveSpecialLinearGroup(Group):
         """Generating matrices of PSL, constructed out of the generating matrices of SL."""
         field = resolve_field(field)
         gen_x, gen_w = SpecialLinearGroup.get_generating_mats(dimension, field)
-        if field is GF2:
+        if field is galois.GF2:
             return gen_x, gen_w
         return (
             np.kron(np.linalg.inv(gen_x), gen_x).view(field),

{qldpc-0.3.0 → qldpc-0.3.2}/src/qldpc/abstract/groups_test.py

@@ -132,8 +132,8 @@ def assert_valid_lifts(group: abstract.Group) -> None:
     # invert elements: g -> g**(-1)
     assert all(
         np.array_equal(
-            np.where(group.inversion_matrix[:, group.index(gg)]),
-            [[group.index(~gg)]],
+            np.flatnonzero(group.inversion_matrix[:, group.index(gg)]),
+            [group.index(~gg)],
         )
         for gg in group_members
     )
@@ -156,8 +156,8 @@ def assert_valid_lifts(group: abstract.Group) -> None:
     else:
         assert all(
             np.array_equal(
-                np.where(group.adjoint_lift(aa)[:, group.index(bb)]),
-                [[group.index(aa * bb * ~aa)]],
+                np.flatnonzero(group.adjoint_lift(aa)[:, group.index(bb)]),
+                [group.index(aa * bb * ~aa)],
             )
             for aa, bb in itertools.product(group_members, repeat=2)
         )

{qldpc-0.3.0 → qldpc-0.3.2}/src/qldpc/abstract/rings.py

@@ -1082,10 +1082,9 @@ def _get_block_howell_form(matrix: galois.FieldArray, *, right: bool = False) ->
     if right and size > 1:
         matrix = matrix.transpose(0, 1, 3, 2)
 
-    # row-reduce as an expanded 2-D matrix and remove all-zero rows
+    # row-reduce as an expanded 2-D matrix, keeping a basis of the row space (no all-zero rows)
     shape = (num_block_rows * size, num_block_cols * size)
-    matrix = matrix.transpose(0, 2, 1, 3).reshape(shape).view(field).row_reduce()
-    matrix = matrix[qldpc.math.first_nonzero_cols(matrix) < matrix.shape[1]].view(field)
+    matrix = matrix.transpose(0, 2, 1, 3).reshape(shape).view(field).row_space()
 
     if size > 1:
         # insert zero rows to shift pivots down so that they always lie on the diagonal of a block

{qldpc-0.3.0 → qldpc-0.3.2}/src/qldpc/cache.py

@@ -18,7 +18,7 @@ limitations under the License.
 from __future__ import annotations
 
 import functools
-import os
+import pathlib
 import sys
 import warnings
 from collections.abc import Callable, Hashable
@@ -30,13 +30,17 @@ import platformdirs
 Params = ParamSpec("Params")
 
 
-def get_disk_cache_path(cache_name: str, *, cache_dir: str | None = None) -> str:
+def get_disk_cache_path(
+    cache_name: str, *, cache_dir: pathlib.Path | str | None = None
+) -> pathlib.Path:
     """Retrieve the path of a cache."""
-    cache_dir = cache_dir or os.path.join(platformdirs.user_cache_dir(), "qldpc")
-    return os.path.join(cache_dir, cache_name)
+    cache_dir = cache_dir or pathlib.Path(platformdirs.user_cache_dir()) / "qldpc"
+    return pathlib.Path(cache_dir) / cache_name
 
 
-def get_disk_cache(cache_name: str, *, cache_dir: str | None = None) -> diskcache.Cache:
+def get_disk_cache(
+    cache_name: str, *, cache_dir: pathlib.Path | str | None = None
+) -> diskcache.Cache:
     """Retrieve a dictionary-like cache object."""
     if running_with_pytest():
         return {}
@@ -46,7 +50,7 @@ def get_disk_cache(cache_name: str, *, cache_dir: str | None = None) -> diskcach
 def use_disk_cache(
     cache_name: str,
     *,
-    cache_dir: str | None = None,
+    cache_dir: pathlib.Path | str | None = None,
     key_func: Callable[..., Hashable] | None = None,
 ) -> Callable[[Callable[Params, Any]], Callable[Params, Any]]:
     """Decorator to cache results to disk."""
@@ -82,7 +86,9 @@ def running_with_pytest() -> bool:
     return "pytest" in sys.modules
 
 
-def clear_entry(cache_name: str, key: Hashable, *, cache_dir: str | None = None) -> None:
+def clear_entry(
+    cache_name: str, key: Hashable, *, cache_dir: pathlib.Path | str | None = None
+) -> None:
     """Clear an entry from a local cache."""
     cache = get_disk_cache(cache_name, cache_dir=cache_dir)
     if key in cache:

{qldpc-0.3.0 → qldpc-0.3.2}/src/qldpc/circuits/__init__.py

@@ -12,6 +12,7 @@ from .bookkeeping import (
 from .common import (
     get_pauli_product_measurements,
     get_unaddressed_measurements,
+    remap_qubit_target,
     restrict_to_qubits,
     with_remapped_qubits,
 )
@@ -40,6 +41,7 @@ from .noise_model import (
     DepolarizingNoiseModel,
     NoiseModel,
     NoiseRule,
+    PauliChannel,
     SI1000NoiseModel,
     as_noiseless_circuit,
 )
@@ -48,6 +50,7 @@ from .transversal import (
     get_transversal_circuit,
     get_transversal_circuits,
     get_transversal_ops,
+    get_transversal_s,
 )
 
 __all__ = [
@@ -60,6 +63,7 @@ __all__ = [
     "Record",
     "get_pauli_product_measurements",
     "get_unaddressed_measurements",
+    "remap_qubit_target",
     "restrict_to_qubits",
     "with_remapped_qubits",
     "get_encoder_and_decoder",
@@ -82,10 +86,12 @@ __all__ = [
     "DepolarizingNoiseModel",
     "NoiseModel",
     "NoiseRule",
+    "PauliChannel",
     "SI1000NoiseModel",
     "as_noiseless_circuit",
     "get_transversal_automorphism_group",
     "get_transversal_circuit",
     "get_transversal_circuits",
     "get_transversal_ops",
+    "get_transversal_s",
 ]

{qldpc-0.3.0 → qldpc-0.3.2}/src/qldpc/circuits/benchmarking.py

@@ -302,11 +302,10 @@ def get_logical_error_and_discard_rate(
         post_select_observables: The observables to post-select on.  Any time the decoder's
             prediction for these observable flips do not agree with the actual observable flips, the
             shot is discarded rather than counting as an error.
-        dem_to_decode: The detector error model to decode.  If post-selecting, this DEM should _not_
-            include any of the the detectors that are post-selected on.  If dem_to_decode is None,
-            this method builds
-                dem_arrays = decoders.DetectorErrorModelArrays(dem)
-                dem_to_decode = dem_arrays.post_selected_on(post_select).simplified().to_dem()
+        dem_to_decode: The detector error model to decode.  This DEM should include _all_ detectors,
+            including any that are post-selected on: the decoder receives every detector bit, for
+            consistency with how sinter works.  If dem_to_decode is None, this method decodes with
+            the (simplified) DEM sampled from circuit_or_dem.
 
     Returns:
         A fraction of samples in which at least one observable was decoded incorrectly.
@@ -318,12 +317,12 @@ def get_logical_error_and_discard_rate(
 
     if dem_to_decode is not None:
         same_num_observables = dem_to_decode.num_observables == dem.num_observables
-        same_num_detectors = dem_to_decode.num_detectors == dem.num_detectors - len(post_select)
+        same_num_detectors = dem_to_decode.num_detectors == dem.num_detectors
         if not same_num_observables or not same_num_detectors:
             raise ValueError(
                 f"Incompatible detector error models."
-                "\n(num_detectors, num_observables) in the DEM to sample (after post-selection):"
-                f" {(dem.num_detectors - len(post_select), dem.num_observables)}"
+                "\n(num_detectors, num_observables) in the DEM to sample:"
+                f" {(dem.num_detectors, dem.num_observables)}"
                 "\n(num_detectors, num_observables) in the DEM to decode:"
                 f" {(dem_to_decode.num_detectors, dem_to_decode.num_observables)}"
             )
@@ -341,31 +340,13 @@ def get_logical_error_and_discard_rate(
 
     # if applicable, post-select on flag detectors
     if postselection_mask is not None:
-        # remove shots in which post-selection detectors fired
         shot_mask = ~np.any(det_data & postselection_mask, axis=1)
         det_data = det_data[shot_mask]
         obs_data = obs_data[shot_mask]
-
-        # remove post-selected detectors from the detector sample data
-        detector_mask = np.ones(dem.num_detectors, dtype=bool)
-        detector_mask[list(post_select)] = False
-        det_data_unpacked = np.unpackbits(
-            det_data, count=dem.num_detectors, bitorder="little", axis=1
-        )
-        det_data = np.packbits(det_data_unpacked[:, detector_mask], bitorder="little", axis=1)
-
-        # record the fraction of shots that were discarded
         discard_rate += np.sum(~shot_mask) / num_samples
 
-        if dem_to_decode is None:
-            # remove the post-selected detectors from the DEM
-            dem_arrays = dem_arrays.post_selected_on(post_select).simplified()
-            dem = dem_arrays.to_dem()
-
-    # compile a decoder for this detector error model
-    compiled_sinter_decoder = sinter_decoder.compile_decoder_for_dem(dem_to_decode or dem)
-
     # decode and identify incorrectly predicted observable flips
+    compiled_sinter_decoder = sinter_decoder.compile_decoder_for_dem(dem_to_decode or dem)
     predicted_flips = compiled_sinter_decoder.decode_shots_bit_packed(det_data)
     incorrectly_predicted_flips = obs_data ^ predicted_flips
 

{qldpc-0.3.0 → qldpc-0.3.2}/src/qldpc/circuits/bookkeeping.py

@@ -43,11 +43,22 @@ class QubitIDs:
     checks_z: tuple[int, ...] = ()
 
     def __init__(
-        self, data: Sequence[int], check: Sequence[int] = (), ancilla: Sequence[int] = ()
+        self,
+        data: int | Sequence[int],
+        check: int | Sequence[int] = (),
+        ancilla: int | Sequence[int] = (),
     ) -> None:
-        self.data = tuple(data)
-        self.check = tuple(check)
-        self.ancilla = tuple(ancilla)
+        self.data = tuple(data if isinstance(data, Sequence) else range(data))
+        check_start = self.data[-1] + 1 if self.data else 0
+        self.check = tuple(
+            check if isinstance(check, Sequence) else range(check_start, check_start + check)
+        )
+        ancilla_start = self.check[-1] + 1 if self.check else check_start
+        self.ancilla = tuple(
+            ancilla
+            if isinstance(ancilla, Sequence)
+            else range(ancilla_start, ancilla_start + ancilla)
+        )
 
     def __iter__(self) -> Iterator[tuple[int, ...]]:
         """Iterate over the collections of qubits tracked by this QubitIDs object."""
@@ -111,8 +122,8 @@ class Record(Mapping[Hashable, list[int]]):
     """An organized record of events in a Stim circuit.
 
     A record is essentially a dictionary that maps some key (such as a qubit index) to an ordered
-    list of the events (such as measurements or detectors) associated with that key.  The events that
-    a Record keeps track of are assumed to be indexed from zero.
+    list of the events (such as measurements or detectors) associated with that key.  The events
+    that a Record keeps track of are assumed to be indexed from zero.
 
     Record is subclassed by MeasurementRecord to keep track of measurements in a circuit, and
     by DetectorRecord to keep track of the detectors in a circuit.
@@ -136,9 +147,6 @@ class Record(Mapping[Hashable, list[int]]):
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}({dict(self.key_to_events)})"
 
-    def __str__(self) -> str:
-        return repr(self)
-
     def __len__(self) -> int:
         """The number of keys associated with events in this record."""
         return len(self.key_to_events)
@@ -168,9 +176,10 @@ class Record(Mapping[Hashable, list[int]]):
     def append(self, record: Mapping[Hashable, Iterable[int] | int], repeat: int = 1) -> None:
         """Append the given record to this one.
 
-        All event numbers in the appended record are increased by the number of events in the current
-        record.  That is, if the current record holds n events numbered from 0 to n - 1, then events
-        (0, 1, ...) in the appended record are added to the current record as (n, n+1, ...).
+        All event numbers in the appended record are increased by the number of events in the
+        current record.  That is, if the current record holds n events numbered from 0 to n - 1,
+        then events (0, 1, ...) in the appended record are added to the current record as
+        (n, n+1, ...).
         """
         assert repeat >= 0
         _record = {  # convert input record into dict[Hashable, list[int]]

{qldpc-0.3.0 → qldpc-0.3.2}/src/qldpc/circuits/common.py

@@ -19,14 +19,27 @@ from __future__ import annotations
 
 import functools
 from collections.abc import Mapping, Sequence
-from typing import Callable, ParamSpec, TypeVar
+from typing import TYPE_CHECKING, Callable, ParamSpec, TypeVar
 
+import galois
 import numpy as np
 import numpy.typing as npt
 import stim
 
 from qldpc import codes, math
-from qldpc.abstract import GF2
+
+####################################################################################################
+# try to import tsim and define a circuit type that may be either of stim.Circuit or tsim.Circuit
+try:
+    import tsim
+
+    stim_or_tsim_Circuit = TypeVar("stim_or_tsim_Circuit", stim.Circuit, tsim.Circuit)
+except ImportError:  # pragma: no cover
+    if not TYPE_CHECKING:
+        tsim = None
+        stim_or_tsim_Circuit = TypeVar("stim_or_tsim_Circuit", bound=stim.Circuit)
+####################################################################################################
+
 
 CircuitOrTableau = TypeVar("CircuitOrTableau", stim.Circuit, stim.Tableau)
 Params = ParamSpec("Params")
@@ -39,7 +52,7 @@ def restrict_to_qubits(
 
     @functools.wraps(func)
     def qubit_func(*args: Params.args, **kwargs: Params.kwargs) -> stim.Circuit:
-        if any(isinstance(arg, codes.QuditCode) and arg.field is not GF2 for arg in args):
+        if any(isinstance(arg, codes.QuditCode) and arg.field is not galois.GF2 for arg in args):
             raise ValueError("Circuit methods are only supported for qubit codes")
         return func(*args, **kwargs)
 
@@ -47,8 +60,11 @@ def restrict_to_qubits(
 
 
 def with_remapped_qubits(
-    circuit: stim.Circuit, qubit_map: Mapping[int, int] | Sequence[int], *, inverse: bool = False
-) -> stim.Circuit:
+    circuit: stim_or_tsim_Circuit,
+    qubit_map: Mapping[int, int] | Sequence[int],
+    *,
+    inverse: bool = False,
+) -> stim_or_tsim_Circuit:
     """The same circuit, but with relabeled qubits.
 
     Qubits not in qubit_map get mapped to themselves.
@@ -60,8 +76,12 @@ def with_remapped_qubits(
         inverse: If True, invert the provided qubit_map.  Default: False.
 
     Returns:
-        stim.Circuit: A remapped circuit.
+        The input circuit with remapped qubits.
     """
+    if tsim is not None and isinstance(circuit, tsim.Circuit):
+        output = with_remapped_qubits(circuit.stim_circuit, qubit_map, inverse=inverse)
+        return tsim.Circuit.from_stim_program(output)
+
     qubit_map = (
         qubit_map
         if isinstance(qubit_map, Mapping)
@@ -81,7 +101,7 @@ def with_remapped_qubits(
             new_circuit.append(block)
 
         else:
-            new_targets = [_remap_target(target, qubit_map) for target in op.targets_copy()]
+            new_targets = [remap_qubit_target(target, qubit_map) for target in op.targets_copy()]
             new_op = stim.CircuitInstruction(
                 name=op.name, targets=new_targets, gate_args=op.gate_args_copy(), tag=op.tag
             )
@@ -90,6 +110,25 @@ def with_remapped_qubits(
     return new_circuit
 
 
+def remap_qubit_target(target: stim.GateTarget, qubit_map: Mapping[int, int]) -> stim.GateTarget:
+    """Remap the qubit addressed by a stim.GateTarget, if any."""
+    if target.qubit_value is None:
+        return target
+
+    new_qubit_value = qubit_map.get(target.qubit_value, target.qubit_value)
+    if target.is_x_target or target.is_z_target or target.is_y_target:
+        return stim.target_pauli(
+            new_qubit_value,
+            target.pauli_type,
+            invert=target.is_inverted_result_target,
+        )
+
+    if target.is_inverted_result_target:
+        return stim.target_inv(new_qubit_value)
+
+    return stim.GateTarget(new_qubit_value)
+
+
 def get_pauli_product_measurements(
     pauli_strings: Sequence[stim.PauliString] | npt.NDArray[np.int_],
     qubits: Sequence[int] | None = None,
@@ -123,22 +162,3 @@ def get_unaddressed_measurements(circuit: stim.Circuit) -> list[int]:
                 measurements[target.value] for target in instruction.targets_copy()
             }
     return sorted(set(measurements) - addressed_measurements)
-
-
-def _remap_target(target: stim.GateTarget, qubit_map: Mapping[int, int]) -> stim.GateTarget:
-    """Remap the qubit addressed by a stim.GateTarget, if any."""
-    if target.qubit_value is None:
-        return target
-
-    new_qubit_value = qubit_map.get(target.qubit_value, target.qubit_value)
-    if target.is_x_target or target.is_z_target or target.is_y_target:
-        return stim.target_pauli(
-            new_qubit_value,
-            target.pauli_type,
-            invert=target.is_inverted_result_target,
-        )
-
-    if target.is_inverted_result_target:
-        return stim.target_inv(new_qubit_value)
-
-    return stim.GateTarget(new_qubit_value)

{qldpc-0.3.0 → qldpc-0.3.2}/src/qldpc/circuits/common_test.py

@@ -23,6 +23,7 @@ import numpy as np
 import pytest
 import stim
 import sympy.combinatorics as comb
+import tsim
 
 from qldpc import circuits, codes
 from qldpc.math import symplectic_conjugate
@@ -95,6 +96,13 @@ def test_qubit_remap(pytestconfig: pytest.Config, num_qubits: int = 8) -> None:
     circuit_b = stim.Circuit("MPP X1*!Y3 \n M !4")
     assert circuit_a == circuit_b
 
+    # a tsim.Circuit input is remapped and returned as a tsim.Circuit
+    tsim_remapped = circuits.with_remapped_qubits(
+        tsim.Circuit.from_stim_program(circuit), qubit_map
+    )
+    assert isinstance(tsim_remapped, tsim.Circuit)
+    assert tsim_remapped.stim_circuit == circuits.with_remapped_qubits(circuit, qubit_map)
+
 
 def test_finding_unaddressed_measurements() -> None:
     """Identify measurements in a circuit that are not addressed by any detectors."""

qldpc-0.3.2/src/qldpc/circuits/conftest_probe.py

@@ -0,0 +1,13 @@
+import pytest
+
+import qldpc.circuits.common as c
+c._TSIM_BRANCH_HITS = 0
+_orig = c.with_remapped_qubits
+import functools
+def wrapped(circuit, *a, **k):
+    if c.tsim is not None and isinstance(circuit, c.tsim.Circuit):
+        c._TSIM_BRANCH_HITS += 1
+    return _orig(circuit, *a, **k)
+c.with_remapped_qubits = wrapped
+def pytest_sessionfinish(session, exitstatus):
+    print("\nTSIM_BRANCH_HITS_ON_WITH_REMAPPED:", c._TSIM_BRANCH_HITS)

{qldpc-0.3.0 → qldpc-0.3.2}/src/qldpc/circuits/encoding.py

@@ -20,11 +20,11 @@ from __future__ import annotations
 from collections.abc import Sequence
 from typing import ParamSpec, TypeVar
 
+import galois
 import numpy as np
 import stim
 
 from qldpc import codes, math
-from qldpc.abstract import GF2
 from qldpc.objects import Pauli
 
 from .bookkeeping import QubitIDs
@@ -198,7 +198,7 @@ def get_state_stabilizers(
     cols_other_z = other_qubits + num_qubits
 
     # build a matrix of stabilizers for the entire circuit output, determined by the flows
-    matrix = GF2.Zeros((num_rows, num_columns))
+    matrix = galois.GF2.Zeros((num_rows, num_columns))
     for gg, flow in enumerate(flow_generators):
         pauli_string = flow.output_copy()
         if pauli_string:
@@ -226,7 +226,7 @@ def get_state_stabilizers(
 
     # identify stabilizers that are supported entirely on the data qubits of the code
     stabilizers = []
-    for row in matrix.row_reduce():
+    for row in matrix.row_space():
         state_xs = row[cols_state_x]
         state_zs = row[cols_state_z]
         other_xs = row[cols_other_x]
@@ -294,17 +294,27 @@ def _get_logical_tableau_from_code_data(
         sector_l = slice(dimension)
         sector_g = slice(dimension, dimension + gauge_dimension)
         sector_s = slice(dimension + gauge_dimension, len(encoder))
-        x2x, x2z, z2x, z2z, *_ = decoded_tableau.to_numpy()
+        x2x, x2z, z2x, z2z, _, z_signs = decoded_tableau.to_numpy()
 
         # sanity check: stabilizers, logicals, and gauge operators should not pick up destabilizers
-        assert not np.any(z2x[:, sector_s])
-        assert not np.any(x2x[sector_l, sector_s])
-        assert not np.any(x2x[sector_g, sector_s])
+        ops_acquired_destabilizers = (
+            np.any(z2x[:, sector_s])
+            or np.any(x2x[sector_l, sector_s])
+            or np.any(x2x[sector_g, sector_s])
+        )
 
         # sanity check: gauge operators should not pick up logical factors
-        assert not np.any(x2x[sector_g, sector_l])
-        assert not np.any(x2z[sector_g, sector_l])
-        assert not np.any(z2x[sector_g, sector_l])
-        assert not np.any(z2z[sector_g, sector_l])
+        gauges_acquired_logicals = (
+            np.any(x2x[sector_g, sector_l])
+            or np.any(x2z[sector_g, sector_l])
+            or np.any(z2x[sector_g, sector_l])
+            or np.any(z2z[sector_g, sector_l])
+        )
+
+        # sanity check: no stabilizers get flipped
+        stabilizers_flipped = np.any(z_signs[sector_s])
+
+        if ops_acquired_destabilizers or gauges_acquired_logicals or stabilizers_flipped:
+            raise ValueError("The provided physical circuit does not implement a logical operation")
 
     return logical_tableau

{qldpc-0.3.0 → qldpc-0.3.2}/src/qldpc/circuits/encoding_test.py

@@ -42,8 +42,8 @@ def test_encoding_circuit(pytestconfig: pytest.Config) -> None:
                 size=code.dimension + code.gauge_dimension,
             )
             basis_prep = stim.Circuit()
-            basis_prep.append("H", np.where(bases != Pauli.Z)[0])
-            basis_prep.append("S", np.where(bases == Pauli.Y)[0])
+            basis_prep.append("H", np.flatnonzero(bases != Pauli.Z))
+            basis_prep.append("S", np.flatnonzero(bases == Pauli.Y))
             simulator.do(basis_prep)
 
         encoder = circuits.get_encoding_circuit(code, only_zero=only_zero)
@@ -104,6 +104,15 @@ def test_logical_tableau() -> None:
     reconstructed_logical_tableau = circuits.get_logical_tableau(code, physical_circuit)
     assert logical_circuit.to_tableau() == reconstructed_logical_tableau
 
+    # logical Pauli operations (which flip logical operator signs) are valid logical operations
+    logical_x = math.op_to_string(code.get_logical_ops(Pauli.X, symplectic=True)[0])
+    reconstructed_logical_tableau = circuits.get_logical_tableau(code, logical_x.to_tableau())
+    assert stim.Circuit("X 0").to_tableau() == reconstructed_logical_tableau
+
+    # a physical circuit that does not preserve the code space is not a logical operation
+    with pytest.raises(ValueError, match="does not implement a logical operation"):
+        circuits.get_logical_tableau(code, stim.Circuit("X 0"))
+
 
 def test_state_stabilizers(pytestconfig: pytest.Config) -> None:
     """Identify the stabilizers of state prepared by a circuit."""

{qldpc-0.3.0 → qldpc-0.3.2}/src/qldpc/circuits/memory/alpha_syndrome.py

@@ -67,9 +67,9 @@ class AlphaSyndrome(SyndromeMeasurementStrategy):
         This strategy uses a Monte Carlo tree serch (MCTS) to construct a syndrome measurement
         circuit that minimizes logical error rates.
 
-        The MCTS requires building and simulating noisy evaluation circuits, which naturally requires
-        defining a noise model.  Computing a logical error rate, in turn, requires specifying a
-        decoder.  The "decoder' and "custom_decoders" arguments to AlphaSyndrome are
+        The MCTS requires building and simulating noisy evaluation circuits, which naturally
+        requires defining a noise model.  Computing a logical error rate, in turn, requires
+        specifying a decoder.  The "decoder' and "custom_decoders" arguments to AlphaSyndrome are
 
         Args:
             noise_model: The noise model append to the syndrome measurement circuit.

{qldpc-0.3.0 → qldpc-0.3.2}/src/qldpc/circuits/memory/memory.py

@@ -196,7 +196,8 @@ def get_memory_experiment_parts(
     See help(qldpc.circuits.get_memory_experiment) for additional information.
 
     Returns:
-        initialization: A circuit that sets the coordinates and initializes the state of data qubits.
+        initialization: A circuit that sets the coordinates and initializes the state of data
+            qubits.
         qec_cycle: A circuit for one logical QEC cycle, with num_rounds syndrome measurements.
         readout: A circuit that reads out final stabilizers.
         measurement_record: A record of all measurements in the above circuits.
@@ -275,7 +276,7 @@ def _get_basis_memory_experiment_parts(
     readout.append("SHIFT_COORDS", [], (1, 0, 0))
     check_support = code.get_matrix(basis)
     for kk, check_id in enumerate(basis_check_ids):
-        data_support = np.where(check_support[kk])[0]
+        data_support = np.flatnonzero(check_support[kk])
         readout.append(
             "DETECTOR",
             [measurement_record.get_target_rec(data_ids[qq]) for qq in data_support]

{qldpc-0.3.0 → qldpc-0.3.2}/src/qldpc/circuits/memory/syndrome_measurement.py

@@ -70,8 +70,8 @@ class EdgeColoring(SyndromeMeasurementStrategy):
         Args:
             strategy: The graph coloration strategy passed to nx.greedy_color when coloring edges.
                 Defaults to "smallest_last".
-            subgraph_kwargs: Keyword arguments to pass to code.get_syndrome_subgraphs when retrieving
-                the Tanner subgraphs of a code.
+            subgraph_kwargs: Keyword arguments to pass to code.get_syndrome_subgraphs when
+                retrieving the Tanner subgraphs of a code.
         """
         self.strategy = strategy
         self.subgraph_kwargs = subgraph_kwargs