Fermion-to-qubit mappings with varying resource requirements for quantum simulation

Here, we propose a general family of mappings of fermionic models to qubit systems and quantum gates that allow us to trade-off the necessary number of qubits n against the difficulty of implementation as parametrized by L, or more complicated quantum gates such as CPhase. Ideally, one would of course like both the number of qubits, as well as the the gate size to be small. We show that our mappings can lead to significant savings in qubits for a variety of examples (see table 1) as compared to the Jordan–Wigner transform for instance, at the expense of greater complexity in realizing the required gates. The latter may lead to an increased time required for the simulation depending on which gates are easy to realize in a particular quantum computing architecture.

Table 1.  Overview of mappings presented in this paper, listed by the complexity of their code functions, their qubit savings, qubit requirements (n), properties of the resulting gates and first appearance. Mappings can be compared with respect to the size of plain words (N) and their targeted Hamming weight K. We also refer to different methods that are not listed, as they do not rely on codes in any way [30, 31].

Mapping	En-/decoding type	Qubits saved	n(N, K)	Resulting gates	Origin
Jordan–Wigner $|$ Parity transform	Linear/linear	None	N	Length-O(n) Pauli strings	[20, 24]
Bravyi–Kitaev transform	Linear/linear	None	N	Length-O(log n) Pauli strings	[2]
Checksum codes	Linear/ affine linear	O(1)	N − 1	Length-O(n) Pauli strings	Here
Binary addressing codes	Nonlinear/nonlinear	O(2n/K)	$\mathrm{log}({N}^{K}/K!)$	$(O(n))$-controlled gates	Here
Segment codes	Linear/nonlinear	$O(n/K)$	$N/\left(1+\tfrac{1}{2K}\right)$	$(O(K))$-controlled gates	Here

At the heart of our efforts is an entirely general construction of the creation and annihilation operators in (3) given an arbitrary encoding ${\bf{e}}$ and the corresponding decoding ${\bf{d}}$. As one might expect, this construction is not efficient for every choice of encoding ${\bf{e}}$ or decoding ${\bf{d}}$. However, for linear encodings ${\bf{e}}$, but possibly nonlinear decodings ${\bf{d}}$, they can take on a very nice form. While in principle any classical code with the same properties can be shown to yield such mappings, we provide an appealing example of how a classical code of fixed Hamming weight [28] can be used to give an interesting mapping.

Two other approaches allow us to be more modest with the algorithmic depth in either accepting a qubit saving that is linear with N, or just saving a fixed amount of qubits for hardly any cost at all.

In previous works, trading quantum resources has been addressed for general algorithms [29], and quantum simulations [30–32]. In the two works of Moll et al and Bravyi et al, qubit requirements are reduced with a scheme that is different from ours. A qubit Hamiltonian is first obtained with e.g. the Jordan–Wigner transform, then unitary operations are applied to it in order taper qubits off successively. The paper by Moll et al provides a straight-forward method to calculate the Hamiltonian, that can be used to reduce the amount of qubits to a minimum, but the number of Hamiltonian terms scales exponentially with the particle number. The notion that our work is based on, was first introduced in [31] by Bravyi et al, for linear en- and decodings. With the generalization of this method, we hope to make the goal of qubit reduction more attainable in reducing the effort to do so. The reduction method is mediated by nonlinear codes, of which we provide different types to choose from. The transform of the Hamiltonian is straight-forward from there on, and we give explicit recipes for arbitrary codes. We can summarize our contributions as follows.

• We show that for any encoding ${\bf{e}}\,:{{\mathbb{Z}}}_{2}^{\otimes N}\to {{\mathbb{Z}}}_{2}^{\otimes n}$ there exists a mapping of fermionic models to quantum gates. For the special case that this encoding is linear, our procedure can be understood as a slightly modified version of the perspective taken in [24]. This gives a systematic way to employ classical codes for obtaining such mappings.
• Using particle conservation symmetry, we develop 3 types of codes that save a constant, linear and exponential amount of qubits (see table 1 and sections 3.1.1–3.1.3). An example from classical coding theory [28] is used to obtain significant qubit savings (here called the binary addressing code), at the expense of increased gate difficulty (unless the architecture would easily support multi-controlled gates).
• The codes developed are demonstrated on two examples from quantum chemistry and physics.
  • 1.  
    The Hamiltonian of the well-studied hydrogen molecule in minimal basis is re-shaped into a two-qubit problem, using a simple code.
  • 2.  
    A Fermi–Hubbard model on a 2 × 5 lattice and periodic boundary conditions in the lateral direction is considered. We parametrize and compare the sizes of the resulting Hamiltonians, as we employ different codes to save various amounts of qubits. In this way, the trade-off between qubit savings and gate complexity is illustrated (see table 2).

As an illustration, we present popular examples of these linear transformations, note again that all of these will have n = N. The Jordan–Wigner transform is a special case for $A={\mathbb{I}}$, leading to the direct mapping. The operator transform gives L = O(N) Pauli strings as

$$\begin{eqnarray}&&{({c}_{j}^{\dagger })}^{b}{({c}_{j}^{})}^{b+1\mathrm{mod}2}\hat{=}\displaystyle \frac{1}{2}({X}_{j}+i{(-1)}^{b}\,{Y}_{j})\mathop{\displaystyle \bigotimes }\limits_{m\lt j}{Z}_{m}.\end{eqnarray} \tag{ 15 }$$

In the parity transform [24], we have L = O(N) X-strings:

$$\begin{eqnarray}{A}^{-1}=\left[\begin{array}{cccc}1 & & & \\ 1 & 1 & & \\ & \ddots & \ddots & \\ & & 1 & 1\end{array}\right],\quad A=\left[\begin{array}{cccc}1 & & & \\ 1 & 1 & & \\ \vdots & \vdots & \ddots & \\ 1 & 1 & \cdots & 1\end{array}\right],\end{eqnarray} \tag{ 16 }$$

$$\begin{eqnarray}&&{({c}_{j}^{\dagger })}^{b}{({c}_{j}^{})}^{b+1\mathrm{mod}2}\ \\ &&\quad \hat{=}\displaystyle \frac{1}{2}({Z}_{j-1}\otimes {X}_{j}-i{(-1)}^{b}\,{Y}_{j})\underset{m=j+1}{\overset{N}{\displaystyle \bigotimes }}{X}_{m}.\end{eqnarray} \tag{ 17 }$$

The Bravyi–Kitaev transform [2] is defined by a matrix A [24, 33] that has non-zero entries according to a certain binary tree rule, achieving $L=O(\mathrm{log}N)$.

Our goal is to be able to trade quantum resources, which is done by reducing degrees of freedom by exploiting symmetries. For that purpose, we provide a theoretical foundation to characterize the latter.

Parity, Jordan–Wigner and Bravyi–Kitaev transforms encode all ${{ \mathcal F }}_{N}$ states and provide mappings for every ${ \mathcal L }({{ \mathcal F }}_{N})$ operator. Unfortunately,they require us to own a N-qubit quantum computer, which might be unnecessary. In fact, the only operator we want to simulate is the Hamiltonian, which usually has certain symmetries. Taking these symmetries into account enables us to perform the same task with n ≤ N qubits instead. Symmetries usually divide the ${{ \mathcal F }}_{N}$ into subspaces, and the idea is to encode only one of those. Let ${ \mathcal B }$ be a basis spanning a subspace $\mathrm{span}({ \mathcal B })\subseteq {{ \mathcal F }}_{N}$ be associated with a Hamiltonian (11), where for every $l,{\boldsymbol{a}},{\boldsymbol{b}};$ ${\hat{h}}_{{\boldsymbol{ab}}}\,:\mathrm{span}({ \mathcal B })\to \mathrm{span}({ \mathcal B })$. Usually, Hamiltonian symmetries generate many such (distinct) subspaces. Under consideration of additional information about our problem, like particle number, parity or spin polarization,we select the correct subspace. Note that particle number conservation is by far the most prominent symmetry to take into account. It is generated by Hamiltonians that are linear combinations of products of ${c}_{i}^{\dagger }{c}_{j}^{\,}\,| \,i,j\in [N]$. These Hamiltonians, originating from first principles, only exhibit terms conserving the total particle number;${\hat{h}}_{{\boldsymbol{ab}}}\,:{{ \mathcal H }}_{N}^{M}\to {{ \mathcal H }}_{N}^{M}$. From all the Hilbert spaces ${{ \mathcal H }}_{N}^{M}$, one considers the space with the particle number matching the problem description.

These symmetries will be utilized in the next section: we develop a language that allows for encodings ${\boldsymbol{e}}$ that reduce the length of the binary vectors ${\boldsymbol{e}}({\boldsymbol{\nu }})$ as compared to ${\boldsymbol{\nu }}$. This means that the state ${\boldsymbol{\nu }}$ will be encoded in $n\leqslant N$ qubits, since each digit saved corresponds to a qubit eliminated. As suggested by Bravyi et al [31], qubit savings can be achieved under the consideration of non-square, invertible matrices A. However, we will see below that using transformations based on nonlinear encodings and decodings ${\boldsymbol{d}}$ (the inverse transform defined by A⁻¹ before), we can eliminate a number of qubits that scales with the system size. For linear codes on the other hand, we find a mere constant saving.

In the following, we will present three types of codes that save qubits by exploiting particle number conservation symmetry, and possibly the conservation of the total spin polarization. Particle-number conserving Hamiltonians are highly relevant for quantum chemistry and problems posed from first principles. We therefore set out to find codes in which ${\boldsymbol{\nu }}\in { \mathcal V }$ have a constant Hamming weight ${{\rm{w}}}_{{\rm{H}}}({\boldsymbol{\nu }})=K$. Since the Hamming weight is defined as ${{\rm{w}}}_{{\rm{H}}}({\boldsymbol{\nu }})={\sum }_{m}{\nu }_{m}$, it yields the total occupation number for the vectors ${\boldsymbol{\nu }}$. In order to simulate systems with a fixed particle number, we are thus interested to find codes that implement code words of constant Hamming weight. Note that the fixed Hamming weight K does not necessarily need to coincide with the total particle number M. A code with the latter property might also be interesting for systems with additional symmetries. Most importantly, we have not taken into account the spin-multiplicity yet. As the particles in our system are fermions, every spatial site will typically have an even number of spin configurations associated with it. Orbitals with the same spin configurations naturally denote subsets of the total amount of orbitals, much like the suits in a card deck. An absence of magnetic terms as well as spin–orbit interactions leaves the Hamiltonian to conserve the number of particles inside all those suits. Consequently, we can append several constant-weight codes to each other. Each of those subcodes encodes thereby the orbitals inside one suit. In electronic system with only Coulomb interactions for instance, we can use two subcodes (${{\boldsymbol{e}}}^{\diamond }$, ${{\boldsymbol{d}}}^{\diamond }$) and (${{\boldsymbol{e}}}^{\spadesuit}$, ${{\boldsymbol{d}}}^{\spadesuit}$), to encode all spin-up, and spin-down orbitals, respectively. The global code (${\boldsymbol{e}},{\boldsymbol{d}}$), encoding the entire system, is obtained by appending the subcode functions e.g. ${\boldsymbol{d}}({{\boldsymbol{\omega }}}^{{\bf{1}}}\oplus {{\boldsymbol{\omega }}}^{{\bf{2}}})={{\boldsymbol{d}}}^{\diamond }({{\boldsymbol{\omega }}}^{{\bf{1}}})\oplus {{\boldsymbol{d}}}^{\spadesuit}({{\boldsymbol{\omega }}}^{{\bf{2}}}).$ Appending codes like this will help us to achieve higher savings at a lower gate cost.

