Pauli Strings: Quantum Operator Basis

• Pauli strings are tensor products of Pauli matrices (I, X, Y, Z) that provide an orthogonal operator basis for multi-qubit systems, enabling efficient qubit Hamiltonian representation.
• They enable commutation analysis and grouping strategies that reduce measurement settings in hybrid quantum-classical algorithms through binary symplectic representations.
• Their algebraic properties underpin Hamiltonian simulation and scalable circuit synthesis, with efficient classical decomposition methods and FPGA-accelerated implementations.

Searching arXiv for recent and foundational papers on Pauli strings to ground the article. {"query":"Pauli strings arXiv hybrid quantum-classical algorithms commutation decomposition propagation universality", "max_results": 10} Pauli strings are tensor products of single-qubit Pauli operators $I$, $X$, $Y$, and $Z$ on multi-qubit systems. They furnish an orthogonal operator basis for $2^n\times 2^n$ matrices, provide the standard language for qubit Hamiltonians and observables, and function as a fundamental computational primitive in hybrid quantum-classical algorithms. Contemporary work treats them not only as a basis for operator expansions, but also as the objects underlying measurement grouping, classical preprocessing, Pauli propagation, magic quantification, and Lie-algebraic controllability (Le et al., 8 Jan 2026, Xiao et al., 2 Jan 2026, Butt et al., 2023).

1. Algebraic definition and representations

On one qubit, the Pauli operators are

$I=\begin{pmatrix}1&0\0&1\end{pmatrix},\quad X=\begin{pmatrix}0&1\1&0\end{pmatrix},\quad Y=\begin{pmatrix}0&-i\ i&0\end{pmatrix},\quad Z=\begin{pmatrix}1&0\0&-1\end{pmatrix}.$

An $n$-qubit Pauli string is a tensor product

$P=\bigotimes_{i=1}^n P_i,\qquad P_i\in\{I,X,Y,Z\},$

or, equivalently, an element of $\{I,X,Y,Z\}^{\otimes n}$; there are $4^n$ such strings, and they form an orthogonal basis for the space of $X$0 complex matrices (Xiao et al., 2 Jan 2026, Jones, 2024).

Up to global phases $X$1, these strings generate the Pauli group. A standard binary symplectic labeling writes a Pauli string as

$X$2

with the local correspondence

$X$3

up to phase (Xiao et al., 2 Jan 2026). An equivalent convention used in array-based implementations is

$X$4

which turns each qubit into a two-bit object and makes bitwise manipulation natural (Dion et al., 2024).

This binary viewpoint is not merely notational. In accelerator and library designs, Pauli strings are encoded as packed bit strings whose $X$5-like and $X$6-like content can be updated by XOR, population count, and related bitwise primitives (Le et al., 8 Jan 2026, Krötz, 25 May 2026). This suggests that much of Pauli-string processing is governed by finite-field structure rather than dense matrix arithmetic.

2. Commutation structure, graphs, and commuting families

Any two Pauli strings either commute or anticommute. For tensor products

$X$7

the pair commutes if the number of qubits on which both local factors are non-identity and different is even, and anticommutes if that number is odd (Butt et al., 2023). In binary symplectic form, this condition is expressed by the parity of

$X$8

or equivalently by the symplectic inner product

$X$9

which vanishes for commuting pairs and is nonzero for anticommuting pairs (Reggio et al., 2023, Krötz, 25 May 2026).

This pairwise structure induces a graph on a chosen set of Pauli strings. One common convention places an edge between two strings when they anticommute; this object appears as the anti-commutation graph in controllability theory and as the frustration graph in studies of the joint numerical range (Smith et al., 10 Jun 2026, Xu et al., 2023). The graph-theoretic viewpoint is central because several properties of Pauli collections depend only on this adjacency structure: universality criteria, ellipsoidal bounds on jointly attainable expectation values, and measurement-grouping algorithms are all phrased in graph language (Smith et al., 10 Jun 2026, Xu et al., 2023).

For measurement tasks, commuting subsets are the relevant decomposition. A full set of non-identity $Y$0-qubit Pauli strings admits an optimal partition into

$Y$1

maximally commuting families, each of size

$Y$2

and this is the minimal possible number of such families (Butt et al., 2023). Finite-field constructions generate these families explicitly by symmetric matrices over $Y$3, while graph-based heuristics address the more general case of arbitrary sparse operator supports (Butt et al., 2023). The practical consequence is that a large Pauli decomposition can often be reorganized into a much smaller number of simultaneously measurable blocks.

