⚛️ quantum physics

MoMPy: automated construction of moment matrices for semidefinite programming relaxations

This paper introduces MoMPy, an open-source Python package that automates the construction of moment matrices for semidefinite programming hierarchies by efficiently resolving structural identifications through a word-rewriting algorithm, thereby providing a unified, scenario-independent framework for diverse quantum certification tasks.

Original authors: Carles Roch i Carceller

Published 2026-08-18

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Carles Roch i Carceller

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

In the quantum world, the rules of reality are written in a language of probabilities and hidden connections. Scientists often ask questions that sound simple but are incredibly difficult to answer: How much randomness can a machine truly generate? How well can we tell two quantum states apart if we only know a little about how they were made? Or, how large a violation of a classical rule can a quantum system produce? To find the answers, researchers must explore a vast, unbounded space of possible physical setups. They need to check every conceivable combination of states and measurements to find the absolute limits of what is possible. Because this space is infinite and the math is not straightforward, finding these limits directly is usually impossible. Instead, scientists use a clever trick called a "relaxation." They trade the impossible task of searching through infinite possibilities for a more manageable problem: searching through a giant grid of numbers that represents all the possible outcomes. If this grid of numbers follows a specific mathematical shape, it guarantees that the answer found is a valid limit for the real world.

The challenge, however, is building that grid. The grid is made of "moments," which are essentially the average values of products of quantum operators. In a real physical system, many of these moments are not independent; they are linked by strict rules. For example, if a measurement has two outcomes that cannot happen at the same time, the math says their product must be zero. If two different parts of a system do not interfere with each other, their order in a calculation does not matter. In small problems, a human can figure out these links by hand. But as the problems get bigger and more realistic, the number of these links explodes into the tens of thousands. Getting them wrong makes the answer useless: miss a link, and the limit is too loose; add a fake link, and the answer is wrong. This bookkeeping task has become a major bottleneck, slowing down research and making it hard to trust the results.

Carles Roch i Carceller has addressed this bottleneck with a new software tool called MoMPy. The core achievement of this work is not just that the software builds these grids automatically, but that it does so using a single, unified method that works for almost every type of quantum question. Before this, researchers often had to write different code for different scenarios, such as testing for "non-locality" in separated systems versus testing for "steering" where one side is trusted and the other is not. MoMPy treats all of these as variations of the same underlying structure. The user simply declares the labels of the quantum operators involved and states the basic rules they obey—such as whether they are projectors, whether they cancel each other out, or whether they commute. The software then takes this list and automatically figures out every single hidden connection between the moments, collapsing thousands of potential entries down to the correct, independent variables.

The software works by treating the quantum operators as words in a language. It applies a set of rewriting rules to these words, much like a grammar checker simplifies a sentence. If the rules say that two words are the same, the software merges them. If a rule says a combination is impossible, it marks it as zero. The program is designed to be incredibly efficient, ensuring that it never does the same calculation twice, even for the most complex setups. It has been tested against a slow, brute-force method to prove that it gets the right answer every time. The results show that it can build these massive grids in seconds, even for scenarios that would take much longer with older methods.

What makes this tool particularly powerful is its flexibility. It can handle three different types of quantum problems with the same code. It can work with standard "state" moments, which are used to test the limits of quantum mechanics in Bell experiments. It can handle "tracial" moments, which are better suited for scenarios where the state is part of the measurement process itself. Most impressively, it can also build "block-valued" matrices, where the entries of the grid are not just single numbers but small matrices themselves. This allows it to tackle a recently discovered class of problems that were previously very difficult to model. The author demonstrates that by simply changing a few settings in the software, the same list of operators can be used to solve problems ranging from certifying randomness in a device to determining the minimum dimension of a quantum system needed to produce a specific pattern of results.

The paper validates this approach by applying it to eight distinct physical scenarios, including famous tests like the CHSH inequality and the Mermin inequality, as well as more complex setups involving multiple parties and networks. In every case, the software successfully reproduced known theoretical limits, such as the maximum quantum violation of a Bell inequality, and solved new problems that required no custom code. The tool is written in Python, a common language for scientists, and relies on only one external library, making it easy to install and use. It does not try to solve the entire physics problem for the user; instead, it acts as a highly reliable engine that prepares the mathematical structure, leaving the final optimization to standard solvers.

This work represents a shift in how quantum limits are explored. By automating the tedious and error-prone task of identifying relationships between moments, MoMPy allows researchers to focus on the physics rather than the algebra. It proves that the complex bookkeeping required for these advanced calculations can be abstracted into a simple, declarative process. The software is open-source and available for anyone to use, ensuring that the community can verify the results and build upon them. By making these powerful relaxation techniques accessible and reliable, the tool opens the door to exploring more complex quantum scenarios and certifying the security and randomness of future quantum technologies with greater confidence.

Technical Summary of "MoMPy: automated construction of moment matrices for semidefinite programming relaxations"

