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 = \tfrac{1}{2}(m_{2j-1} + i\,m_{2j}), \qquad c_j^\dagger = \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.

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|$:

$$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|.$$

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

Reference states and paired monomials

A Fock state $|n_1 \dots n_N\rangle$ (in particular a Hartree-Fock reference, or Slater determinant) has an especially simple Majorana expansion. Introducing the paired operator for each orbital,

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

the corresponding density operator factorises one orbital 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).