⚛️ quantum physics

Qurrium: A Python package for randomized measurement-based estimation of quantum state properties

This paper introduces Qurrium, an open-source Python package built on Qiskit that implements randomized measurement protocols, specifically the classical shadow protocol, to estimate quantum state properties like purity and entropy through both end-to-end simulation workflows and standalone analysis of pre-collected hardware data.

Original authors: Huai-Chun Chang, Teik-Hui Lee, Arthur Strauss, Yu-Cheng Lin, Hsiu-Chuan Hsu

Published 2026-09-17

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Huai-Chun Chang, Teik-Hui Lee, Arthur Strauss, Yu-Cheng Lin, Hsiu-Chuan Hsu

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 world of quantum computing, the most valuable thing a machine can produce is a specific arrangement of its internal components, known as a quantum state. These states are the raw material for solving complex problems, from simulating new materials to cracking codes. However, these states are incredibly fragile and difficult to describe. Unlike a classical computer bit, which is simply a zero or a one, a quantum state exists in a vast, multidimensional space where it can be a mix of many possibilities at once. To understand what a quantum computer is actually doing, scientists must measure it. But the act of measuring a quantum system is tricky; it forces the system to collapse into a single, definite outcome, destroying the delicate information that existed before. If a scientist wants to know the full nature of the state, they cannot simply look at it once. They must repeat the process many times, but doing so in a way that reveals the whole picture without needing to reconstruct the entire state from scratch is a monumental challenge. This is where the need for efficient, reliable methods to peek inside the quantum machine becomes critical.

A team of researchers has developed a new software tool called Qurrium to solve this problem. The tool is designed to help scientists estimate the properties of these elusive states using a method called randomized measurements. Instead of trying to measure every single detail of a quantum state, which would take an impossible amount of time, this approach involves taking many random snapshots. Imagine trying to understand the shape of a complex object in a dark room by shining a flashlight on it from many different, random angles. You don't see the whole object at once, but by collecting enough of these random glimpses, you can build a reliable picture of its overall form. In the quantum world, this means applying random rotations to the qubits before measuring them, then using a computer to piece together the results to estimate things like how pure the state is, how much information it holds, or how similar it is to another state.

The researchers built Qurrium as a package for Python, the most popular programming language in the scientific community, specifically designed to work with Qiskit, the leading software framework for quantum computing. This design choice means that the tool is immediately accessible to the thousands of researchers already using Qiskit, removing the barrier of learning a new, specialized language. The software offers two distinct ways to work. The first is a complete, end-to-end workflow where a user can prepare a quantum circuit, run the randomized measurements, and analyze the results all within the same program. The second is a standalone tool for scientists who have already collected data from a real quantum machine. This allows them to feed their existing measurement records into the software to extract answers without needing to run the simulation steps again. This flexibility is crucial because it bridges the gap between theoretical simulation and the messy reality of physical hardware.

To prove the tool works, the team tested it on two very different scenarios. First, they examined a "cluster state," a specific type of quantum arrangement that acts as a resource for quantum computing. They used the software to check how well the state held together and to measure the connections between different parts of the system. The results matched the theoretical predictions perfectly, showing that the software could accurately calculate the purity of the state and the overlap between the cluster state and other known states. Second, they looked at a system evolving over time according to the rules of the Ising model, a classic framework for understanding how spins in a material interact. They tracked how the state changed as it evolved, measuring the entropy, or disorder, of the system at different moments. In these tests, they compared the software's analysis of data from a perfect, noise-free simulation against data collected from a real, physical quantum processor built by the Academia Sinica in Taiwan.

The results from the real hardware showed the expected imperfections. While the ideal simulation produced smooth, predictable curves, the data from the physical processor showed deviations, revealing the presence of noise and errors inherent in current technology. For instance, when measuring the overlap between the evolving state and its starting point, the real machine showed a larger drop in accuracy than the simulation, indicating that the physical qubits were losing their coherence faster than expected. Despite these errors, the software successfully captured the overall behavior of the system, demonstrating that it can distinguish between the true quantum dynamics and the noise introduced by the hardware. This ability to separate signal from noise is vital for benchmarking and improving future quantum devices.

The paper concludes that Qurrium provides a robust and accessible way to characterize quantum states, making advanced analysis available to a broader community of researchers. By supporting both full simulations and the analysis of real-world data, the tool helps scientists understand the capabilities and limitations of their quantum hardware. The researchers also highlight that the software can be extended to support direct hardware execution, allowing users to run experiments and analyze the results in a single environment. Furthermore, the ability to compare states prepared on different machines using the same randomized measurement data opens the door for standardized verification across different quantum platforms. This work does not claim to have solved all the problems of quantum measurement, but it offers a practical, efficient, and open-source solution that brings the complex task of quantum state characterization closer to the everyday practice of quantum scientists.

Technical Summary of "Qurrium: A Python package for randomized measurement-based estimation of quantum state properties"