Problem Statement
Semidefinite programming (SDP) hierarchies, such as the Navascués–Pironio–Acín (NPA) hierarchy, are the standard tool for bounding quantum correlations and certifying quantum properties. These methods rely on constructing "moment matrices," where entries are expectation values of products of operators. A critical bottleneck in this process is the "bookkeeping" required to identify which matrix entries correspond to the same SDP variable. Physical constraints—such as projector idempotency ( $P^2=P$ ), orthogonality of measurement outcomes ( $P_i P_j = 0$ ), and commutation between distinct parties—imply that many distinct operator words (monomials) evaluate to the same moment.

Manually deriving these identifications is error-prone and infeasible for large hierarchies involving tens of thousands of entries. Incorrect identifications either weaken the bound (by missing constraints) or invalidate it entirely (by imposing non-physical constraints). Existing software tools often address specific scenarios (e.g., Bell nonlocality vs. prepare-and-measure) using distinct code paths or specialized algebraic structures, making it difficult to unify different types of relaxations (tracial, state-based, or block-valued) within a single framework.

Methodology
The paper presents MoMPy, an open-source Python package that automates the construction of moment matrices through a unified, declarative approach. The core methodology involves:

Declarative Abstraction: The user defines a set of operator labels and a small set of structural relations (idempotency, orthogonality, commutation, and reality/reversal). The package does not infer these relations; they are explicitly declared.
Word-Rewriting Algorithm: The identification problem is recast as a word-rewriting problem on tuples of integers. MoMPy employs a memoised breadth-first search coupled with a disjoint-set forest (union-find) data structure.
- This algorithm computes the equivalence classes of words under the declared relations.
- It ensures that each distinct monomial is processed exactly once per build, regardless of how many matrix entries it labels.
- A "sticky zero class" handles words that are forced to vanish (e.g., due to orthogonality), propagating zeros backward through the equivalence classes.
Unified Moment Map ( $\Theta$ ): The construction is independent of the physical scenario's specific moment map. It supports three primary modes via flags on a single MomentProblem object:
- State moments (NPA): $\Theta(X) = \langle \psi | X | \psi \rangle$ (non-cyclic).
- Tracial moments: $\Theta(X) = \text{Tr}(X)$ (cyclic).
- Block-valued moments: $\Theta(X) = X$ (operator-valued entries, $d \times d$ blocks).
Integration: The output is a matrix of SDP variable indices and a lookup table. This is designed to be fed directly into modeling layers like CVXPY, leaving the objective function and solver selection to the user.

Key Contributions
The paper makes three primary contributions:

A General Abstraction: It isolates the common step across NPA, tracial, and block-valued hierarchies: quotienting a matrix of formal words by the equivalence generated by operator relations. This abstraction is defined by four word-level relations and optional cyclicity/block-size flags, removing the need for scenario-specific notions like "parties" or "settings" in the core construction.
An Efficient Algorithm: The implementation solves the identification problem with a cost governed by the number of distinct reachable words rather than the number of matrix entries. It is validated against an independent brute-force implementation and numerical realizability checks.
Demonstration of Generality: The author demonstrates that a single MomentProblem class, combined with different declared relations and flags, can reproduce constructions typically treated as distinct. This includes:
- Bell-type bounds (NPA).
- Tripartite Mermin inequalities.
- Steering and measurement compatibility (using block matrices with partial traces).
- Prepare-and-measure dimension witnesses and state discrimination (using tracial moments).
- Device-independent randomness certification.
- Certification of deterministic correlations using operator-valued moments (block matrices).

Results and Validation

Correctness: The package was validated against a brute-force reference implementation across 720 randomized scenarios, with exact agreement on matrix partitions. It also reproduces known closed-form optima (e.g., Tsirelson's bound $2\sqrt{2}$ for CHSH, local bound 2, and algebraic maximum 4 for Mermin).
Performance: Benchmarks across eight structurally distinct scenarios (ranging from bipartite Bell tests to network configurations) show that build times scale with the number of distinct words rather than matrix size. For example, a $3165 \times 3165$ matrix with 27,000 variables was built in ~98 seconds, exploring over 11 million distinct words.
Block-Valued Consistency: A key result is the successful construction of a block-moment matrix (where entries are $d \times d$ operators) using the exact same monomial list and algebra as a scalar relaxation, differing only in the dim and cyclicity flags. This validates the claim that the underlying abstraction is robust across different moment map choices.

Significance and Claims
The author explicitly states that MoMPy is not designed for raw throughput; compiled, specialized tools (like Moment) may build standard hierarchies faster. Instead, the significance of MoMPy lies in generality of expression and audibility.

Unified Interface: It is the first tool where tracial, state, and block-valued moments are choices of the same underlying object sharing a single declared algebra and monomial list.
Transparency: Because the rewriting core is pure Python and documented argument-by-argument, users can audit the identifications their relaxation depends on, rather than trusting a "black box." This is crucial because incorrect identifications (e.g., imposing cyclicity where it does not hold) silently degrade bounds.
Interactivity: The tool is designed for the regime of working practice where models are iteratively designed and rebuilt (matrices of a few hundred to a few thousand rows), allowing researchers to test different structural assumptions without rewriting code.

The paper concludes that the "bookkeeping" of moment matrices is a shared, not scenario-specific, problem, and that a single declarative construction can cover a wide range of quantum information tasks previously requiring bespoke implementations.

Technical Summary of "MoMPy: automated construction of moment matrices for semidefinite programming relaxations"

More like this