The codes that we now introduce (see also again table 1), fulfill the task of encoding only constant-weight words differently well. The larger ${ \mathcal V }$, the less qubits will be eliminated, but we expect the resulting gate sequences to be more simple. Although not just words of that weight are encoded, we treat K as a parameter—the targeted weight.

3.1.1. Checksum codes

A slim, constant amount of qubits can be saved with the following n = N − 1, affine linear codes. Checksum codes encode all the words with either even or odd Hamming weight. As this corresponds to exactly half of the Fock space, one qubit is eliminated. This means we disregard the last component when we encode ${\boldsymbol{\nu }}$ into words with one digit less. The decoding function then adds the missing component depending on the parity of the code words. The code for K odd is defined as

$$\begin{eqnarray}{\boldsymbol{d}}({\boldsymbol{\omega }})=\left[\begin{array}{ccc}1 & & \\ & \ddots & \\ & & 1\\ 1 & \cdots & 1\end{array}\right]{\boldsymbol{\omega }}+\left(\begin{array}{c}0\\ \vdots \\ 0\\ 1\end{array}\right)\,\mathrm{mod}\,2,\end{eqnarray} \tag{ 34 }$$

$$\begin{eqnarray}{\boldsymbol{e}}({\boldsymbol{\nu }})=\left[\begin{array}{cccc}1 & & & 0\\ & \ddots & & \vdots \\ & & 1 & 0\end{array}\right]{\boldsymbol{\nu }}\,\mathrm{mod}\,2.\end{eqnarray} \tag{ 35 }$$

In the even-K version, the affine vector ${{\boldsymbol{u}}}_{{\boldsymbol{N}}}$, added in the decoding, is removed. Since encoding and decoding function are both at most affine linear, the extracted operators will all be Pauli strings, with at most a minus sign. The advantage of the checksum codes is that they do not depend on K. They can be used even in cases of smaller saving opportunities, like $K\approx N/2$. We can employ these codes even for Hamiltonians that conserve only the Fermion parity. This makes them important for effective descriptions of superconductors [34].

3.1.2. Codes with binary addressing

We present a concept for heavily nonlinear codes for large qubit savings, $n=\lceil \mathrm{log}({N}^{K}/K!)\rceil$, [28]. In order to conserve the maximum amount of qubits possible, we choose to encode particle coordinates as binary numbers in ${\boldsymbol{\omega }}$. To keep it simple, we here consider the example of weight-one binary addressing codes, and refer the reader to appendix D for K > 1. In K = 1, we recognize the qubit savings to be exponential, so consider N = 2ⁿ. Encoding and decoding functions are defined by means of the binary enumerator, $\mathrm{bin}\,:{{\mathbb{Z}}}_{2}^{\otimes n}\to {\mathbb{Z}}$, with $\mathrm{bin}({\boldsymbol{\omega }})={\sum }_{j=1}^{n}{2}^{j-1}{\omega }_{j}$

$$\begin{eqnarray}&&{d}_{j}({\boldsymbol{\omega }})=\displaystyle \prod _{i=1}^{n}({\omega }_{i}+1+{q}_{i}^{\,j})\ \mathrm{mod}\ 2,\end{eqnarray} \tag{ 36 }$$

$$\begin{eqnarray}&&{\boldsymbol{e}}({\boldsymbol{\nu }})=[{{\boldsymbol{q}}}^{{\bf{1}}}| {{\boldsymbol{q}}}^{{\bf{2}}}| \cdots | {{\boldsymbol{q}}}^{{}^{{{\bf{2}}}^{{\boldsymbol{n}}}}}]{\boldsymbol{\nu }}\ \ \mathrm{mod}\ 2,\end{eqnarray} \tag{ 37 }$$

where ${{\boldsymbol{q}}}^{{\boldsymbol{j}}}\in {{\mathbb{Z}}}_{2}^{\otimes n}$ is implicitly defined by $\mathrm{bin}({{\boldsymbol{q}}}^{{\boldsymbol{j}}})+1=j$. An input ${\boldsymbol{\omega }}$ will by construction render only the jth component of (36) non-zero, when ${{\boldsymbol{q}}}^{{\boldsymbol{j}}}={\boldsymbol{\omega }}$ ⁵ .

The exponential qubit saving comes at a high cost: the product over each component of ${\boldsymbol{\omega }}$ implies multi-controlled gates on the entire register. This is likely to cause connectivity problems. Note that decomposing the controlled gates will in general be practically prohibited by the sheer amount of resulting terms. On top of those drawbacks, we also expect the encoding function to be nonlinear for K > 1.

3.1.3. Segment codes

We introduce a type of scaleable $n=\lceil N/\left(1+\tfrac{1}{2K}\right)\rceil$ codes to eliminate a linear amount of qubits. The idea of segment codes is to cut the vectors ${\boldsymbol{\nu }}$ into smaller, constant-size vectors ${\hat{{\boldsymbol{\nu }}}}^{{\boldsymbol{i}}}\in {{\mathbb{Z}}}_{2}^{\otimes \hat{N}}$, such that ${\boldsymbol{\nu }}={\bigoplus }_{i}{\hat{{\boldsymbol{\nu }}}}^{{\boldsymbol{i}}}$. Each such segment ${\hat{{\boldsymbol{\nu }}}}^{{\boldsymbol{i}}}$ is encoded by a subcode. Although we have introduced the concept already, this segmentation is independent from our treatment of spin 'suits'. In order to construct a weight K global code, we append several instances of the same subcode. Each of these subcodes codes is defined on $\hat{n}$ qubits, encoding $\hat{N}=\hat{n}+1$ orbitals. We deliberately have chosen to only save one qubit per segment in order to keep the segment size $\hat{N}(K)$ small.

We now turn our attention to the construction of these segment codes. As shown in appendix E, the segment sizes can be set to $\hat{n}=2K$ and $\hat{N}=2K+1$. As the global code is supposed to encode all ${\boldsymbol{\nu }}\in {{\mathbb{Z}}}_{2}^{\otimes N}$ with Hamming weight K, each segment must encode all vectors from Hamming weight zero up to weight K. In this way, we guarantee that the encoded space contains the relevant, weight K subspace. This construction follows from the idea that each block contains equal or less than K particles, but might as well be empty. For each segment, the following de- and encoding functions are found for $\hat{{\boldsymbol{\omega }}}\in {{\mathbb{Z}}}_{2}^{\otimes \hat{n}},\hat{{\boldsymbol{\nu }}}\in {{\mathbb{Z}}}_{2}^{\otimes \hat{N}}$:

$$\begin{eqnarray}\hat{{\boldsymbol{d}}}(\hat{{\boldsymbol{\omega }}})=\left[\begin{array}{ccc}1 & & \\ & \ddots & \\ & & 1\\ 0 & ... & 0\end{array}\right]\hat{{\boldsymbol{\omega }}}+f(\hat{{\boldsymbol{\omega }}})\left(\begin{array}{c}1\\ \vdots \\ \vdots \\ 1\end{array}\right)\ \mathrm{mod}\ 2,\end{eqnarray} \tag{ 38 }$$

$$\begin{eqnarray}\hat{{\boldsymbol{e}}}(\hat{{\boldsymbol{\nu }}})=\left[\begin{array}{cccc}1 & & & 1\\ & \ddots & & \vdots \\ & & 1 & 1\end{array}\right]\hat{{\boldsymbol{\nu }}}\,\mathrm{mod}\,2,\end{eqnarray} \tag{ 39 }$$

where $f\,:{{\mathbb{Z}}}_{2}^{\otimes \hat{n}}\to {{\mathbb{Z}}}_{2}$ is a binary switch. The switch is the source of nonlinearity in these codes. On an input $\hat{{\boldsymbol{\omega }}}$ with ${{\rm{w}}}_{{\rm{H}}}(\hat{{\boldsymbol{\omega }}})\gt K$, it yields one, and zero otherwise.

There is just one problem: segment codes are not suitable for particle-number conserving Hamiltonians, according to the definition of the basis ${ \mathcal B }$, that we would have for segment codes. The reason for this is that we have not encoded all states with ${{\rm{w}}}_{{\rm{H}}}({\boldsymbol{\nu }})\gt K$. In this way, Hamiltonian terms ${\hat{h}}_{{\boldsymbol{ab}}}$ that exchange occupation numbers between two segments, can map into unencoded space. We can, however, adjust these terms, such that they only act non-destructively on states with at most K particles between the involved segment. This does not change the model, but aligns the Hamiltonian with the necessary condition that we have on ${ \mathcal B },{\hat{h}}_{{\boldsymbol{a}}{\boldsymbol{b}}}\,:\mathrm{span}({ \mathcal B })\,\to \mathrm{span}({ \mathcal B })$. This is discussed in detail appendix E, where we also provide an explicit description of the binary switch mentioned earlier.

Using segment codes, the operator transforms will have multi-controlled gates as well: the binary switch is nonlinear. However, gates are controlled on at most an entire segment, which means there is no gate that acts on more than $2K$ qubits. This an improvement in gate locality, as compared to binary addressing codes.

In this subsection, we will demonstrate the Hamiltonian transformation on a simple problem. Choosing a standard example, we draw comparison with other methods for qubit reduction. As one of the simplest problems, the minimal electronic structure of the hydrogen molecule has been studied extensively for quantum simulation [3, 4] already. We describe the system as two electrons on 2 spatial sites. Because of the spin-multiplicity, we require 4 qubits to simulate the Hamiltonian in conventional ways. Using the particle conservation symmetry of the Hamiltonian, this number can be reduced. The Hamiltonian also lacks terms that mix spin-up and -down states, with the total spin polarization known to be zero. Taking into account these symmetries, one finds a total of 4 fermionic basis states: ${ \mathcal V }=\{(0,1,0,1),(0,1,1,0),(1,0,0,1),(1,0,1,0)\}$. These can be encoded into two qubits by appending two instances of a (N = 2, n = 1, K = 1)-code. The global code is defined as :

$$\begin{eqnarray}{\boldsymbol{d}}({\boldsymbol{\omega }})=\left[\begin{array}{cc}1 & \\ 1 & \\ & 1\\ & 1\end{array}\right]{\boldsymbol{\omega }}+\left(\begin{array}{c}1\\ 0\\ 1\\ 0\end{array}\right)\ \mathrm{mod}\ 2,\end{eqnarray} \tag{ 40 }$$

$$\begin{eqnarray}{\boldsymbol{e}}({\boldsymbol{\nu }})=\left[\begin{array}{cccc}0 & 1 & 0 & 0\\ 0 & 0 & 0 & 1\end{array}\right]{\boldsymbol{\nu }}\,\ \mathrm{mod}\ 2.\end{eqnarray} \tag{ 41 }$$

The physical Hamiltonian

