Notation

This page collects the notation used throughout the concepts section: the Majorana basis, how monomials are indexed and made Hermitian, the expansion of operators and states, the commutation rule that drives propagation, and the Pauli operators used for qubit problems. The Propagation Algorithm page builds on these definitions.

Majorana operators

Majorana operators $m_j$ are Hermitian ($m_j^\dagger = m_j$) and satisfy the anticommutation algebra

$$\{m_i,\,m_j\} = 2\delta_{ij}\,\mathbb{I}.$$

A system of $N$ fermionic modes is described by $2N$ Majorana operators $m_1, \ldots, m_{2N}$. They are related to the usual fermionic creation and annihilation operators by

$$c_j^\dagger = \tfrac{1}{2}(m_{2j-1} + i\,m_{2j}), \qquad c_j = \tfrac{1}{2}(m_{2j-1} - i\,m_{2j}).$$

Every operator on $N$ modes can be written as a polynomial in the $2N$ Majorana operators, so Hamiltonians, quantum states, and circuit generators can all be expressed in the same language.

Monomials and the Hermitian basis

A Majorana monomial is indexed by a binary string $\nu \in \{0,1\}^{2N}$ and defined with a phase prefactor that makes it Hermitian:

$$M_\nu = i^{\binom{|\nu|}{2}}\, m_1^{\nu_1} m_2^{\nu_2} \cdots m_{2N}^{\nu_{2N}} \;\propto\; \prod_{i=1}^{N} m_{2i-1}^{\nu_{2i-1}}\, m_{2i}^{\nu_{2i}}.$$

The string $\nu$ records which Majorana operators are present (its set of ones is the monomial's support), and the length $|\nu|$ is the number of ones - i.e. how many Majorana operators the monomial contains.

Each of the $2N$ positions of $\nu$ is a slot, and API documentation that counts something "in slots" means positions of $\nu$ rather than modes or qubits. In the Majorana basis slot $j$ is the Majorana operator $m_j$; the Pauli basis stores a Pauli string in the same $2N$ slots, two per qubit, so a length counted in slots runs up to twice the qubit count.

The phase $i^{\binom{|\nu|}{2}}$ makes $M_\nu$ Hermitian. Taking the dagger reverses the order of the $n$ Majorana operators, and each of the $\binom{n}{2}$ transpositions needed to restore their order flips a sign, so a bare monomial of length $n$ satisfies $(m_{i_1}\cdots m_{i_n})^\dagger = (-1)^{n(n-1)/2}\,m_{i_1}\cdots m_{i_n}$. The compensating factor $i^{\binom{|\nu|}{2}}$ cancels this sign and restores $M_\nu^\dagger = M_\nu$:

Because every $M_\nu$ is Hermitian, any Hermitian operator $H$ expands with purely real coefficients,

$$H = \sum_\nu c_\nu\, M_\nu, \qquad c_\nu \in \mathbb{R}.$$

Commutation rule

For two monomials $M_\nu$ and $M_\mu$, whether they commute or anticommute is fixed by their lengths and the parity of their overlap $|\nu \cap \mu|$ with $\cap$ being equivalent to bit-wise AND operation on the binary strings:

$$M_\nu M_\mu = (-1)^{\,|\nu|\,|\mu| \,+\, |\nu \cap \mu|}\, M_\mu M_\nu.$$

The three resulting cases are:

• two even monomials commute iff the overlap is even;
• two odd monomials commute iff the overlap is odd;
• an even and an odd monomial commute iff the overlap is even.

Throughout propagation the generators and the propagated terms are even monomials, so the relevant case is the first: two even monomials anticommute if and only if their overlap is odd. When that happens, their product is again a single monomial, on the symmetric difference of the two supports:

$$M_\nu M_\mu \;\propto\; M_{\nu \oplus \mu}, \qquad |\nu \oplus \mu| = |\nu| + |\mu| - 2\,|\nu \cap \mu|.$$

With this one-to-one map, an anticommuting pair produces exactly one new monomial, which is what makes gate application deterministic and sparse, and is the algebraic core of the propagation algorithm.

Reference states and paired monomials

monoprop's reference state is always a product state: a Fock state $|n_1 \dots n_N\rangle$ in mode space, or equivalently a computational-basis state in qubit space. (In quantum chemistry this is the Hartree-Fock reference, or Slater determinant, but nothing in the algorithm assumes that origin.) Such a state has an especially simple Majorana expansion. Introducing the paired operator for each mode,

$$\overline{m}_j = -i\,m_{2j-1} m_{2j},$$

the corresponding density operator factorises one mode at a time,

$$|n_1 \dots n_N\rangle\!\langle n_1 \dots n_N| = \frac{1}{2^N} \prod_{j=1}^{N}\bigl(1 + (-1)^{n_j}\,\overline{m}_j\bigr).$$

Expanding the product, this is a sum of paired monomials -- products of the $\overline{m}_j$ -- with signs fixed by the occupation numbers.

Pauli operators

For qubit problems monoprop works in the Pauli basis. The single-qubit Pauli operators $X, Y, Z$ are Hermitian and square to the identity,

$$X^2 = Y^2 = Z^2 = \mathbb{I}, \qquad P^\dagger = P.$$

On a single qubit two distinct Paulis anticommute,

$$XY = -YX, \qquad YZ = -ZY, \qquad ZX = -XZ,$$

and cyclically, while any two Paulis acting on different qubits commute. Two single-qubit Paulis therefore either commute (when they are equal, or one is the identity) or anticommute, and their product is again a single Pauli up to a phase.

A Pauli string on $N$ qubits is a tensor product

$$P = P_1 \otimes \cdots \otimes P_N, \qquad P_i \in \{I, X, Y, Z\},$$

built from a single-qubit Pauli on each qubit. Every Pauli string is Hermitian and squares to the identity, and any operator on $N$ qubits can be written as a polynomial in the Pauli strings, so Hamiltonians, quantum states, and circuit generators are all expressed in the same language.

Because every Pauli string is Hermitian, any Hermitian operator $H$ expands with purely real coefficients,

$$H = \sum_P c_P\, P, \qquad c_P \in \mathbb{R}.$$

Two Pauli strings either commute or anticommute: comparing them qubit by qubit, the product picks up one sign flip for each qubit on which they carry distinct, non-identity Paulis, so they anticommute exactly when the number of such qubits is odd. When that happens their product is again a single Pauli string (up to a phase), which is what makes gate application in the Pauli picture deterministic and sparse.

The Pauli weight of a string is the number of qubits it acts on non-trivially — the count of its non-identity factors. It is the structural measure of a Pauli string, and PauliPropagator uses it to decide which terms to keep as the operator grows (see Truncation and cutoffs).