3. Exponentials, conjugation, and dynamical propagation

Exponentials of Pauli strings are the elementary unitaries of Hamiltonian simulation and many variational circuits. Since any Pauli string $Y$4 satisfies $Y$5, its exponential obeys

$Y$6

so Hamiltonian simulation by product formulas reduces to repeated application of Pauli-string rotations (Sarkar et al., 2024).

Circuit synthesis for $Y$7 can be organized by reducing a general $Y$8-string to an $Y$9-string through single-qubit Clifford conjugations and then using permutation similarity to map that string to $Z$0. In the construction of scalable circuits, the relevant permutation matrices are products of CNOT gates, and the resulting implementation uses single-qubit rotations together with CNOTs in a pattern compatible with low-connectivity, star-graph hardware (Sarkar et al., 2024). For arbitrary Pauli strings, the gate counts are bounded in terms of the numbers of $Z$1, $Z$2, and $Z$3 factors, with at most $Z$4 CNOTs of one orientation and at most $Z$5 of the opposite orientation in the general case (Sarkar et al., 2024).

Under conjugation by Clifford operations, Pauli strings map to Pauli strings exactly; under a general Pauli rotation, an anticommuting Pauli string becomes a linear combination of two strings. Pauli propagation exploits this by tracking operators directly in the Pauli basis instead of in state-vector form (Teng et al., 12 Dec 2025). In Liouville space, the adjoint action is encoded by a Pauli transfer matrix, and the resulting Pauli-path expansion expresses the evolved operator as a sum over intermediate Pauli strings. The chief obstacle is the rapid growth of the support of this sum.

When the dynamics possess symmetry, many propagated strings are redundant. A symmetry-adapted framework merges strings that lie in the same group orbit and propagates only orbit representatives. For a symmetry group $Z$6, the orbit

$Z$7

partitions the Pauli basis, and the symmetry-merging Pauli propagation algorithm replaces ordinary coefficient dictionaries by dictionaries indexed by orbit representatives (Teng et al., 12 Dec 2025). The resulting reduction in space complexity is determined by orbit sizes; explicit formulas are given for translation symmetry and permutation symmetry, with the latter yielding

$Z$8

representatives instead of $Z$9 strings (Teng et al., 12 Dec 2025).

4. Decomposition, sampling, and classical algorithms

A central classical task is Pauli decomposition: given an operator $2^n\times 2^n$0, compute coefficients $2^n\times 2^n$1 in

$2^n\times 2^n$2

For dense, arbitrary complex matrices, a Gray-code method evaluates each coefficient in $2^n\times 2^n$3 time and the full decomposition in $2^n\times 2^n$4, while using constant additional memory and a branchless inner loop (Jones, 2024). The same work emphasizes that the algorithm is particularly suited to matrices expected to be dense in the Pauli basis and that it is embarrassingly parallel across Pauli indices (Jones, 2024).

A different regime arises when the matrix is promised to be $2^n\times 2^n$5-sparse in the Pauli basis and is given by sparse classical queries. In that setting, an exact randomized algorithm recovers the full decomposition with success probability at least $2^n\times 2^n$6 and with query and runtime complexity polynomial in $2^n\times 2^n$7, $2^n\times 2^n$8, and $2^n\times 2^n$9 (Spencer et al., 30 Jun 2026). The method separates the $I=\begin{pmatrix}1&0\0&1\end{pmatrix},\quad X=\begin{pmatrix}0&1\1&0\end{pmatrix},\quad Y=\begin{pmatrix}0&-i\ i&0\end{pmatrix},\quad Z=\begin{pmatrix}1&0\0&-1\end{pmatrix}.$0-support and $I=\begin{pmatrix}1&0\0&1\end{pmatrix},\quad X=\begin{pmatrix}0&1\1&0\end{pmatrix},\quad Y=\begin{pmatrix}0&-i\ i&0\end{pmatrix},\quad Z=\begin{pmatrix}1&0\0&-1\end{pmatrix}.$1-support of the unknown Pauli strings and treats the latter as a sparse Walsh-Hadamard recovery problem.