$$\begin{eqnarray}H & = & -{h}_{11}({c}_{1}^{\dagger }{c}_{1}^{\ }+{c}_{3}^{\dagger }{c}_{3}^{\ })-{h}_{22}({c}_{2}^{\dagger }{c}_{2}^{\ }+{c}_{4}^{\dagger }{c}_{4}^{\ })\\ & & +{h}_{1331}\ {c}_{1}^{\dagger }{c}_{3}^{\dagger }{c}_{3}^{\ }{c}_{1}^{\ }+{h}_{2442}\ {c}_{2}^{\dagger }{c}_{4}^{\dagger }{c}_{4}^{\ }{c}_{2}^{\ }\\ & & +{h}_{1221}({c}_{1}^{\dagger }{c}_{4}^{\dagger }{c}_{4}^{\ }{c}_{1}^{\ }+{c}_{3}^{\dagger }{c}_{2}^{\dagger }{c}_{2}^{\ }{c}_{3}^{\ })\\ & & +({h}_{1221}-{h}_{1212})({c}_{1}^{\dagger }{c}_{2}^{\dagger }{c}_{2}^{\ }{c}_{1}^{\ }+{c}_{3}^{\dagger }{c}_{4}^{\dagger }{c}_{4}^{\ }{c}_{3}^{\ })\\ & & +{h}_{1212}({c}_{1}^{\dagger }{c}_{4}^{\dagger }{c}_{3}^{\ }{c}_{2}^{\ }+{c}_{2}^{\dagger }{c}_{3}^{\dagger }{c}_{4}^{\ }{c}_{1}^{\ })\\ & & +{h}_{1212}({c}_{1}^{\dagger }{c}_{3}^{\dagger }{c}_{4}^{\ }{c}_{2}^{\ }+{c}_{2}^{\dagger }{c}_{4}^{\dagger }{c}_{3}^{\ }{c}_{1}^{\ }),\end{eqnarray} \tag{ 42 }$$

is transformed into the qubit Hamiltonian

$$\begin{eqnarray}&&{g}_{1}\ {\mathbb{I}}+{g}_{2}\ {X}_{1}\otimes {X}_{2}+{g}_{3}\ {Z}_{1}+{g}_{4}\ {Z}_{2}+{g}_{5}\ {Z}_{1}\otimes {Z}_{2}.\end{eqnarray} \tag{ 43 }$$

The real coefficients g_i are formed by the coefficients h_ijkl of (42). After performing the transformation, we find

$$\begin{eqnarray}&&{g}_{1}=-{h}_{11}-{h}_{22}+\displaystyle \frac{1}{2}{h}_{1221}+\displaystyle \frac{1}{4}{h}_{1331}+\displaystyle \frac{1}{4}{h}_{2442},\end{eqnarray} \tag{ 44 }$$

$$\begin{eqnarray}&&{g}_{2}={h}_{1212},\end{eqnarray} \tag{ 45 }$$

$$\begin{eqnarray}&&{g}_{3}={g}_{4}=\displaystyle \frac{1}{2}{h}_{11}-\displaystyle \frac{1}{2}{h}_{22}+-\displaystyle \frac{1}{4}{h}_{1331}+\displaystyle \frac{1}{4}{h}_{2442},\end{eqnarray} \tag{ 46 }$$

$$\begin{eqnarray}&&{g}_{5}=-\displaystyle \frac{1}{2}{h}_{1221}+\displaystyle \frac{1}{4}{h}_{1331}+\displaystyle \frac{1}{4}{h}_{2442}.\end{eqnarray} \tag{ 47 }$$

In previous works, conventional transforms have been applied to that problem Hamiltonian. Afterwards, the resulting 4-qubit-Hamiltonian has been reduced by hand in some way. In [11], the actions on two qubits are replaced with their expectation values after inspection of the Hamiltonian. In [30], on the other hand, the Hamiltonian is reduced to two qubits in a systematic fashion. Finally, the case is revisited in [31], where the problem is reduced below the combinatorical limit to one qubit. The latter two attempts have used Jordan–Wigner, the former the Bravyi–Kitaev transform first.

We present another example to illustrate the trade-off between qubit number and gate cost as well as circuit depth. For that purpose, we consider a simple toy Hamiltonian and demonstrate that a reduction of qubit requirements is theoretically possible. Although we do not want to claim that this scenario is realistic, we present a simple cost model with it, that hints the potential up-scaling of circuit depth and simulation cost, as the number of qubits decreases: we therefore consider the total sum of Pauli lengths of every term, which gives us an idea of the number of two-qubit gates required, and the number of Hamiltonian terms, as we decompose controlled gates (28), which should give us an idea of possible T-gate requirements and simulation depth. Let us start now to describe the model. We consider a small lattice with periodic boundary conditions in the lateral direction. The system shall contain 10 spatial sites, doubled by the spin-multiplicity. The problem Hamiltonian is

$$\begin{eqnarray}H & = & -t\displaystyle \sum _{\langle i,j\rangle \in E}({c}_{i}^{\dagger }{c}_{j}^{\ }+{c}_{j}^{\dagger }{c}_{i}^{\ })\\ & & +U\displaystyle \sum _{j=1}^{10}{c}_{j}^{\dagger }{c}_{j}^{\ }\,{c}_{10+j}^{\dagger }{c}_{10+j}^{\ },\end{eqnarray} \tag{ 48 }$$

with its real coefficients t, U. It exhibits hopping terms along the edges E of the graph in figure 1. The sketch on the left of this figure shows the connection graph of the first 10 orbitals. The other 10 orbitals are connected in the same fashion, and each such site is interacting with its counterpart from the other graph. We aim to populate this model with four Fermions, where the total spin polarization is zero. Two conventional transforms and two transforms based on our codes are compared by the amount of qubits necessary, as well as the size of the transformed Hamiltonian. Note that besides eigenenergies, one might also be interested in obtaining the values of correlation functions, e.g. $\langle {c}_{i}^{\dagger }{c}_{j}^{}\rangle$, which is done by measuring (qubit) operators obtained with the transform (48). The only difference is that if a correlator maps into unencoded space, it is to be set to zero. As benchmarks, we decompose controlled gates and count the number of resulting Pauli strings. The sum of their total weight constitutes the gate count. Having these two disconnected graphs is an invitation to us to append two codes acting on sites 1–10 and 11–20 respectively. for this example, we consider the following codes:

• 1.  
  Jordan–Wigner and Bravyi–Kitaev transform: for comparison, we employ these conventional transforms on our system, with which we do not save qubits. The resulting terms are best obtained by the transforming every Fermion operator in (48) by (13), where the flip, parity and update sets, F(j), P(j), U(j) are determined by the choice of matrices A and A⁻¹, which are binary tree matrices in the the case of the Bravyi-Kitev transform, and identity matrices for the Jordan–Wigner transform.
• 2.  
  Checksum code ⊕ checksum code: knowing that the particle number is conserved, and that spin cannot be flipped, we are free to save 2 qubits in constraining the parity of both, spin-up and -down particles, alike. This is done in appending two (N = 10) checksum codes, where each that acts on only spin-up (spin-down) orbitals, so indices 1–10 (11–20). The code resulting from appending two even checksum codes is linear, and encoding and decoding function feature the matrices

  $$\begin{eqnarray}\left[\begin{array}{cccccccc}1 & & & 0 & & & & \\ & \ddots & & \vdots & & & & \\ & & 1 & 0 & & & & \\ & & & & 1 & & & 0\\ & & & & & \ddots & & \vdots \\ & & & & & & 1 & 0\end{array}\right],\ \left[\begin{array}{cccccc}1 & & & & & \\ & \ddots & & & & \\ & & 1 & & & \\ 1 & \cdots & 1 & & & \\ & & & 1 & & \\ & & & & \ddots & \\ & & & & & 1\\ & & & 1 & \cdots & 1\end{array}\right].\end{eqnarray} \tag{ 49 }$$

  However, as not the entire Fock space is encoded, we need to perform the operator transform according to (31), where the update operator is defined by (33), where A refers here to the first matrix.
• 3.  
  Segment code ⊕ segment code: knowing the particle number in one 'spin suite' to be 2, we can for both, spin-up and -down orbitals, append two K = 2 segment codes to each other. This equals a total of 4 segment codes, saving 4 qubits. The resulting global code $({\boldsymbol{e}},{\boldsymbol{d}})$ is defined by

  $$\begin{eqnarray}&&{\boldsymbol{e}}\left(\underset{i=1}{\overset{4}{\displaystyle \bigoplus }}{\hat{{\boldsymbol{\nu }}}}^{{\boldsymbol{i}}}\right)=\underset{i=1}{\overset{4}{\displaystyle \bigoplus }}\hat{{\boldsymbol{e}}}({\hat{{\boldsymbol{\nu }}}}^{{\boldsymbol{i}}}),\end{eqnarray} \tag{ 50 }$$

  $$\begin{eqnarray}{\boldsymbol{d}}({\boldsymbol{\omega }})=\left(\left[\begin{array}{cccc}1 & & & \\ & 1 & & \\ & & 1 & \\ & & & 1\end{array}\right]\otimes \left[\begin{array}{cccc}1 & & & 1\\ & \ddots & & \vdots \\ & & 1 & 1\end{array}\right]\right){\boldsymbol{\omega }}\ \mathrm{mod}\ 2,\end{eqnarray} \tag{ 51 }$$

  where $\hat{{\boldsymbol{e}}}$ are the encodings of the subcodes (39), and ${\hat{{\boldsymbol{\nu }}}}^{{\boldsymbol{i}}}$ are occupations on the segements of the total orbital vector ${\boldsymbol{\nu }}={\bigoplus }_{i}{\hat{{\boldsymbol{\nu }}}}^{{\boldsymbol{i}}}$. These segments are formed as suggested by the right-hand side of figure 1. For details on the decoding functions and Hamiltonian adjustments, please consider appendix E. The Hamiltonian transform is in the end carried out again by (31) and (33).
• 4.  
  Checksum code $\oplus$ segment code: a compromise between the above, in which the spin-up orbitals are transformed via a checksum code, and the spin-down orbitals are transformed via two segment codes. The global code used for the Hamiltonian transformation is the appendage of an (even-weight, N = 10) checksum code and two (K = 2) segment codes, including Hamiltonian adjustments on the spin-down orbitals.

Zoom In Zoom Out Reset image size

Note that from the combinatorial perspective, we could encode the problem with 11 qubits. However, if we append two K = 2 binary addressing codes to each other, the resulting Hamiltonian is on 14 qubits already. The problem is that the resulting Hamiltonian for this case cannot be expressed with decomposed controlled gates due to the high number of resulting terms.

Indeed, table 2 suggests that decomposing the controlling gates might easily lead to very large Hamiltonians with a multitude of very small terms. The gate decomposition appears therefore undesirable. We in general recommend to rather decompose large controlled gates as shown in [35]. However, one also notices that an elimination of up to two qubits comes at a low cost: the amount of gates is not higher than in the Bravyi–Kitaev transform. As soon as we employ segment codes on the other hand, the Hamiltonian complexity rises with the amount of qubits eliminated.

In order to verify that the gate sequences (31) are mimicking the Hamiltonian dynamics adequately, we verify that the resulting terms have the same effect on the Hamiltonian basis. This is done on the level of second quantization with respect to the notation (18): no transition into a qubit system is made. This step serves the sole purpose to quantify the effect of the Hamiltonian terms on the states. To that end, we begin by studying the effect of a singular fermionic operator ${c}_{j}^{(\dagger )}$ on a pure state, before considering an entire term ${\hat{h}}_{{\boldsymbol{ab}}}$ on a state in ${ \mathcal B }$. As a preliminary, we note that (3)–(6) follow directly from (2), when considering that

