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

AI summary

Overview

Research area: Quantum computing software — randomized measurement protocols (classical shadows) for quantum state characterization.

Technical level: Intermediate. Readers should be comfortable with qubit notation, Pauli operators, and Python/Qiskit, but the paper is written as tooling documentation rather than a theory paper.

Scope: This paper introduces Qurrium, a Qiskit-based Python package that implements randomized measurement protocols — specifically the classical shadow protocol — for estimating purity, second-order Rényi entropy, Pauli expectation values, and state overlap, with both a simulation-integrated workflow and a hardware-agnostic data-analysis workflow.

What This Paper Is About

Characterizing a quantum state (how pure it is, how entangled its parts are, how it compares to another state) normally requires many different measurement settings, each tailored to the quantity of interest. Randomized measurement protocols flip this: measure randomly first, then decide in post-processing what to estimate. The problem is that usable, low-friction software for this is scarce in the Python/Qiskit ecosystem — the authors point to RandomMeas.jl as a comprehensive Julia alternative. Qurrium fills that gap by providing a Qiskit-native implementation that accepts both simulated circuits and pre-collected data from any hardware platform.

Key Contributions

1. A Qiskit-native randomized measurement package. Qurrium implements the classical shadow protocol (random Pauli measurements) and the Haar-measure-based randomized measurement protocol, exposing purity, second-order Rényi entropy, Pauli expectation values, and state overlap through a single Python interface built directly on Qiskit.

2. Two distinct workflows. The end-to-end workflow (the ShadowUnveil class with .measure() and .analyze(), plus .write()/.read() serialization) handles circuit preparation, simulation, measurement, and analysis in one place. The standalone estimation workflow (classical_shadow_complex) accepts pre-collected bitstrings and random unitaries in Qurrium's data format from any platform, bypassing simulation entirely.

3. A new unbiased overlap estimator. The paper derives an estimator pairing the shot-averaged, inverted shadow of one state with the shot-averaged, uninverted raw projectors of a second state. Appendix A proves this deliberate asymmetry is what makes the estimator unbiased — extending classical shadows beyond linear functionals to comparing states prepared independently on different devices.

4. A hardware demonstration on an in-house superconducting processor. Measurements were taken on a five-qubit superconducting QPU fabricated by Academia Sinica (the "AS QPU"), driven by Quantum Machines OPX1000 controllers with pulse-level scripts in QUA, and analyzed through the standalone workflow.

Main Findings

• Cluster-state Pauli observables come out correct. For a six-qubit one-dimensional cluster state with open boundary conditions, using snapshots=600 and shots=400, the estimated expectation values for the stabilizers XZI and ZXZ were approximately 1.0 each, while the non-stabilizer ZXI gave approximately 0.0008 — consistent with stabilizer-state analysis.

• Overlap estimates match stabilizer theory. For a six-qubit periodic-boundary cluster state compared against all-zero, all-plus, and GHZ reference states, the estimated subsystem overlaps agreed well with the closed-form values in Table 1, which range from 1/2^n_A up to 1/2^(n−2) depending on subsystem size and reference state. Both the f̂₁ estimator (against a known density matrix) and the f̂₂ estimator (both states from measurement data) were used.

• Mutual information shows short-range entanglement. For an eight-qubit cluster state simulated on AerSimulator with N_U = 3^8 settings and N_K = 100 shots, and two-qubit subsystems A and B, the second-order Rényi mutual information took values 2, 1, and 0 at separations d = 0, 1, and 2 respectively. For open boundary conditions it stays at 0 beyond d > 2, reflecting the three-body stabilizer structure.

• Ising dynamics: ideal simulation tracks analytics, hardware drifts. For the two-qubit ZZ Ising quench (H = J Z₀Z₁, initial state |+⟩|+⟩) with N_U = 90 random Pauli settings and N_K = 32 shots, AerSimulator results matched the analytic predictions ⟨X₀X₁⟩ = 1, X-component oscillation at cos(2Jt), Y-components zero, and overlap cos²(Jt). AS QPU data captured the qualitative behavior but deviated quantitatively.

• The f̂₂ overlap estimator is more error-sensitive on hardware. Both overlap estimators agreed with analytics in ideal simulation, but on the AS QPU f̂₂ deviated more than f̂₁, because errors from both reconstructed density matrices accumulate. At Jt = π/2 the vanishing overlap marks orthogonality with the initial state.

• Hardware entropy is suppressed, whole-system purity is inflated. The single-qubit second-order Rényi entropy from the AS QPU did not reach its maximum of 1, which the authors attribute to amplitude damping or coherent gate errors preventing maximal entanglement; the ideal simulation followed the analytic form 1 − 2 sin²(Jt)cos²(Jt). Meanwhile the full two-qubit system, which should remain at zero entropy under unitary evolution, showed a larger value on the QPU, indicating decoherence.

• Not reported: No runtime benchmarks, memory-usage measurements, scaling studies with qubit count, or quantitative error-mitigation comparisons are given in the paper content.

Methodology in Plain English