Expectation-value sampling also benefits from Pauli structure. For stabilizer Rényi entropies and stabilizer nullity, the relevant quantities are $I=\begin{pmatrix}1&0\0&1\end{pmatrix},\quad X=\begin{pmatrix}0&1\1&0\end{pmatrix},\quad Y=\begin{pmatrix}0&-i\ i&0\end{pmatrix},\quad Z=\begin{pmatrix}1&0\0&-1\end{pmatrix}.$2 over all Pauli strings $I=\begin{pmatrix}1&0\0&1\end{pmatrix},\quad X=\begin{pmatrix}0&1\1&0\end{pmatrix},\quad Y=\begin{pmatrix}0&-i\ i&0\end{pmatrix},\quad Z=\begin{pmatrix}1&0\0&-1\end{pmatrix}.$3. By partitioning Pauli operators into families indexed by $I=\begin{pmatrix}1&0\0&1\end{pmatrix},\quad X=\begin{pmatrix}0&1\1&0\end{pmatrix},\quad Y=\begin{pmatrix}0&-i\ i&0\end{pmatrix},\quad Z=\begin{pmatrix}1&0\0&-1\end{pmatrix}.$4 and applying a fast Walsh-Hadamard transform in the complementary $I=\begin{pmatrix}1&0\0&1\end{pmatrix},\quad X=\begin{pmatrix}0&1\1&0\end{pmatrix},\quad Y=\begin{pmatrix}0&-i\ i&0\end{pmatrix},\quad Z=\begin{pmatrix}1&0\0&-1\end{pmatrix}.$5-index, one obtains all Pauli expectations in $I=\begin{pmatrix}1&0\0&1\end{pmatrix},\quad X=\begin{pmatrix}0&1\1&0\end{pmatrix},\quad Y=\begin{pmatrix}0&-i\ i&0\end{pmatrix},\quad Z=\begin{pmatrix}1&0\0&-1\end{pmatrix}.$6 rather than $I=\begin{pmatrix}1&0\0&1\end{pmatrix},\quad X=\begin{pmatrix}0&1\1&0\end{pmatrix},\quad Y=\begin{pmatrix}0&-i\ i&0\end{pmatrix},\quad Z=\begin{pmatrix}1&0\0&-1\end{pmatrix}.$7, and the average cost per sampled Pauli string drops from $I=\begin{pmatrix}1&0\0&1\end{pmatrix},\quad X=\begin{pmatrix}0&1\1&0\end{pmatrix},\quad Y=\begin{pmatrix}0&-i\ i&0\end{pmatrix},\quad Z=\begin{pmatrix}1&0\0&-1\end{pmatrix}.$8 to $I=\begin{pmatrix}1&0\0&1\end{pmatrix},\quad X=\begin{pmatrix}0&1\1&0\end{pmatrix},\quad Y=\begin{pmatrix}0&-i\ i&0\end{pmatrix},\quad Z=\begin{pmatrix}1&0\0&-1\end{pmatrix}.$9 (Xiao et al., 2 Jan 2026).

For bounded-locality collections, even the basic task of counting anticommuting pairs admits specialized acceleration. If $n$0 Pauli strings on $n$1 qubits have weight bounded by a constant, the exact number of anticommuting unordered pairs can be computed in $n$2 time in the bounded-locality regime by maintaining counts of labeled subpatterns and using a subset-zeta identity, rather than performing $n$3 pairwise symplectic checks (Cha et al., 10 May 2026).

5. Implementations and performance-oriented systems

Several recent systems treat Pauli strings as first-class computational objects rather than as derived symbolic data. They differ in target workload—matrix decomposition, Hamiltonian preprocessing, array algebra, or FPGA acceleration—but converge on the same principle: compact binary structure is the main source of speed.

System	Task	Reported results
PACOX	FPGA-based Pauli string computation	250 MHz, 0.33 W, 8,052 LUTs, 10,934 FFs, 324 BRAMs; up to 100 times speedup for up to 19 qubits (Le et al., 8 Jan 2026)
PauLIB	High-performance Pauli-string processing	25 ns single-string multiplication at 500 qubits; 14 times faster than PauliEngine and 660 times faster than Qiskit; 142 MB vs 1,036 MB for a one-million-term Hamiltonian at 500 qubits (Krötz, 25 May 2026)
PauliArray	NumPy-based array manipulation of Pauli strings	about 6 times faster than Qiskit and 3 times faster than OpenFermion for the tested Jordan–Wigner mappings; about 2 times faster than Qiskit for commutators (Dion et al., 2024)
DENSE / DenseGrouper	Optimal grouping into commuting families for dense operators	computational speedups close to the theoretical limit of $n$4 relative to qubit-wise commuting groupings, for $n$5 qubits (Reggio et al., 2023)