Problem Statement
Characterizing quantum states is fundamental to applications ranging from Hamiltonian simulation and hardware calibration to algorithm design. While randomized measurement protocols offer a resource-efficient framework for estimating quantum state properties (such as purity, entropy, and overlaps) across various hardware platforms (trapped ions, superconducting qubits, etc.), there is a growing need for accessible software tools that integrate these protocols into the dominant quantum computing ecosystem. Existing tools, such as the Julia-based RandomMeas.jl, exist but do not leverage the widespread adoption of Python and Qiskit. The authors identify a gap for a native Python implementation that lowers the barrier to entry for researchers already working within the Qiskit framework.

Methodology
The paper introduces Qurrium, a Python package built directly on Qiskit that implements randomized measurement protocols, specifically focusing on the classical shadow protocol. The methodology relies on the "measure first, ask questions later" paradigm, where random measurements are performed first, and specific quantities are estimated during post-processing.

Key methodological components include:

Classical Shadow Protocol: The package implements the protocol where an $n$ -qubit state is measured under $N_U$ random Pauli settings. For each setting, a random tensor-product unitary $U$ is applied, followed by computational basis measurement. The resulting bitstrings and counts are used to construct "snapshots" (inverted measurement projectors). Averaging these snapshots yields an unbiased estimator of the density matrix ( $\hat{\rho}$ ).
Estimators: Qurrium provides estimators for:
- Linear Observables: Expectation values of Pauli operators via $\langle O \rangle = \text{Tr}(O \hat{\rho})$ .
- Nonlinear Functionals: Purity ( $\text{Tr}(\rho_A^2)$ ) and second-order Rényi entropy.
- State Overlap: The paper derives and implements an unbiased estimator for the overlap between two states $\rho$ and $\rho'$ , $\hat{f}_2(\rho, \rho') = \frac{1}{N_U} \sum_m \text{Tr}[\rho^{(m)} \Pi'^{(m)}]$ , where one state is inverted (shadow) and the other is kept as raw projectors. This allows for overlap estimation between states prepared independently.
Software Workflows:
- End-to-End Workflow: Users instantiate a ShadowUnveil class to define a quantum circuit, execute randomized measurements (via AerSimulator or hardware), and analyze data to extract properties. This workflow handles circuit execution, data collection, and analysis in a single pipeline.
- Standalone Estimation Workflow: Users can input pre-collected measurement data (random unitaries and bitstrings) in Qurrium's data format. This allows for the analysis of data from any hardware platform without re-running the simulation or circuit preparation stages.

Key Contributions

Qurrium Package: A Python-native implementation of randomized measurement protocols built on Qiskit, making these advanced characterization techniques accessible to the existing Qiskit user community.
Unbiased Overlap Estimator: The authors present a specific derivation and implementation for estimating the overlap between two independently prepared quantum states using classical shadows, extending the protocol beyond linear functionals.
Dual Workflow Architecture: The distinction between an integrated end-to-end workflow and a flexible standalone workflow enables both new experiments and the re-analysis of legacy hardware data.
Hardware Demonstration: The package was used to analyze experimental data from a prototype superconducting quantum processor developed by Academia Sinica (AS QPU), demonstrating compatibility with real-world, pulse-level control systems (Quantum Machines' OPX1000).

Results
The paper validates Qurrium through two primary use cases:

Cluster State: The package successfully estimated the purity, second-order Rényi entropy, and expectation values of stabilizer and non-stabilizer Pauli operators for one-dimensional cluster states. It also calculated the overlap between cluster states and reference states (all-zero, all-plus, and GHZ states) across various subsystem sizes. The results matched theoretical predictions derived from stabilizer formalism.
Ising Time Evolution: The package tracked the time evolution of a two-qubit system under an Ising Hamiltonian ( $H = JZ_0Z_1$ $H = J Z_{0} Z_{1}$ ).
- Pauli Observables: Estimated expectation values for $X$ and $Y$ observables matched analytical solutions, though real hardware (AS QPU) showed deviations consistent with noise.
- Overlap (Loschmidt Echo): Both linear ( $\hat{f}_1$ ) and non-linear ( $\hat{f}_2$ ) overlap estimators were tested. The $\hat{f}_2$ estimator showed larger deviations on hardware due to error accumulation, but both captured the qualitative dynamics, including the vanishing overlap at $Jt = \pi/2$ .
- Entropy: The second-order Rényi entropy of subsystems correctly captured the build-up of bipartite entanglement. Real hardware results showed reduced entropy compared to ideal simulations, indicating decoherence and amplitude damping.

Significance and Claims
The authors position Qurrium as a practical tool that bridges the gap between theoretical randomized measurement protocols and the practical needs of the quantum computing community. By leveraging Qiskit, the package lowers the entry barrier for researchers to perform resource-efficient state characterization.

The paper claims that the standalone estimation workflow is particularly significant for its platform independence; as long as measurement outcomes and random unitaries are recorded in the specified format, data from any hardware (trapped ions, superconducting qubits, etc.) can be analyzed uniformly. The successful application to the Academia Sinica superconducting processor demonstrates that the package can handle real experimental data, including pulse-level control integration.

The authors modestly frame the work as a step toward broader adoption of classical shadow protocols, noting that future developments could include direct hardware backend integration for end-to-end execution, pulse calibration using these metrics as objective functions, and standardized cross-platform verification protocols. The paper does not claim to solve all characterization challenges but provides a robust, accessible framework for estimating specific state properties with reduced resource overhead compared to full tomography.

More like this