$$\begin{eqnarray}&&{c}_{j}^{\ }{c}_{j}^{\ }={c}_{j}^{\dagger }{c}_{j}^{\dagger }={c}_{j}^{\ }| {\rm{\Theta }}\rangle =0.\end{eqnarray} \tag{ B1 }$$

The relations (3)–(6) indicate how singular operators act on pure states in general. We now become more specific and apply these rules to a state $({\prod }_{i}{({c}_{i}^{\dagger })}^{{\nu }_{i}})| {\rm{\Theta }}\rangle$, that is not necessarily in ${ \mathcal B }$, but is described by an occupation vector ${\boldsymbol{\nu }}\in {{\mathbb{Z}}}_{2}^{\otimes N}$. The effect of an annihilation operator on such a state is considered first:

$$\begin{eqnarray}&&{c}_{j}^{\,}\left[\displaystyle \prod _{i=1}^{N}{({c}_{i}^{\dagger })}^{{\nu }_{i}}\right]| {\rm{\Theta }}\rangle =\left[\displaystyle \prod _{i\lt j}{(-{c}_{i}^{\dagger })}^{{\nu }_{i}}\right]\ \ {c}_{j}^{\,}{({c}_{j}^{\dagger })}^{{\nu }_{j}}\ \ \left[\displaystyle \prod _{k\gt j}{({c}_{k}^{\dagger })}^{{\nu }_{k}}\right]| {\rm{\Theta }}\rangle \ \end{eqnarray} \tag{ B2 }$$

$$\begin{eqnarray}&&=\,\left[\displaystyle \prod _{i\lt j}{(-{c}_{i}^{\dagger })}^{{\nu }_{i}}\right]\ \ \displaystyle \frac{1}{2}[1-{(-1)}^{{\nu }_{j}}]\ \ \left[\displaystyle \prod _{k\gt j}{({c}_{k}^{\dagger })}^{{\nu }_{k}}\right]| {\rm{\Theta }}\rangle \ \end{eqnarray} \tag{ B3 }$$

$$\begin{eqnarray}&&=\,\left[\displaystyle \prod _{i\lt j}{(-1)}^{{\nu }_{i}}\right]\ \ \displaystyle \frac{1}{2}[1-{(-1)}^{{\nu }_{j}}]\ \ \left[\displaystyle \prod _{k=1}^{N}{({c}_{k}^{\dagger })}^{{\nu }_{k}+{\delta }_{{jk}}\mathrm{mod}2}\right]| {\rm{\Theta }}\rangle \ .\end{eqnarray} \tag{ B4 }$$

A short explanation on what has happened: in (B2), c_j has anticommuted with all creation operator ${c}_{i}^{\dagger }$ that have indexes i < j. Depending on the component ν_j, a creation operator ${c}_{j}^{\dagger }$ might now be to the right of the annihilator c_j. If the creation operator is not encountered, we may continue the anticommutations of c_j until it meets the vacuum and annihilates the state by ${c}_{j}| {\rm{\Theta }}\rangle =0$. Using the anticommutation relations (2), we therefore replace ${c}_{j}^{\,}{({c}_{j}^{\dagger })}^{{\nu }_{j}}$ with $\tfrac{1}{2}[1-{(-1)}^{{\nu }_{j}}]$ when going from (B2) to (B3). Finally, the terms are rearranged in (B4): conditional sign changes of the anticommutations are factored out of the new state with an occupation that is now described by the binary vector $({\boldsymbol{\nu }}+{{\boldsymbol{u}}}_{{\boldsymbol{j}}}\ \mathrm{mod}\ 2)$ rather than ${\boldsymbol{\nu }}$. When considering to apply a creation operator ${c}_{j}^{\dagger }$ on the former state, the result is similar. Alone at step (B3), we have to replace ${c}_{j}^{\dagger }{({c}_{j}^{\dagger })}^{{\nu }_{j}}$ by $\tfrac{1}{2}[1+{(-1)}^{{\nu }_{j}}]$ instead, as now the case of appearance of the creation operator leads to annihilation: ${c}_{j}^{\dagger }{c}_{j}^{\dagger }=0$. We thus find

$$\begin{eqnarray}&&{c}_{j}^{\dagger }\left[\displaystyle \prod _{i=1}^{N}{({c}_{i}^{\dagger })}^{{\nu }_{j}}\right]| {\rm{\Theta }}\rangle =\left[\displaystyle \prod _{i\lt j}{(-1)}^{{\nu }_{i}}\right]\ \ \displaystyle \frac{1}{2}[1+{(-1)}^{{\nu }_{j}}]\ \ \left[\displaystyle \prod _{k=1}^{N}{({c}_{k}^{\dagger })}^{{\nu }_{k}+{\delta }_{{jk}}\mathrm{mod}2}\right]| {\rm{\Theta }}\rangle .\end{eqnarray} \tag{ B5 }$$

We now turn our attention to the actual goal, effect of a Hamiltonian term from (11) on a state in ${ \mathcal B }$ (this means its occupation vector ${\boldsymbol{\nu }}$ is in ${ \mathcal V }$). We therefore consider a generic operator sequence ${\prod }_{i=1}^{l}{({c}_{{a}_{i}}^{\dagger })}^{{b}_{i}}{({c}_{{a}_{i}}^{})}^{1+{b}_{i}\mathrm{mod}2}$, parametrized by some N-ary vector ${\boldsymbol{a}}\in {[N]}^{\otimes l}$ and a binary vector ${\boldsymbol{b}}\in {{\mathbb{Z}}}_{2}^{\otimes l}$, for some length l. With (B4) and (B5), we now have the means to consider the effect such a sequence of annihilation and creation operators. The two relations will be repeatedly utilized in an inductive procedure, as every single operator ${({c}_{{a}_{i}}^{\dagger })}^{{b}_{i}}{({c}_{{a}_{i}}^{})}^{1+{b}_{i}\mathrm{mod}2}$ of ${\prod }_{i=1}^{l}{({c}_{{a}_{i}}^{\dagger })}^{{b}_{i}}{({c}_{{a}_{i}}^{})}^{1+{b}_{i}\mathrm{mod}2}$ will act on a basis state, one after another. The state's occupation is updated after every such operation. For convenience, we define:

$$\begin{eqnarray}&&{{\boldsymbol{\nu }}}^{({\boldsymbol{i}})}\in {{\mathbb{Z}}}_{2}^{\otimes N}\quad | \ i\in \{0,\,...,\,l\},\end{eqnarray} \tag{ B6 }$$

$$\begin{eqnarray}&&{{\boldsymbol{\nu }}}^{({\boldsymbol{l}})}={\boldsymbol{\nu }}\in { \mathcal V },\end{eqnarray} \tag{ B7 }$$

$$\begin{eqnarray}&&{{\boldsymbol{\nu }}}^{({\boldsymbol{i}}-{\bf{1}})}={{\boldsymbol{\nu }}}^{({\boldsymbol{i}})}+{{\boldsymbol{u}}}_{{{\boldsymbol{a}}}_{{\boldsymbol{i}}}}\ \ \mathrm{mod}\ 2.\end{eqnarray} \tag{ B8 }$$

Now, the procedure starts:

$$\begin{eqnarray}&&\left[\,\displaystyle \prod _{i=1}^{l}{({c}_{{a}_{i}}^{\dagger })}^{{b}_{i}}{({c}_{{a}_{i}}^{})}^{1+{b}_{i}\mathrm{mod}2}\right]\ \left[\,\displaystyle \prod _{k=1}^{N}{({c}_{k}^{\dagger })}^{{\nu }_{k}}\right]| {\rm{\Theta }}\rangle \end{eqnarray} \tag{ B9 }$$

$$\begin{eqnarray}&&=\,\left[\,\displaystyle \prod _{i=1}^{l-1}{({c}_{{a}_{i}}^{\dagger })}^{{b}_{i}}{({c}_{{a}_{i}}^{})}^{1+{b}_{i}\mathrm{mod}2}\right]\ \displaystyle \frac{1}{2}[1-{(-1)}^{{b}_{l}}{(-1)}^{{\nu }_{{a}_{l}}}]{(-1)}^{{\displaystyle \sum }_{j\lt {a}_{l}}{\nu }_{j}}\left[\displaystyle \prod _{k=1}^{N}{({c}_{k}^{\dagger })}^{{\nu }_{k}+{\delta }_{{a}_{l}k}\mathrm{mod}2}\right]| {\rm{\Theta }}\rangle \end{eqnarray} \tag{ B10 }$$

$$\begin{eqnarray}&&=\,\left[\displaystyle \frac{1}{2}[1-{(-1)}^{{b}_{l}}{(-1)}^{{\nu }_{{a}_{l}}^{(l)}}]{(-1)}^{{\displaystyle \sum }_{j\lt {a}_{l}}{\nu }_{j}^{(l)}}\right]\ \left[\,\displaystyle \prod _{i=1}^{l-1}{({c}_{{a}_{i}}^{\dagger })}^{{b}_{i}}{({c}_{{a}_{i}}^{})}^{1+{b}_{i}\mathrm{mod}2}\right]\ \left[\displaystyle \prod _{k=1}^{N}{({c}_{k}^{\dagger })}^{{\nu }_{k}^{(l-1)}}\right]| {\rm{\Theta }}\rangle \end{eqnarray} \tag{ B11 }$$

$$\begin{eqnarray}&&=\,\left[\,\displaystyle \prod _{i=1}^{l}\mathop{\underbrace{\displaystyle \frac{1}{2}[1-{(-1)}^{{b}_{i}}{(-1)}^{{\nu }_{{a}_{i}}^{(i)}}]}}\limits_{{\rm{projector}}\,{\rm{eigenvalues}}}\mathop{\underbrace{{(-1)}^{{\displaystyle \sum }_{j\lt {a}_{i}}{\nu }_{j}^{(i)}}}}\limits_{{\rm{parity}}\,{\rm{signs}}}\right.]\ \mathop{\underbrace{\left[\,\displaystyle \prod _{k=1}^{N}{({c}_{k}^{\dagger })}^{{\nu }_{k}^{(0)}}\right]| {\rm{\Theta }}\rangle }}\limits_{{\rm{updated}}\,{\rm{state}}}.\end{eqnarray} \tag{ B12 }$$

We again explain what has happened: first, the rightmost operator, which is either ${c}_{{a}_{l}}^{\ }$ or ${c}_{{a}_{l}}^{\dagger }$ depending on the parameter b_l, acts on the state according to either (B4) or (B5). We therefore combine the two relations for the absorption of this operator ${({c}_{{a}_{l}}^{\dagger })}^{{b}_{l}}{({c}_{{a}_{l}}^{})}^{1+{b}_{l}\mathrm{mod}2}$ in (B10). In the same fashion, all the remaining operators of the sequence are one-after-another absorbed into the state. The new state is described by the vector ${{\boldsymbol{\nu }}}^{({\boldsymbol{l}}-{\bf{1}})}$ after the update. And the cycle begins anew with ${({c}_{{a}_{l-1}}^{\dagger })}^{{b}_{l-1}}{({c}_{{a}_{l-1}}^{})}^{1+{b}_{l-1}\mathrm{mod}2}$. From (B11) on, we use the notations (B6)–(B8) to describe partially updated occupations. By the end of this iteration, the occupation of the state is changed to $\,{{\boldsymbol{\nu }}}^{({\bf{0}})}={\boldsymbol{\nu }}+{\boldsymbol{q}}\ \mathrm{mod}\ 2\$, with the total change $\ {\boldsymbol{q}}={\sum }_{i}{{\boldsymbol{u}}}_{{{\boldsymbol{a}}}_{{\boldsymbol{i}}}}\ \mathrm{mod}\ 2$. Also, the coefficients of (B12) take into account sign changes from anticommutations ('parity signs' in (B12)) and the eigenvalues of the applied projections. In its entirety, (B12) denotes the resulting state, and is the main ingredient for the next step.