PACOX is distinctive in computing a sparse representation of a Pauli string not as a $n$6 matrix but as a permutation vector $n$7 and phase vector $n$8, using a compact binary encoding, XOR-based index permutation, and phase accumulation in FPGA logic (Le et al., 8 Jan 2026). PauLIB instead targets large Pauli sums in software through a bit-packed binary symplectic representation, sorted array layouts rather than hash maps, and a struct-of-arrays organization for explicit SIMD vectorization (Krötz, 25 May 2026). PauliArray focuses on multidimensional array semantics and broadcasting over Pauli strings and operators, enabling fermion-to-qubit mappings, commutators, and expectation-value manipulations with compact NumPy code (Dion et al., 2024).

The measurement-grouping line of work addresses a different bottleneck: reducing the number of circuit settings required for expectation values of dense operators. The DENSE method partitions the full set of $n$9-qubit Pauli strings into the minimal number of commuting families and provides corresponding diagonalizing circuits, with reported IBM-hardware speedups close to $P=\bigotimes_{i=1}^n P_i,\qquad P_i\in\{I,X,Y,Z\},$0 over qubit-wise commuting groupings for $P=\bigotimes_{i=1}^n P_i,\qquad P_i\in\{I,X,Y,Z\},$1 (Reggio et al., 2023). Together, these systems show that Pauli-string workloads are now treated as a distinct domain for high-performance computing.

6. Roles in magic, controllability, testing, and geometry

In resource-theoretic studies of nonstabilizerness, Pauli strings define the probability distribution

$P=\bigotimes_{i=1}^n P_i,\qquad P_i\in\{I,X,Y,Z\},$2

whose Rényi entropies yield stabilizer Rényi entropies, and whose unit-modulus support determines stabilizer nullity (Xiao et al., 2 Jan 2026). Because this distribution is indexed by the full Pauli basis, efficient manipulation of Pauli strings directly determines the tractability of magic estimation for generic many-body wavefunctions.

In controllability theory, Pauli strings are used as Hamiltonian generators. One result shows that, when generators are restricted to be Pauli strings, the minimal universal generating set for $P=\bigotimes_{i=1}^n P_i,\qquad P_i\in\{I,X,Y,Z\},$3 has size

$P=\bigotimes_{i=1}^n P_i,\qquad P_i\in\{I,X,Y,Z\},$4

and an associated compiler produces a sequence of Pauli rotations for any target Pauli rotation with optimal $P=\bigotimes_{i=1}^n P_i,\qquad P_i\in\{I,X,Y,Z\},$5 complexity (Smith et al., 2024). A complementary result provides necessary and sufficient conditions for a finite set of Pauli strings to generate $P=\bigotimes_{i=1}^n P_i,\qquad P_i\in\{I,X,Y,Z\},$6: existence of a universal core on a subset of qubits, product universality on the complement, and connectivity of the anti-commutation graph (Smith et al., 10 Jun 2026). In that framework, the anti-commutation graph is the decisive combinatorial object.

In verification and software engineering, commuting Pauli strings have been used as test cases rather than as mere observables. QOPS defines a test case as a weighted linear combination of Pauli strings drawn from the same commuting family, integrates directly with IBM’s Estimator API, and uses commuting families to reduce the amount of program specification required. On 194,982 real quantum programs it reports perfect F1-score, precision, and recall (Muqeet et al., 2024). This suggests that Pauli-string structure can serve not only algorithm design and simulation, but also industrial-scale program testing.

A more geometric direction studies the joint numerical range of a set of Pauli strings through its frustration graph. The graph parameter

$P=\bigotimes_{i=1}^n P_i,\qquad P_i\in\{I,X,Y,Z\},$7

emerges as the exact maximal sum of squared expectations for any self-adjoint unitary representation of the graph, and satisfies

$P=\bigotimes_{i=1}^n P_i,\qquad P_i\in\{I,X,Y,Z\},$8

A counterexample based on $P=\bigotimes_{i=1}^n P_i,\qquad P_i\in\{I,X,Y,Z\},$9 shows that $\{I,X,Y,Z\}^{\otimes n}$0 can be strictly larger than the independence number, while still remaining below the Lovász theta number (Xu et al., 2023). This places Pauli strings at the intersection of operator geometry and graph invariants.

Pauli strings therefore occupy a dual role. Algebraically, they are the discrete operator basis of qubit theory. Computationally, they are the objects upon which decomposition, grouping, simulation, propagation, and control algorithms act. The recent literature shows that advances in quantum software, hardware acceleration, and structural analysis increasingly depend on treating Pauli strings not as incidental notation, but as the primary units of representation and computation.