qLDPC 0.3.1__tar.gz → 0.3.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qLDPC
-Version: 0.3.1
+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

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

@@ -1,6 +1,6 @@
 [project]
 name = "qLDPC"
-version = "0.3.1"
+version = "0.3.2"
 description = "Tools for constructing and analyzing quantum low density parity check (qLDPC) codes."
 readme = "README.md"
 license = "Apache-2.0"

{qldpc-0.3.1 → 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.1 → 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.1 → qldpc-0.3.2}/src/qldpc/circuits/__init__.py

@@ -50,6 +50,7 @@ from .transversal import (
     get_transversal_circuit,
     get_transversal_circuits,
     get_transversal_ops,
+    get_transversal_s,
 )
 
 __all__ = [
@@ -92,4 +93,5 @@ __all__ = [
     "get_transversal_circuit",
     "get_transversal_circuits",
     "get_transversal_ops",
+    "get_transversal_s",
 ]

{qldpc-0.3.1 → 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.1 → 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."""

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

@@ -19,7 +19,7 @@ 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
@@ -28,6 +28,19 @@ import stim
 
 from qldpc import codes, math
 
+####################################################################################################
+# 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")
 
@@ -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)

{qldpc-0.3.1 → 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.1 → qldpc-0.3.2}/src/qldpc/circuits/encoding.py

@@ -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.1 → 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.1 → qldpc-0.3.2}/src/qldpc/circuits/memory/memory.py

@@ -276,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.1 → qldpc-0.3.2}/src/qldpc/circuits/noise_model.py

@@ -110,20 +110,10 @@ import itertools
 import math
 import re
 from collections.abc import Callable, Collection, Iterable, Iterator, Mapping
-from typing import TYPE_CHECKING, TypeVar
 
 import stim
 
-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)
-
-from .common import with_remapped_qubits
+from .common import stim_or_tsim_Circuit, tsim, with_remapped_qubits
 
 ####################################################################################################
 # global constants
@@ -238,7 +228,8 @@ CORRELATED_ERROR_NAMES = frozenset({"CORRELATED_ERROR", "E", "ELSE_CORRELATED_ER
 def as_noiseless_circuit(circuit: stim_or_tsim_Circuit) -> stim_or_tsim_Circuit:
     """Wrap a circuit in a noiseless, one-repitition stim.CircuitRepeatBlock."""
     if tsim is not None and isinstance(circuit, tsim.Circuit):
-        return tsim.Circuit.from_stim_program(as_noiseless_circuit(circuit.stim_circuit))
+        output = as_noiseless_circuit(circuit.stim_circuit)
+        return tsim.Circuit.from_stim_program(output)
     block = stim.CircuitRepeatBlock(repeat_count=1, body=circuit.copy(), tag=DEFAULT_IMMUNE_OP_TAG)
     noiseless_circuit = stim.Circuit()
     noiseless_circuit.append(block)
@@ -930,16 +921,15 @@ class NoiseModel:
             The input circuit with added noise.
         """
         if tsim is not None and isinstance(circuit, tsim.Circuit):
-            return tsim.Circuit.from_stim_program(
-                self.noisy_circuit(
-                    circuit.stim_circuit,
-                    system_qubits=system_qubits,
-                    immune_qubits=immune_qubits,
-                    immune_op_tag=immune_op_tag,
-                    immunize_gates=immunize_gates,
-                    insert_ticks=insert_ticks,
-                )
+            output = self.noisy_circuit(
+                circuit.stim_circuit,
+                system_qubits=system_qubits,
+                immune_qubits=immune_qubits,
+                immune_op_tag=immune_op_tag,
+                immunize_gates=immunize_gates,
+                insert_ticks=insert_ticks,
             )
+            return tsim.Circuit.from_stim_program(output)
 
         system_qubits = frozenset(
             range(circuit.num_qubits) if system_qubits is None else system_qubits

{qldpc-0.3.1 → qldpc-0.3.2}/src/qldpc/circuits/transversal.py

@@ -32,6 +32,51 @@ from .common import restrict_to_qubits
 from .encoding import _get_logical_tableau_from_code_data, get_encoder_and_decoder
 
 
+@restrict_to_qubits
+def get_transversal_s(code: codes.CSSCode, *, validate: bool = True) -> stim.Circuit:
+    """Get a physical circuit for a transversal logical S = diag(1, i) gate of the code.
+
+    The returned circuit applies one physical S or S_DAG gate to each qubit, and thereby enacts
+    a logical S gate on every logical qubit of the code.
+
+    This construction only supports self-dual codes with equivalent logicals (SWEL):
+    1. Self dual = CSS code with identical X and Z stabilizers.
+    2. Equivalent logicals = applying a Hadamard to every physical qubit enacts a logical Hadamard
+        on every logical qubit.  This property depends on the choice of logical operator basis.
+    """
+    if validate:
+        logs_z = code.get_logical_ops(Pauli.Z)
+        if not np.array_equal(
+            code.canonicalized.matrix_x, code.canonicalized.matrix_z
+        ) or not np.array_equal(logs_z @ logs_z.T, np.eye(code.dimension, dtype=int)):
+            raise ValueError(
+                "Transversal S gate construction currently only supports SWEL stabilizer codes"
+            )
+
+    # Build a test circuit: physical S on all qubits
+    test_circuit = stim.Circuit()
+    test_circuit.append("S", range(len(code)))
+    test_tableau = test_circuit.to_tableau()
+
+    # Identify Pauli corrections in the "decoded" frame of logicals/stabilizers/destabilizers.
+    encoder, decoder = get_encoder_and_decoder(code)
+    decoded_tableau = encoder.then(test_tableau).then(decoder)
+    *_, x_signs, z_signs = decoded_tableau.to_numpy()
+    # A flip of an X-type operator is corrected by its Z-type dual, and vice versa.
+    decoded_frame_correction = stim.PauliString.from_numpy(xs=z_signs, zs=x_signs)
+
+    # Map the decoded-frame Pauli correction back to a physical Pauli.  For SWEL codes this
+    # correction is purely Z-type (mod stabilizers), and appending a Z after an S makes it S_DAG,
+    # so we can realize the correction by emitting S_DAG (rather than S) on the corrected qubits.
+    physical_correction = decoded_frame_correction.after(encoder, targets=range(len(code)))
+    _, physical_zs = physical_correction.to_numpy()
+
+    circuit = stim.Circuit()
+    circuit.append("S", np.flatnonzero(~physical_zs))
+    circuit.append("S_DAG", np.flatnonzero(physical_zs))
+    return circuit
+
+
 @restrict_to_qubits
 def get_transversal_ops(
     code: codes.QuditCode,

{qldpc-0.3.1 → qldpc-0.3.2}/src/qldpc/circuits/transversal_test.py

@@ -26,6 +26,24 @@ import stim
 from qldpc import circuits, codes, external
 
 
+def test_transversal_s() -> None:
+    """Build a physical circuit for the transversal logical S gate of a SWEL code."""
+    # the Steane code is SWEL, so its logical S gate is transversal
+    code = codes.SteaneCode()
+    circuit = circuits.get_transversal_s(code)
+
+    # the circuit is built entirely from single-qubit S and S_DAG gates (no Pauli corrections)
+    assert {instruction.name for instruction in circuit} <= {"S", "S_DAG"}
+
+    # the circuit implements a logical S gate
+    logical_tableau = circuits.get_logical_tableau(code, circuit)
+    assert logical_tableau == stim.Circuit("S 0").to_tableau()
+
+    # non-SWEL codes are rejected
+    with pytest.raises(ValueError, match="SWEL"):
+        circuits.get_transversal_s(codes.ToricCode(2))
+
+
 def test_transversal_ops() -> None:
     """Construct SWAP-transversal logical Cliffords of a code."""
     code: codes.CSSCode