qLDPC

This library contains tools for constructing and analyzing quantum low density parity check (qLDPC) codes. At least, that was the original motivation for this library. In practice, the tools here work just as well for error-correcting stabilizer and subsystem codes more broadly.

In a nutshell, qLDPC provides supports a variety of built-in codes and custom codes constructed from parity check matrices that represent stabilizer or gauge group generators. Once a code is constructed, qLDPC automates various tasks of common interest, and integrates with external tools for analyzing error-correcting codes (including QDistRnd, ldpc, stim, and sinter, among others). Automated tasks include:

• constructing a canonical basis logical Pauli operators,
• computing (or upper-bounding) code distance,
• computing logical error rates in a code-capacity model,
• constructing various circuits of interest, such as a quantum memory experiment for obtaining circuit-level logical error rates,
• defining custom Pauli noise models,
• plugging a decoder of choice into your workflow.

See the examples directory for some demonstrations and use-cases.

Where possible, this library strives to support codes over arbitrary finite (Galois) fields -- that is, for qudits of any prime power dimension. Circuit-related utilities are, however, limited to qubit codes.

📦 Installation

This library requires Python>=3.10, and can be installed from the Python Package Index (PyPI) with

pip install qldpc

To install a local version of qLDPC from source:

git clone https://github.com/qLDPCOrg/qLDPC.git
pip install -e qLDPC

You can also pip install -e 'qLDPC[dev]' to additionally install some development tools.

GAP

Some features in qLDPC require an installation of the GAP computer algebra system. If you (a) use linux or macOS, and (b) use a conda to manage your python environment, then you can obtain GAP by running conda install -c conda-forge gap (or gap-core). Installations without conda should also work, as long as gap is a recognized command in the command line. Unfortunately, I have not figured out how to install GAP in a qLDPC-compatible way on Windows. If you figure this out, please let me know!

macOS

If you use macOS you may need to install cvxpy manually by following the instructions here before installing qLDPC. If you use conda to manage your python environment, you can obtain cvxpy by running conda install -c conda-forge cvxpy.

🚀 Features

Notable features include:

• ClassicalCode: class for representing classical linear error-correcting codes over finite fields.
  • Various pre-defined classical code families.
  • Communication with the GAP/GUAVA package for even more codes.
• QuditCode: class for constructing Galois-qudit codes, including both stabilizer and subsystem codes.
  • QuditCode.get_logical_ops: method to construct a complete basis of nontrivial logical Pauli operators for a QuditCode.
  • QuditCode.get_distance: method to compute the exact code distance of a QuditCode (i.e., the minimum weight of a nontrivial logical operator). Includes options to compute an upper bound on code distance using QDistRnd or (for CSS codes) a decoder-based method introduced in arXiv:2308.07915.
  • QuditCode.concatenate: method to concatenate QuditCodes in various ways.
• CSSCode: subclass of QuditCode for the special case of constructing a quantum CSS code out of two mutually compatible ClassicalCodes. Special cases (subclasses) with specialized constructors and helper methods include:
  • TBCode: two-block quantum codes.
  • BBCode: bivariate bicycle codes, as in arXiv:2308.07915 and arXiv:2311.16980. See examples/bivariate_bicycle_codes.ipynb for methods to identify...
    • toric layouts of a BBCode, in which the code looks like a toric code augmented by some long-distance checks, as in discussed in arXiv:2308.07915, and
    • qubit layouts that minimize the communication distance for neutral atoms, as discussed in arXiv:2404.18809.
  • HGPCode: hypergraph product codes, first introduced in arXiv:0903.0566.
  • SHPCode: subsystem hypergraph product codes, as in arXiv:2002.06257.
  • SHYPSCode: subsystem hypergraph product simplex codes, as in arXiv:2502.07150.
  • LPCode: lifted product codes, as in arXiv:2012.04068 and arXiv:2202.01702.
  • SLPCode: subsystem lifted product codes, as in arXiv:2404.18302.
  • QTCode: quantum Tanner codes, as in arXiv:2202.13641 and arXiv:2206.07571.
• decoders.py: module for decoding errors with various methods, including BP-OSD, BP-LSD, and belief-find (via ldpc), Relay-BP (via relay-bp), minimum-weight perfect matching (via pymatching), and others. Includes an interface for using custom decoders.
• qldpc.circuits: module for stim circuits and circuit utilities, including:
  • get_memory_experiment: circuit for testing the performance of a code as a quantum memory. Accepts both predefined and custom-built SyndromeMeasurementStrategys.
  • NoiseModel: class for constructing expressive Pauli noise models, which map noiseless circuits to noisy circuits. Built-in subclasses include a single-parameter DepolarizingNoiseModel and a superconducting-inspired SI1000NoiseModel.
  • SinterDecoder: class to construct circuit-level decoders that are usable by sinter.
  • get_encoding_circuit: circuit to prepare the all-|0> logical state of a code. (Warning: generally not fault-tolerant. Fault-tolerant encoding circuits pending.)
  • get_transversal_ops: logical tableaus and physical circuits for the SWAP-transversal logical Clifford gates of a code, constructed via the code automorphism method of arXiv:2409.18175. (Warning: exponential complexity.)
  • get_transversal_circuits: find a SWAP-transversal physical circuit (if any) that implements a given logical Clifford operation in a code. (Warning: exponential complexity.)
• abstract.py: module for abstract algebra (groups, algebras, modules, and representations thereof).
  • Various pre-defined groups (mostly borrowed from SymPy).
  • Communication with the GAP computer algebra system and GroupNames.org for constructing even more groups.
• objects.py: module for constructing helper objects such as Cayley complexes and chain complexes, which are instrumental for the construction of various quantum codes.

🤔 Questions and issues

This project aspires to have a documentation page, but at the moment the documentation is out of date and auto-generated from source code that was written to be human-readable in a plain text editor. For now, I recommend looking at the source code (and comments therein) directly, as well as the examples directory. Test files (such as qldpc/codes/quantum_test.py) also contain some examples of using the classes and methods in this library.

If you have any questions, feedback, or requests, please open an issue on GitHub or email me at mika.perlin@gmail.com!

⚓ Attribution

If you use this software in your work, please cite with:

@misc{perlin2023qldpc,
  author = {Perlin, Michael A.},
  title = {{qLDPC}},
  year = {2023},
  publisher = {GitHub},
  journal = {GitHub repository},
  howpublished = {\url{https://github.com/qLDPCOrg/qLDPC}},
}

This may require adding \usepackage{url} to your LaTeX file header. Alternatively, you can cite

Michael A. Perlin. qLDPC. https://github.com/qLDPCOrg/qLDPC, 2023.