The core recipe is "measure first, ask questions later." To probe an n-qubit state, you apply a random product of single-qubit gates — the paper uses the set {H, HS†, I} as the default — which effectively rotates the state so that a computational-basis measurement reveals a randomly chosen Pauli basis (X, Y, or Z) on each qubit. You repeat this for N_U random settings, with N_K shots each, and record both the chosen unitaries and the resulting bitstrings.

Each shot is then converted into a "snapshot" by inverting the known measurement distortion: each single-qubit projector is mapped to 3Π − I. Averaging these gives an estimate of the density matrix that is correct on average. From there, purity comes from comparing snapshots across different settings, entropy follows from purity, expectation values come from tracing the estimated density matrix against the operator, and overlaps come from pairing an inverted shadow of one state with raw projectors of another.

For the demonstration, the authors wrote two example programs: a time-independent one on a six-qubit cluster state (ground state of a sum of three-body stabilizers, built from Hadamards and controlled-Z gates) and a dynamical one on a two-qubit Ising quench. The cluster state is convenient because its exact purities, entropies, and overlaps can be computed analytically from the stabilizer group, giving ground truth for comparison. The Ising quench is convenient because its time evolution is exactly solvable. The hardware run used a five-qubit, one-dimensional superconducting chip with four tunable couplers, programmed at the pulse level in QUA; the raw data were then fed back into Qurrium's standalone analysis function without any simulation step.

Why This Matters

Tools determine who can participate. Randomized measurement protocols are among the most hardware-efficient ways to characterize quantum states, but implementing them correctly — with the right inverse channel, the right unbiased estimators, and the bookkeeping for random settings — is fiddly. Qurrium lowers that barrier by sitting inside Qiskit, which the authors note is the dominant framework in quantum computing software, so existing Qiskit users can adopt it without switching ecosystems. The standalone workflow matters just as much: it decouples data collection from analysis, so a lab running hardware through any control stack can hand its data to a collaborator for standardized processing.

Real-world applications include:

• Hardware benchmarking and calibration. Purity and overlap serve as hardware-agnostic objective functions for tuning pulses and gates, without requiring full state tomography.
• Quantum many-body physics studies. Rényi entropies and mutual information reveal entanglement structure in simulated materials and spin models.
• Cross-platform verification. Comparing states prepared on different quantum devices from a shared set of randomized measurements.
• Algorithm and device development. Estimating observables with measurement settings chosen before knowing what will be asked.

Industry relevance: The package targets the practical gap between quantum algorithms research and deployed hardware characterization. Its use of the Qiskit runtime API is flagged as a route to error mitigation methods such as dynamical decoupling and Pauli twirling, and the pulse-calibration angle is directly relevant to groups operating superconducting processors who need faster characterization loops.

Future Directions

1. Native hardware backends inside Qurrium. The end-to-end workflow currently covers simulation (AerSimulator); extending it to real backends would consolidate circuit construction, execution, and analysis in one environment. The authors outline two routes: a single pre-compiled program that generates random Pauli settings in real time (as in their OPX1000 implementation), or compiling one circuit per random setting via the Qiskit runtime API.

2. Pulse calibration powered by state-property estimates. Folding the end-to-end workflow into a pulse-optimization loop would let purity and overlap act as calibration objectives, potentially reducing calibration overhead relative to full tomography.

3. Standardized cross-platform verification protocols. Turning the standalone workflow into a shared convention for exchanging randomized measurement data would let groups compare measurement accuracy, hardware performance, and state-preparation quality across devices.

4. Open question: accounting for hardware noise in estimators. The AS QPU results show f̂₂ accumulating error from both reconstructed states, and subsystem entropy failing to reach its maximum of 1. How to best mitigate these effects (beyond mentioning existing Qiskit runtime tools) is left for follow-up work.

Target Audience

Quantum computing researchers and graduate students who already work in Python and Qiskit and need to characterize simulated or hardware-prepared states without building measurement pipelines from scratch. It is especially useful for experimental groups collecting randomized measurement data on platforms outside the Qiskit execution stack, and for theorists who want a reference implementation of the classical shadow estimators — including the asymmetric overlap estimator — to check against or build upon. Readers seeking performance benchmarks or large-scale scaling analysis will not find them here; this is a software and demonstration paper.

Authors’ abstract

Estimating quantum state properties is essential across a wide range of applications, from studying quantum many-body physics to benchmarking quantum hardware. We present Qurrium, a Python package built on Qiskit that implements randomized measurement protocols for estimating purity, second-order Rényi entropy, expectation values of Pauli observables, and state overlap. In this paper, we focus on the classical shadow protocol and demonstrate two workflows in Qurrium. One is the end-to-end workflow that integrates quantum circuit preparation, simulation, measurement, and analysis. The other is the standalone estimation workflow that accepts pre-collected measurement data from any hardware platform in Qurrium's data format. We demonstrate both workflows through examples of a cluster state and an Ising time-evolved state. Furthermore, we report results obtained from a superconducting quantum processor developed by Academia Sinica and analyzed using the standalone estimation workflow. Qurrium is built on Qiskit, the dominant framework in quantum computing software, making it directly accessible to the large community of researchers already working with Qiskit. The source code is openly available at https://github.com/qurrium/qurrium and the example code is provided at https://github.com/qurrium/classical-shadow-examples.