We are given the operator transform (31) and the state transform (19). We want to show the that the Fermion system is adequately simulated, which means to show that the effect (B12) is replicated by (31) acting on $| {\boldsymbol{e}}({\boldsymbol{\nu }})\rangle$. This is the goal of the next two steps. We start by evaluating the application of (31) on that state, up to the update operator ${{ \mathcal U }}^{a}$. This means that the operators applied implement two things only: the parity signs of (B12), and the projection onto the correct occupational state. Note that these parity operators and projectors are applied before the update operator in (31):

$$\begin{eqnarray}&&\mathop{\underbrace{{{ \mathcal U }}^{{\boldsymbol{a}}}}}\limits_{{\rm{update}}\,{\rm{operator}}}\mathop{\underbrace{\left(\displaystyle \prod _{v=1}^{l-1}\,\displaystyle \prod _{w=v+1}^{l}{(-1)}^{{\theta }_{{a}_{v}{a}_{w}}}\right)}}\limits_{{\rm{parity}}\,{\rm{operators}}}\displaystyle \prod _{x=1}^{l}\mathop{\underbrace{\displaystyle \frac{1}{2}\left({\mathbb{I}}-\left[\displaystyle \prod _{y=x+1}^{l}{(-1)}^{{\delta }_{{a}_{x}{a}_{y}}}\right]{(-1)}^{{b}_{x}}\ {\mathfrak{X}}[{d}_{{a}_{x}}]\right)}}\limits_{{\rm{projectors}}}\mathop{\underbrace{{\mathfrak{X}}[\,{p}_{{a}_{x}}]}}\limits_{{\rm{parity}}\,{\rm{operators}}}.\end{eqnarray} \tag{ B13 }$$

We now commence our evaluation:

$$\begin{eqnarray}&&{{ \mathcal U }}^{{\boldsymbol{a}}}\left[\left(\displaystyle \prod _{v=1}^{l-1}\,\displaystyle \prod _{w=v+1}^{l}{(-1)}^{{\theta }_{{a}_{v}{a}_{w}}}\right)\displaystyle \prod _{x=1}^{l}\displaystyle \frac{1}{2}\left({\mathbb{I}}-\left[\displaystyle \prod _{y=x+1}^{l}{(-1)}^{{\delta }_{{a}_{x}{a}_{y}}}\right]{(-1)}^{{b}_{x}}\ {\mathfrak{X}}[{d}_{{a}_{x}}]\right){\mathfrak{X}}[\,{p}_{{a}_{x}}]\right]\quad | {\boldsymbol{e}}({\boldsymbol{\nu }})\rangle \end{eqnarray} \tag{ B14 }$$

$$\begin{eqnarray}&&=\ {{ \mathcal U }}^{{\boldsymbol{a}}}\left[\left(\displaystyle \prod _{v=1}^{l-1}\,\displaystyle \prod _{w=v+1}^{l}{(-1)}^{{\theta }_{{a}_{v}{a}_{w}}}\right)\displaystyle \prod _{x=1}^{l}\displaystyle \frac{1}{2}\left(1-\left[\displaystyle \prod _{y=x+1}^{l}{(-1)}^{{\delta }_{{a}_{x}{a}_{y}}}\right]{(-1)}^{{b}_{x}}\ {(-1)}^{{d}_{{a}_{x}}({\boldsymbol{e}}({\boldsymbol{\nu }}))}\right){(-1)}^{{p}_{{a}_{x}}({\boldsymbol{e}}({\boldsymbol{\nu }}))}\right]\quad | {\boldsymbol{e}}({\boldsymbol{\nu }})\rangle \end{eqnarray} \tag{ B15 }$$

$$\begin{eqnarray}&&=\ {{ \mathcal U }}^{{\boldsymbol{a}}}\left[\left(\displaystyle \prod _{v=1}^{l-1}\,\displaystyle \prod _{w=v+1}^{l}{(-1)}^{{\theta }_{{a}_{v}{a}_{w}}}\right)\displaystyle \prod _{x=1}^{l}\displaystyle \frac{1}{2}\left(1-\left[\displaystyle \prod _{y=x+1}^{l}{(-1)}^{{\delta }_{{a}_{x}{a}_{y}}}\right]{(-1)}^{{b}_{x}}\ {(-1)}^{{\nu }_{{a}_{x}}}\right){(-1)}^{{\displaystyle \sum }_{j\lt {a}_{x}}{\nu }_{j}}\right]\quad | {\boldsymbol{e}}({\boldsymbol{\nu }})\rangle \end{eqnarray} \tag{ B16 }$$

$$\begin{eqnarray}&&=\ {{ \mathcal U }}^{{\boldsymbol{a}}}\ \left[\displaystyle \prod _{x=1}^{l}\displaystyle \frac{1}{2}\left(1-{(-1)}^{{b}_{x}}\ {(-1)}^{{\nu }_{{a}_{x}}+{\displaystyle \sum }_{y=x+1}^{l}{\delta }_{{a}_{x}{a}_{y}}}\right){(-1)}^{{\displaystyle \sum }_{j\lt {a}_{x}}{\nu }_{j}+{\displaystyle \sum }_{y=x+1}^{l}{\theta }_{{a}_{x}{a}_{y}}}\right]\quad | {\boldsymbol{e}}({\boldsymbol{\nu }})\rangle \end{eqnarray} \tag{ B17 }$$

$$\begin{eqnarray}&&=\,\left[\displaystyle \prod _{x=1}^{l}\displaystyle \frac{1}{2}(1-{(-1)}^{{b}_{x}}\ {(-1)}^{{\nu }_{{a}_{x}}^{(x)}}){(-1)}^{{\displaystyle \sum }_{j\lt {a}_{x}}{\nu }_{j}^{(x)}}\right]\quad {{ \mathcal U }}^{{\boldsymbol{a}}}\ | {\boldsymbol{e}}({\boldsymbol{\nu }})\rangle .\end{eqnarray} \tag{ B18 }$$

Let us describe what has happened: in (B15), the extraction property (21) is used, and we arrive at (B16) after using the property ${\boldsymbol{d}}({\boldsymbol{e}}({\boldsymbol{\nu }}))={\boldsymbol{\nu }}$ and the definition of the parity function. From there we go to (B17) when we merge the two products and perform rearrangements that make it easy to cast all delta and theta functions into the components of the partially updated occupations ${{\boldsymbol{\nu }}}^{({\boldsymbol{i}})}$, (B18).

Comparing (B18) to (B12), we notice to have successfully mimicked the same sign changes and and projections, as the coefficients in both relations match. Now it is only left to show that the state update is executed correctly. Naively, one would think that we would need to show that

$$\begin{eqnarray}&&{{ \mathcal U }}^{{\boldsymbol{a}}}\ | {\boldsymbol{e}}({\boldsymbol{\nu }})\rangle \hat{=}\left[\,\displaystyle \prod _{k=1}^{N}{({c}_{k}^{\dagger })}^{{\nu }_{k}^{(0)}}\right]| {\rm{\Theta }}\rangle ,\end{eqnarray} \tag{ B19 }$$

but this is too strong a statement. It is in fact sufficient to demand

$$\begin{eqnarray}&&{{ \mathcal U }}^{{\boldsymbol{a}}}| {\boldsymbol{e}}({\boldsymbol{\nu }})\rangle =| {\boldsymbol{e}}({{\boldsymbol{\nu }}}^{({\bf{0}})})\rangle \ =\ | {\boldsymbol{e}}({\boldsymbol{\nu }}+{\boldsymbol{q}}\ \mathrm{mod}\ 2)\rangle .\end{eqnarray} \tag{ B20 }$$

For ${{\boldsymbol{\nu }}}^{({\bf{0}})}\in { \mathcal V }$, (B19) and (B20) is equivalent. However, it might be the case that ${{\boldsymbol{\nu }}}^{({\bf{0}})}\notin { \mathcal V }$, so ${{\boldsymbol{\nu }}}^{({\bf{0}})}$ is not encoded. This mean that (B19) is not fulfilled, since ${\boldsymbol{d}}({\boldsymbol{e}}({{\boldsymbol{\nu }}}^{({\bf{0}})}))\ne {{\boldsymbol{\nu }}}^{({\bf{0}})}$. It is however not necessary to include ${{\boldsymbol{\nu }}}^{({\bf{0}})}$ in the encoding, as for ${{\boldsymbol{\nu }}}^{({\bf{0}})}\notin { \mathcal V }$, the state will vanish anyways: we know from ${\hat{h}}_{{\boldsymbol{ab}}}\,:\mathrm{span}({ \mathcal B })\to \mathrm{span}({ \mathcal B })$, that in this case ${\hat{h}}_{{\boldsymbol{ab}}}$ must act destructively on that basis state, ${\hat{h}}_{{\boldsymbol{ab}}}\,({\prod }_{k}{({c}_{k}^{\dagger })}^{{\nu }_{k}})| {\rm{\Theta }}\rangle =0$. This detail is implemented by the projector part of the transformed sequence (31). These projectors are, as we have just shown, working faithfully like (B12), for the transformed sequence acting on every $| {\boldsymbol{\nu }}\rangle$ with ${\boldsymbol{\nu }}\in { \mathcal V }$. Hence (B20) is a sufficient condition for the updated state. The proof is completed once we have verified that (B20) is satisfied with the update operator defined as in (32). This is done during the next step.

The missing piece of the proof is to check that (32) and (33) fulfill the condition (B20). We start by verifying the condition (B20) for (33), which we have presented as special case of (32) for linear encoding functions: ${\boldsymbol{e}}({\boldsymbol{\nu }}+{{\boldsymbol{\nu }}}^{{\prime} }\ \mathrm{mod}\ 2)={\boldsymbol{e}}({\boldsymbol{\nu }})+{\boldsymbol{e}}({{\boldsymbol{\nu }}}^{{\prime} })\ \mathrm{mod}\ 2$. Using that property, one can in fact derive (33) from (32) directly. We now apply (33) to $| {\boldsymbol{e}}({\boldsymbol{\nu }})\rangle$, but firstly we note that

$$\begin{eqnarray}&&{X}_{j}| {\boldsymbol{\omega }}\rangle =| {\boldsymbol{\omega }}+{{\boldsymbol{u}}}_{{\boldsymbol{j}}}\ \mathrm{mod}\ 2\rangle ,\end{eqnarray} \tag{ B21 }$$

where ${{\boldsymbol{u}}}_{{\boldsymbol{j}}}$ is the jth unit vector of ${{\mathbb{Z}}}_{2}^{\otimes n}$. Using (B21) and the linearity of ${\boldsymbol{e}}$, we find:

$$\begin{eqnarray}&&{{ \mathcal U }}^{{\boldsymbol{a}}}| {\boldsymbol{e}}({\boldsymbol{\nu }})\rangle =\left[\underset{i=1}{\overset{n}{\displaystyle \bigotimes }}{({X}_{i})}^{{\displaystyle \sum }_{j}{A}_{{ij}}{q}_{j}\mathrm{mod}2}\right]| {\boldsymbol{e}}({\boldsymbol{\nu }})\rangle \end{eqnarray} \tag{ B22 }$$

$$\begin{eqnarray}&&=\left[\underset{i=1}{\overset{n}{\displaystyle \bigotimes }}{({X}_{i})}^{{\boldsymbol{e}}({\boldsymbol{q}})}\right]| {\boldsymbol{e}}({\boldsymbol{\nu }})\rangle \end{eqnarray} \tag{ B23 }$$

$$\begin{eqnarray}&&=| {\boldsymbol{e}}({\boldsymbol{\nu }})+{\boldsymbol{e}}({\boldsymbol{q}})\ \mathrm{mod}\ 2\rangle \end{eqnarray} \tag{ B24 }$$

$$\begin{eqnarray}&&=| {\boldsymbol{e}}({\boldsymbol{\nu }}+{\boldsymbol{q}}\ \mathrm{mod}\ 2)\rangle ,\end{eqnarray} \tag{ B25 }$$

which shows (B20) for linear encodings.

We now turn our attention to general encodings and prove the same expression for update operators as defined in (32):

$$\begin{eqnarray}&&{{ \mathcal U }}^{{\boldsymbol{a}}}| {\boldsymbol{e}}({\boldsymbol{\nu }})\rangle =\left(\displaystyle \sum _{{\boldsymbol{t}}\,\in {{\mathbb{Z}}}_{2}^{\otimes n}}\left[\underset{i=1}{\overset{n}{\displaystyle \bigotimes }}{({X}_{i})}^{{t}_{i}}\right]\displaystyle \prod _{j=1}^{n}\displaystyle \frac{1}{2}({\mathbb{I}}+{(-1)}^{{t}_{j}}\ {\mathfrak{X}}[{\varepsilon }_{j}^{\,{\boldsymbol{q}}}])\right)\ | {\boldsymbol{e}}({\boldsymbol{\nu }})\rangle \end{eqnarray} \tag{ B26 }$$

$$\begin{eqnarray}&&=\left(\displaystyle \sum _{{\boldsymbol{t}}\,\in {{\mathbb{Z}}}_{2}^{\otimes n}}\left[\underset{i=1}{\overset{n}{\displaystyle \bigotimes }}{({X}_{i})}^{{t}_{i}}\right]\displaystyle \prod _{j=1}^{n}\mathop{\underbrace{\displaystyle \frac{1}{2}(1+{(-1)}^{{t}_{j}+{\varepsilon }_{j}^{{\boldsymbol{q}}}({\boldsymbol{e}}({\boldsymbol{\nu }}))})}}\limits_{\qquad {\delta }_{{t}_{j}^{}{\varepsilon }_{j}^{{\boldsymbol{q}}}({\boldsymbol{e}}({\boldsymbol{\nu }}))}}\right)| {\boldsymbol{e}}({\boldsymbol{\nu }})\rangle \end{eqnarray} \tag{ B27 }$$

$$\begin{eqnarray}&&=\left(\underset{i=1}{\overset{n}{\displaystyle \bigotimes }}{({X}_{i})}^{{\varepsilon }_{i}^{{\boldsymbol{q}}}({\boldsymbol{e}}({\boldsymbol{\nu }}))}\right)\ | {\boldsymbol{e}}({\boldsymbol{\nu }})\rangle \end{eqnarray} \tag{ B28 }$$

$$\begin{eqnarray}&&=| {\boldsymbol{e}}({\boldsymbol{\nu }})+{{\boldsymbol{\varepsilon }}}^{{\boldsymbol{q}}}({\boldsymbol{e}}({\boldsymbol{\nu }}))\ \mathrm{mod}\ 2\rangle \end{eqnarray} \tag{ B29 }$$

$$\begin{eqnarray}&&=| {\boldsymbol{e}}({\boldsymbol{\nu }})+{\boldsymbol{e}}({\boldsymbol{\nu }})+{\boldsymbol{e}}({\boldsymbol{d}}({\boldsymbol{e}}({\boldsymbol{\nu }}))+{\boldsymbol{q}}\ \mathrm{mod}\ 2)\ \mathrm{mod}\ 2\rangle \end{eqnarray} \tag{ B30 }$$

$$\begin{eqnarray}&&=| {\boldsymbol{e}}({\boldsymbol{\nu }}+{\boldsymbol{q}}\ \mathrm{mod}\ 2)\rangle ,\end{eqnarray} \tag{ B31 }$$

which completes the proof. We swiftly recap what has happened: in (B26), we have plugged the definition of (32) into the left-hand side of (B20). In between this equation and (B27), we have evaluated the expectation values of the extracted operators ${\mathfrak{X}}[{\varepsilon }_{j}^{{\boldsymbol{q}}}]$. From that line to the next, the ${{\mathbb{Z}}}_{2}^{\otimes n}$-sum is collapsed over the condition ${\boldsymbol{t}}={{\boldsymbol{\varepsilon }}}^{{\boldsymbol{q}}}({\boldsymbol{e}}({\boldsymbol{\nu }}))$. We go from (B28) to (B29) by applying (B21). Once we insert the definition (30) into (B29), it becomes obvious that the condition (B20) is fulfilled. Thus, the entire operator transform is now proven.

In this ordering, one can find a recipe for a singular creation or annihilation operator. The strategy is to consider a second code for the odd subspace. As before (${\boldsymbol{e}},{\boldsymbol{d}}$) denotes the code for the even subspace, and now (${{\boldsymbol{e}}}^{{\prime} },{{\boldsymbol{d}}}^{{\prime} }$) is encoding the odd subspace. The idea is that after an odd operator (which in this ordering is an annihilation operator), the state is updated into the odd subspace. With every even operator (which is a creation operator), the state is updated from the odd subspace back into the even one. We find:

$$\begin{eqnarray}&&{c}_{j}^{\dagger }\hat{=}\displaystyle \frac{1}{2}\ {\bar{{ \mathcal U }}}^{(j)}\ ({\mathbb{I}}+{\mathfrak{X}}[{d}_{j}])\ {\mathfrak{X}}[{p}_{j}],\end{eqnarray} \tag{ C2 }$$

$$\begin{eqnarray}&&{c}_{j}^{\ }\hat{=}\displaystyle \frac{1}{2}\ {{ \mathcal U }}^{(j)}\ ({\mathbb{I}}-{\mathfrak{X}}[{d}_{j}^{{\prime} }]){\mathfrak{X}}[{p}_{j}^{{\prime} }].\end{eqnarray} \tag{ C3 }$$

In (C3), ${{ \mathcal U }}^{(j)}$ is defined as in (32), but its counterpart from (C2) is defined by

$$\begin{eqnarray}&&{\bar{{ \mathcal U }}}^{(j)}=\displaystyle \sum _{{\boldsymbol{t}}\,\in {{\mathbb{Z}}}_{2}^{\otimes n}}\left[\underset{i=1}{\overset{n}{\displaystyle \bigotimes }}{({X}_{i})}^{{t}_{i}}\right]\displaystyle \prod _{i=1}^{n}\displaystyle \frac{1}{2}({\mathbb{I}}+{(-1)}^{{t}_{i}}\ {\mathfrak{X}}[{\varepsilon }_{k}^{{\prime} \ {{\boldsymbol{u}}}_{{\boldsymbol{j}}}}]),\end{eqnarray} \tag{ C4 }$$

with the primed functions ${{\boldsymbol{\varepsilon }}}^{{\prime} {\boldsymbol{q}}},{{\boldsymbol{p}}}^{{\prime} }$ defined like (30) and (29), but with (${{\boldsymbol{e}}}^{{\prime} }$, ${{\boldsymbol{d}}}^{{\prime} }$) in place of (${\boldsymbol{e}}$, ${\boldsymbol{d}}$).

This method relies on n qubits being feasible to simulate the odd subspace in. That is, however, not always the case. The basis set of ${{ \mathcal H }}_{N}^{M-1}$ is in general larger than ${{ \mathcal H }}_{N}^{M}$, when M > N/2. In this way, the odd subspace can also be larger and even be infeasible to simulate with just n qubits. As a solution, one changes the ordering into odd operators being creation operators, and even ones being annihilators, like ${c}_{k}^{\ }{c}_{i}^{\dagger }\,{c}_{l}^{\ }{c}_{j}^{\dagger }$. This causes the odd subspace to become ${{ \mathcal H }}_{N}^{(M+1)}$, which has a smaller basis set than ${{ \mathcal H }}_{N}^{M}$. For that case (${\boldsymbol{e}}$, ${\boldsymbol{d}}$) become the code for the odd subspace, and (${{\boldsymbol{e}}}^{{\prime} }$, ${{\boldsymbol{d}}}^{{\prime} }$) will be associated to the even subspace in (C2) and (C3).

The obvious disadvantage is that two codes have to be employed at once. However, the checksum code for instance (section 3.1.1 in the main part), comes in two different flavors already, which can be used as codes for even and odd subspaces, respectively.

The building blocks ${c}_{i}^{\dagger }{c}_{j}^{\ }$ are guaranteed to conserve the particle number, so the even subspace is conserved. As a consequence, one may consider the possibility to transform the operators as the pairs we have rearranged them into. In this way, we still have a certain compartmentalization of (31). Two special cases are to be taken into account: when i > j, an additional minus sign has to be added, as compared to the i < j case. Also, when i = j, all parity operators cancel and the projectors coincide. We find:

$$\begin{eqnarray}{c}_{i}^{\dagger }{c}_{j}\hat{=}\left\{\begin{array}{ll}\tfrac{1}{4}\ {(-1)}^{{\theta }_{{ij}}}\ {{ \mathcal U }}^{(i,j)}\ {\mathfrak{X}}[{p}_{i}]\ {\mathfrak{X}}[{p}_{j}]\ ({\mathbb{I}}+{\mathfrak{X}}[{d}_{i}])({\mathbb{I}}-{\mathfrak{X}}[{d}_{j}]) & i\ne j\\ \tfrac{1}{2}(1-{\mathfrak{X}}[{d}_{j}]) & i=j,\end{array}\right.\end{eqnarray} \tag{ C5 }$$

with ${{ \mathcal U }}^{(i,j)}$ being the l = 2 version of (32), and ${\boldsymbol{p}}$ and ${{\boldsymbol{\varepsilon }}}^{{\boldsymbol{q}}}$ defined as usual by (29) and (30).

As an example, we present the weight-two binary addressing code on N = 2^r orbitals. The integer r will determine the size of the entire qubit system $n=2r-1$, with two registers of size r and r − 1.

With the two registers, a binary vector ${\boldsymbol{\omega }}={\boldsymbol{\alpha }}\oplus {\boldsymbol{\beta }}$ with ${\boldsymbol{\alpha }}\in {{\mathbb{Z}}}_{2}^{\otimes r}$ and ${\boldsymbol{\beta }}\in {{\mathbb{Z}}}_{2}^{\otimes (r-1)}$ is defining the qubit basis. In two-dimensions, the brick turns into a rectangle and the tetrahedron into triangle. The decoding function takes binary addresses of the rectangular ${\boldsymbol{y}}$, and transforms them into coordinates in the triangle ${\boldsymbol{x}}$. The ordering condition implies hereby where to dissect the rectangle: figure D1 may serve as a visual aid, disregarding the excluded cases of ${y}_{1}={y}_{2}$, we find for ${y}_{1}\in [N],{y}_{2}\in [N/2]$ and ${\boldsymbol{x}}\in {[N]}^{\otimes 2}$:

$$\begin{eqnarray}({x}_{1},{x}_{2})=\left\{\begin{array}{ll}({y}_{1},N/2+{y}_{2}) & {\rm{for}}\quad {y}_{1}\lt N/2+{y}_{2}\\ ({y}_{1},N/2-{y}_{2}+1) & {\rm{for}}\quad {y}_{1}\gt N/2+{y}_{2}.\end{array}\right.\end{eqnarray} \tag{ D4 }$$

This decoding is translated into a binary functions as follows: the coordinate y₁ is represented by the binary vector ${\boldsymbol{\alpha }}$ and y₂ by ${\boldsymbol{\beta }}$. For each component defined by the binary vector ${\boldsymbol{b}}\in {{\mathbb{Z}}}_{2}^{\otimes r}$, we have

$$\begin{eqnarray}{d}_{j}({\boldsymbol{\alpha }}\oplus {\boldsymbol{\beta }}) & = & S({\boldsymbol{\alpha }},{\boldsymbol{\beta }})\displaystyle \prod _{i=1}^{r}({\alpha }_{i}+{q}_{i}^{\,j,r}+1)+(1+S({\boldsymbol{\alpha }},{\boldsymbol{\beta }}))(1+T({\boldsymbol{\alpha }},{\boldsymbol{\beta }}))\displaystyle \prod _{i=1}^{r}({\alpha }_{i}+{q}_{i}^{\,j,r})\\ & & +(1+S({\boldsymbol{\alpha }},{\boldsymbol{\beta }}))(1+T({\boldsymbol{\alpha }},{\boldsymbol{\beta }}))\displaystyle \prod _{k=1}^{r-1}({\beta }_{k}+{q}_{k}^{\,j,r})+S({\boldsymbol{\alpha }},{\boldsymbol{\beta }})\displaystyle \prod _{k=1}^{r-1}({\beta }_{k}+{q}_{k}^{\,j,r}+1)\ \ \mathrm{mod}\ 2,\end{eqnarray} \tag{ D5 }$$

with ${{\boldsymbol{q}}}^{{\boldsymbol{j}},{\boldsymbol{r}}}=({q}_{1}^{\,j,r},{q}_{2}^{\,j,r}\,,\,...,\,{q}_{{2}^{r}}^{\,j,r})$ as defined in (D3) and we have employed two binary functions S and $T:({{\mathbb{Z}}}_{2}^{\otimes r},{{\mathbb{Z}}}_{2}^{\otimes (r-1)})\to {{\mathbb{Z}}}_{2}$. Here, S compares the binary numbers to determine if the coordinates are left of the dissection (a black tile in figure D1)

$$\begin{eqnarray}&&S({\boldsymbol{\alpha }},{\boldsymbol{\beta }})={\alpha }_{r}\displaystyle \sum _{j=1}^{r-1}\left[\displaystyle \prod _{r-1\geqslant i\gt j}({\alpha }_{i}+{\beta }_{i}+1)\right](1+{\alpha }_{j}){\beta }_{j}+1+{\alpha }_{r}\ \ \mathrm{mod}\ 2.\end{eqnarray} \tag{ D6 }$$

The binary function T, on the other hand, is checking whether a set of coordinates is on a diagonal position (diagonally marked tiles). These excluded cases are mapped to ${(0)}^{\otimes r}$ altogether

$$\begin{eqnarray}&&T({\boldsymbol{\alpha }},{\boldsymbol{\beta }})={\displaystyle \prod }_{i}({\alpha }_{i}+{\beta }_{i})\ \mathrm{mod}\ 2.\end{eqnarray} \tag{ D7 }$$

This concludes the decoding function. Unfortunately, the amount of logic elements in the decoding will complicate the weight-two codes quite a bit, and the encoding function is hardly better. The reason for this is to find in the ordering condition: the update operations are conditional on whether we change the ordering of the coordinates represented by ${\boldsymbol{\alpha }}$ and ${\boldsymbol{\beta }}$. This is reflected in a nonlinear encoding function: we remind us that the encoding function is a map ${\boldsymbol{e}}:{{\mathbb{Z}}}_{2}^{\otimes {2}^{r}}\to {{\mathbb{Z}}}_{2}^{\otimes (2r-1)}$, and with ${\boldsymbol{\nu }}\in {{\mathbb{Z}}}_{2}^{\otimes {2}^{r}}$ we find

$$\begin{eqnarray*}{\boldsymbol{e}}({\boldsymbol{\nu }}) & = & \displaystyle \sum _{j=2}^{{2}^{r-1}}\ \displaystyle \sum _{i=1}^{j-1}({{\boldsymbol{q}}}^{{\boldsymbol{i}},{\boldsymbol{r}}}+{{\boldsymbol{I}}}^{{\boldsymbol{r}}}\ \mathrm{mod}\ 2)\oplus ({{\boldsymbol{q}}}^{{\boldsymbol{j}},{\boldsymbol{r}}-{\bf{1}}}+{{\boldsymbol{I}}}^{{\boldsymbol{r}}-{\bf{1}}}\ \mathrm{mod}\ 2){\nu }_{i}{\nu }_{j}\\ & & +\displaystyle \sum _{j={2}^{r-1}+1}^{{2}^{r}}\ \displaystyle \sum _{i=1}^{{2}^{r-1}}({{\boldsymbol{q}}}^{{\boldsymbol{i}},{\boldsymbol{r}}}+{{\boldsymbol{I}}}^{{\boldsymbol{r}}}\ \mathrm{mod}\ 2)\oplus ({{\boldsymbol{q}}}^{{\boldsymbol{j}}-{{\bf{2}}}^{{\boldsymbol{r}}-{\bf{1}}},{\boldsymbol{r}}-{\bf{1}}}){\nu }_{i}{\nu }_{j}\\ & & +\displaystyle \sum _{j={2}^{r-1}+2}^{{2}^{r}}\ \displaystyle \sum _{i={2}^{r-1}+1}^{j-1}({{\boldsymbol{q}}}^{{\boldsymbol{i}},{\boldsymbol{r}}})\oplus ({{\boldsymbol{q}}}^{{\boldsymbol{j}}-{{\bf{2}}}^{{\boldsymbol{r}}-{\bf{1}}},{\boldsymbol{r}}-{\bf{1}}}){\nu }_{i}{\nu }_{j}\quad \ \mathrm{mod}\ 2,\end{eqnarray*}$$

with ${{\boldsymbol{q}}}^{{\boldsymbol{i}},{\boldsymbol{j}}}$ as defined in (D3), and ${{\boldsymbol{I}}}^{{\boldsymbol{j}}}={(1)}^{\otimes j}={{\boldsymbol{q}}}^{{{\bf{2}}}^{{\boldsymbol{j}}},{\boldsymbol{j}}}$.

Zoom In Zoom Out Reset image size

The dissecting of tetrahedrons can be generalized for codes of weight larger than two (see again [28]), but as one increases the number of dissections, the code functions are complicated even further.

At this point we want to sketch the idea behind the segment sizes ($\hat{N},\hat{n}$) stated during section 3.1.3 in the main part, but first of all we would like to clearly set up the situation.

We consider vectors ${\boldsymbol{\nu }}\in {{\mathbb{Z}}}_{2}^{\otimes N}$ to consist of $\hat{m}$ smaller vectors ${\hat{{\boldsymbol{\nu }}}}^{{\boldsymbol{i}}}$ of length $\hat{n}+1$, such that ${\boldsymbol{\nu }}={\bigoplus }_{i=1}^{\hat{m}}{\hat{{\boldsymbol{\nu }}}}^{{\boldsymbol{i}}}$. We call those vectors ${\hat{{\boldsymbol{\nu }}}}^{{\boldsymbol{i}}}$ segments of ${\boldsymbol{\nu }}$. The goal is now to find a code (${\boldsymbol{e}},{\boldsymbol{d}}$) to encode a basis ${ \mathcal V }$ which contains all vectors ${\boldsymbol{\nu }}$ with Hamming weight K. For that purpose we relate the segment ${\hat{{\boldsymbol{\nu }}}}^{{\boldsymbol{i}}}$ to a segment of the code space, $\hat{{{\boldsymbol{\omega }}}^{i}}$, for all i ∈ [N]. The code space segments constitute the code words in a fashion similar to the previous segmentation of ${\boldsymbol{\nu }}$: ${\boldsymbol{\omega }}={\bigoplus }_{i=1}^{\hat{m}}\hat{{{\boldsymbol{\omega }}}^{i}}$. However, the length of those binary vectors $\hat{{{\boldsymbol{\omega }}}^{i}}$ is $\hat{n}$, such that with $n=\hat{m}\hat{n}$ and $N=\hat{m}(\hat{n}+1)$, the problem is reduced by $\hat{m}$ qubits as compared to conventional transforms. We now introduce the subcodes ($\hat{{\boldsymbol{e}}}:{{\mathbb{Z}}}_{2}^{\otimes (\hat{n}+1)}\to {{\mathbb{Z}}}_{2}^{\otimes \hat{n}},\hat{{\boldsymbol{d}}}:{{\mathbb{Z}}}_{2}^{\otimes \hat{n}}\to {{\mathbb{Z}}}_{2}^{\otimes (\hat{n}+1)}$), with which we encode the ith segment ${\hat{{\boldsymbol{\nu }}}}^{{\boldsymbol{i}}}$ as $\hat{{{\boldsymbol{\omega }}}^{i}}$ (see figure E1). Note that we require the subcodes to inherit all the code properties. In this way we guarantee the code properties of the global code (${\boldsymbol{e}},{\boldsymbol{d}}$) when appending $\hat{m}$ instances of the same subcode:

$$\begin{eqnarray}&&{\boldsymbol{d}}\left(\underset{i=1}{\overset{\hat{m}}{\displaystyle \bigoplus }}\hat{{{\boldsymbol{\omega }}}^{i}}\right)=\underset{i=1}{\overset{\hat{m}}{\displaystyle \bigoplus }}\hat{{\boldsymbol{d}}}(\hat{{{\boldsymbol{\omega }}}^{i}}),\qquad {\boldsymbol{e}}\left(\underset{i=1}{\overset{\hat{m}}{\displaystyle \bigoplus }}{\hat{{\boldsymbol{\nu }}}}^{{\boldsymbol{i}}}\right)=\underset{i=1}{\overset{\hat{m}}{\displaystyle \bigoplus }}\hat{{\boldsymbol{e}}}({\hat{{\boldsymbol{\nu }}}}^{{\boldsymbol{i}}}).\end{eqnarray} \tag{ E1 }$$

Zoom In Zoom Out Reset image size

The orbital number being an integer multiple of the block size is of course an idealized scenario. One will probably have to add a few other components in order to compensate for dimensional mismatches.

We now set out to find the smallest segment size $\hat{n}$. It should be clear that $\hat{n}$ is a function of the targeted Hamming weight K: this means K determines which segment codes are suitable for the system. The reason for this is that we need to encode all vectors with weight 0 to K inside every segment, taking into account for the up to K particles on the orbitals inside one segment. In order to include weight K vectors, the size of each segment must be at least K. If the segment size would be exactly K, on the other hand, we end up encoding the entire Fock space again. In doing so, we are not making any qubit savings. The segments must thus be larger than K. In other words, we look for an integer $\hat{n}\gt K$, where the sum of all combinations $\hat{{\boldsymbol{\nu }}}\in {{\mathbb{Z}}}_{2}^{\otimes (\hat{n}+1)}$ with ${{\rm{w}}}_{{\rm{H}}}(\hat{{\boldsymbol{\nu }}})\leqslant K$ is smaller equal ${2}^{\hat{n}}$

$$\begin{eqnarray}&&{2}^{\hat{n}}\ \geqslant \ \displaystyle \sum _{k=0}^{K}\left(\displaystyle \genfrac{}{}{0em}{}{\hat{n}+1}{k}\right).\end{eqnarray} \tag{ E2 }$$

In the case $\hat{n}=2K$, the condition is fulfilled as identity, since exactly half of all ${2}^{\hat{n}+1}$ combinations are included in the sum.

This subsection offers a closer look at the construction of the segment subcodes ($\hat{{\boldsymbol{e}}},\hat{{\boldsymbol{d}}}$). Let us start by considering the decoding $\hat{{\boldsymbol{d}}}$ in order to explore the nature of the binary switch $f(\hat{{\boldsymbol{\omega }}})$, that occurs in (38). One observes the two (affine) linear $({{\mathbb{Z}}}_{2}^{\otimes \hat{n}}\to {{\mathbb{Z}}}_{2}^{\otimes (\hat{n}+1)})$-maps

$$\begin{eqnarray}\hat{{\boldsymbol{\omega }}}\to \left[\begin{array}{ccc}1 & & \\ & \ddots & \\ & & 1\\ 0 & ... & 0\end{array}\right]\hat{{\boldsymbol{\omega }}}\,\mathrm{mod}\,2,\qquad \hat{{\boldsymbol{\omega }}}\ \to \ \left[\begin{array}{ccc}1 & & \\ & \ddots & \\ & & 1\\ 0 & ... & 0\end{array}\right]\hat{{\boldsymbol{\omega }}}+\left(\begin{array}{c}1\\ \vdots \\ \vdots \\ 1\end{array}\right)\ \mathrm{mod}\ 2.\end{eqnarray} \tag{ E3 }$$

to produce together all the vectors with weight equal or smaller than K, if we input all $\hat{{\boldsymbol{\omega }}}$ with ${{\rm{w}}}_{{\rm{H}}}(\hat{{\boldsymbol{\omega }}})\leqslant K$ into the first, and the remaining cases with ${{\rm{w}}}_{{\rm{H}}}(\hat{{\boldsymbol{\omega }}})\gt K$ into the second one. Note that the last component is always zero in outputs of the first function and one in the second. Therefore, the inverse of both maps is always a linear map with the matrix $[\ {\mathbb{I}}\ | {{\boldsymbol{I}}}^{\hat{{\boldsymbol{n}}}}]$. We take this inverse as encoding (39), and the two maps (E3) are merged into the decoding (38). In order to switch between these two maps we define the binary function $f(\hat{{\boldsymbol{\omega }}})\,:{{\mathbb{Z}}}_{2}^{\otimes \hat{n}}\to {{\mathbb{Z}}}_{2}$ such that

$$\begin{eqnarray}f(\hat{{\boldsymbol{\omega }}})=\left\{\begin{array}{ll}1 & {\rm{for}}\ \ {{\rm{w}}}_{{\rm{H}}}(\hat{{\boldsymbol{\omega }}})\gt K\\ 0 & {\rm{otherwise}}.\end{array}\right.\end{eqnarray} \tag{ E4 }$$

In general, one can define this binary switch in a brute-force way by

$$\begin{eqnarray}&&f(\hat{{\boldsymbol{\omega }}})=\displaystyle \sum _{k=K+1}^{2K}\displaystyle \sum _{\displaystyle \genfrac{}{}{0em}{}{{\boldsymbol{t}}\in {{\mathbb{Z}}}_{2}^{\otimes 2K}}{{{\rm{w}}}_{{\rm{H}}}({\boldsymbol{t}})=k}}\displaystyle \prod _{m=1}^{2K}({\hat{\omega }}_{m}+1+{t}_{m})\ \mathrm{mod}\ 2.\end{eqnarray} \tag{ E5 }$$

For the case K = 1 ($\hat{n}=2$), the switch equals $f({\boldsymbol{\omega }})={\omega }_{1}{\omega }_{2}$, and for the code we recover a version of binary addressing codes, where the vector (0, 0, 0) is encoded.

$$\begin{eqnarray}&&\hat{{\boldsymbol{d}}}(\hat{{\boldsymbol{\omega }}})=\left(\begin{array}{c}{\hat{\omega }}_{1}\,({\hat{\omega }}_{2}+1)\\ ({\hat{\omega }}_{1}+1)\,{\hat{\omega }}_{2}\\ {\hat{\omega }}_{1}{\hat{\omega }}_{2}\end{array}\right)\ \mathrm{mod}\ 2,\qquad \hat{{\boldsymbol{e}}}(\hat{{\boldsymbol{\nu }}})=\left[\begin{array}{ccc}1 & 0 & 1\\ 0 & 1 & 1\end{array}\right]\hat{{\boldsymbol{\nu }}}\ \ \mathrm{mod}\ 2.\end{eqnarray} \tag{ E6 }$$

In the K = 2 ($\hat{n}=4$) case, this binary switch is found to be $f(\hat{{\boldsymbol{\omega }}})={\hat{\omega }}_{1}{\hat{\omega }}_{2}{\hat{\omega }}_{3}+{\hat{\omega }}_{1}{\hat{\omega }}_{2}{\hat{\omega }}_{4}+{\hat{\omega }}_{1}{\hat{\omega }}_{3}{\hat{\omega }}_{4}+{\hat{\omega }}_{2}{\hat{\omega }}_{3}{\hat{\omega }}_{4}+{\hat{\omega }}_{1}{\hat{\omega }}_{2}{\hat{\omega }}_{3}{\hat{\omega }}_{4}\ \mathrm{mod}\ 2$.

As mentioned in section 3.1.3, in the main part, segment codes are not automatically compatible with all particle-number-conserving Hamiltonians. We show here, how certain adjustments can be made to these Hamiltonians, such that their action on the space ${{ \mathcal H }}_{N}^{K}$ is not changed, but segment codes become feasible to describe them with. In order to understand this issue, we begin by examining the encoded space. For that purpose we reprise the situation of (E1), where we have append $\hat{m}$ instances of the same subcode. With segment codes, the basis ${ \mathcal V }$ contains vectors with Hamming weights from 0 to $\hat{m}K$. We have encoded all possible vectors ${\boldsymbol{\nu }}$ with $0\leqslant {{\rm{w}}}_{{\rm{H}}}({\boldsymbol{\nu }})\leqslant K$, but although we have some, not all vectors with ${{\rm{w}}}_{{\rm{H}}}({\boldsymbol{\nu }})\gt K$ are encoded. We can illustrate that point rather quickly: each segment has length $2K+1$, but the subcode encodes vectors $\hat{{\boldsymbol{\nu }}}$ with only ${{\rm{w}}}_{{\rm{H}}}(\hat{{\boldsymbol{\nu }}})\leqslant K$. The (global) basis ${ \mathcal V }$ is thus deprived of vectors ${\boldsymbol{\nu }}=({\bigoplus }_{i}{\hat{{\boldsymbol{\nu }}}}^{{\boldsymbol{i}}})$ where for any segment $i,{{\rm{w}}}_{{\rm{H}}}({\hat{{\boldsymbol{\nu }}}}^{{\boldsymbol{i}}})\gt K$.

We now turn our attention to terms, which, when present in a Hamiltonian, make segment codes infeasible to use. Note, that ${ \mathcal V }$-vectors with ${{\rm{w}}}_{{\rm{H}}}({\boldsymbol{\nu }})\ne K$, are not corresponding to fermionic states we are interested in. In particular it is a certain subset of states with ${{\rm{w}}}_{{\rm{H}}}({\boldsymbol{\nu }})\gt K$, which can lead out of the encoded space (into the states previously mentioned) when acted upon with certain fermionic operators. Let us consider the operator ${c}_{i}^{\dagger }{c}_{j}^{\ }$ as an example, where i and j are in different segments (let us call these segments A and B). Now a basis state as depicted in figure E2, is not annihilated by ${c}_{i}^{\dagger }{c}_{j}^{\ }$, and leads into a state with 3 particles in segment A. The problem is that the initial state is encoded in the $(K=2)$ segment codes, whereas the updated state (with the 3 particles in A) is not. In general, operators ${\hat{h}}_{{\boldsymbol{ab}}}$, that change occupations in between segments, will cause some basis states with ${{\rm{w}}}_{{\rm{H}}}({\boldsymbol{\nu }})\gt K$ to leave the encoded space. We can however adjust these terms ${\hat{h}}_{{\boldsymbol{ab}}}\to {\hat{h}}_{{\boldsymbol{ab}}}^{{\prime} }$, such that ${\hat{h}}_{{\boldsymbol{ab}}}^{{\prime} }:\mathrm{span}({ \mathcal B })\to \mathrm{span}({ \mathcal B })$, where ${ \mathcal B }$ is the basis encoded by the segment codes. We now sketch the idea behind those adjustments, before we reconsider the situation of figure E2. Note that after these adjustments have been made to all Hamiltonian terms in question, the segment codes are compatible with the new Hamiltonian. The idea is to switch those terms off for states, that already have K particles inside the segments, to which particles will be added. We have to take care to do this in a way that leaves the Hamiltonian hermitian on the level of second quantization, i.e. we have to adjust the terms ${\hat{h}}_{{\boldsymbol{ab}}}^{\ }$ and ${\hat{h}}_{{\boldsymbol{ab}}}^{\dagger }$ into ${\hat{h}}_{{\boldsymbol{ab}}}^{{\prime} }$ and ${({\hat{h}}_{{\boldsymbol{ab}}}^{\dagger })}^{{\prime} }$, such that ${\hat{h}}_{{\boldsymbol{ab}}}^{{\prime} }+{({\hat{h}}_{{\boldsymbol{ab}}}^{\dagger })}^{{\prime} }$ is hermitian. For the K = 2 code of figure E2, we can make the following adjustments:

Zoom In Zoom Out Reset image size

$$\begin{eqnarray}&&{c}_{i}^{\dagger }{c}_{j}^{\ }\ \to \ \left(1-\displaystyle \sum _{l,k\lt l\,\in \,{\rm{}}\,{\rm{B}}}{c}_{k}^{\dagger }{c}_{k}^{\ }{c}_{l}^{\dagger }{c}_{l}^{\ }\right){c}_{i}^{\dagger }{c}_{j}^{\ }\left(1-\displaystyle \sum _{w,v\lt w\,\in \,{\rm{}}\,{\rm{A}}}{c}_{v}^{\dagger }{c}_{v}^{\ }{c}_{w}^{\dagger }{c}_{w}^{\ }\right).\end{eqnarray} \tag{ E7 }$$