text:
# Fermionic quantum computation

## Introduction

The notion of locality plays the key role in the definition of computation process. The same basic principles apply to classical computers and the circuit model of quantum computation :

1. The computer consists of small pieces, or cells (bits, qubits, qutrits or something else).
2. It is allowed to operate on few cells at a time.
3. All cells are identical, so each operation has a model which can be applied to different sets of cells. We call such a model a gate (like the CNOT gate) while the operation itself is called a gate application (like CNOT applied to qubits $`5`$ and $`8`$).

In fact, the main difference between classical computation and quantum computation is the concrete interpretation of these postulates. The standard quantum interpretation is as follows.

* Each cell is described by a Hilbert space of small dimensionality. (Without loss of generality, these spaces are two-dimensional, in which case the cells are called qubits). The Hilbert space of the entire computer is the tensor product of the spaces associated to the individual cells.
* Each operation is described by a unitary operator which is the tensor product of some operator $`U`$, acting on the selected qubits, and the identity operator acting on the rest of the system.
* A $`p`$-qubit gate can be defined as $`U`$ acting on some standard $`2^p`$-dimensional space (which is the same as a standard set of $`p`$ qubits).

This interpretation might be perfect from the complexity-theoretic point of view, but it does not necessarily correspond to physics. At the fundamental level, Fermi systems do not satisfy the condition (2i). Hence using fermions as carriers of quantum information  should be considered as a different computation model, although it is equivalent to the standard one in a certain sense. At the macroscopic level, collective quantum degrees of freedom (or excitations, such as anyons ) do not even satisfy the condition (1i). In all such cases, it makes sense to abstract the nontrivial locality properties from physical details. This will lead us to a definition of “fermionic gates”, “anyonic gates” and other quantum computation models which deserve careful study.

What can one expect from alternative models of quantum computation? It is very unlikely that any physical system would provide more computational power than the standard quantum computation model has. (This might be wrong for quantum gravity but here we can only guess). So, the alternative models should be polynomially equivalent to the standard one. There are indeed several results which support this statement. Firstly, D. Abrams and S. Lloyd  have shown that a system of $`m`$ local fermionic modes (i.e. sites which can be empty or occupied) can be simulated on a quantum computer in such a way that one fermionic gate takes $`O(m)`$ qubit operations. In some cases (one of the assumptions is that the number of particles is conserved) faster simulation is possible. We will extend this result by showing that in the general case (when the number of fermions is conserved only modulo $`2`$) each fermionic gate can be simulated by $`O(\mathrm{log}m)`$ qubit gates. Secondly, TQFT computation (which is more general than quantum computation with anyons) can be simulated in polynomial time on an ordinary quantum computer .

Thus alternative quantum computation models do not generate new computational classes. Rather, they provide new descriptions of the standard class $`\mathrm{B}QP`$ (the class of problems that are solvable on a quantum computer in polynomial time). These descriptions may be useful to find new quantum algorithms, error-correcting codes, fault-tolerant procedures, or to prove that $`\mathrm{B}QP`$ is contained in some other computational classes. They may also open the door to new physical implementations of a quantum computer.

## 1 A more general notion of locality

Why isn’t the standard interpretation of locality good in all cases? The answer is in the way we describe quantum evolution. The Hilbert space and state vectors are very convenient tools but they are not directly related to physically observable things. Operators are much more “real” as they allow one to describe interaction between the system and the rest of the world. In fact, the causality principle is usually stated in terms of operators: “operators in spatially separated points commute”. Our definition of locality will be in the same spirit.

A quantum system can be characterized by a finite-dimensional $`C^{}`$-algebra111$`C^{}`$-algebra is a generalization of the algebra of linear operators on a Hilbert space. The properties of operator addition, multiplication, Hermitian conjugation and the operator norm are axiomatized in a certain way. However, instead of using the axioms, we will rely on a characterization of finite-dimensional $`C^{}`$-algebras given below. $`𝒢`$ whose elements are called “physical operators”. As a matter of fact, they are operators on a suitable Hilbert space. Indeed, it is a theorem that $`𝒢`$ can be represented as $`_j𝐋(_j)`$, where $`𝐋()`$ stands for the algebra of operators on the space $``$. Hence $`𝒢`$ acts on $`=_j_j`$. (In the case of fermions, $`=_0_1`$ is the Foch space split into the subspaces corresponding to an even and odd number of particles; $`𝒢`$ is the algebra of operators which preserve the parity).

To define locality, we will assume that the system is associated with some set of sites $`M`$. The following properties are postulated:

1. For each subset of sites $`SM`$, there is a $`C^{}`$-subalgebra $`𝒢(S)𝒢`$. Elements of $`𝒢(S)`$ are called physical operators acting on $`S`$. We require that $`𝒢(M)=𝒢`$, $`𝒢(\mathrm{})=𝐂I`$ (where $`𝐂`$ is the algebra of complex numbers, $`I`$ is the unit element of $`𝒢`$), and $`𝒢(S)𝒢(S^{})`$ if $`SS^{}`$.
2. If $`S_1S_2=\mathrm{}`$ then any two operators $`X_1𝒢(S_1)`$ and $`X_2𝒢(S_2)`$ commute.

The concept of unitarity is well defined in this setting: an element $`U𝒢(M)`$ is called unitary if $`UU^{}=U^{}U=I`$ (the operation $``$ is a part of the $`C^{}`$-algebra structure). Note that nonunitary elements of $`𝒢(M)`$ also have physical meaning because they can be used to construct a unitary operator on a larger space $``$, where $``$ represents some external system (e. g. a measurement device). Such an operator generally has the form $`U=_kA_kB_k`$ ($`A_k𝒢(M)`$), i. e. $`U𝒢(M)𝐋()`$.

Thus we have given a more general interpretation of the locality postulates 1 and 2 which were discussed in the introduction. (We put aside the postulate 3 here).

## 2 Local fermionic modes

Consider $`m`$ sites (numbered $`0`$ through $`m1`$) each of which can be either empty or occupied by a spinless fermionic particle. Such sites will be called local fermionic modes (LFMs). The Hilbert space $``$ of this system, known as Foch space, is spanned by $`2^m`$ basis vectors $`|n_0,\mathrm{},n_{m1}`$, where $`n_j=0,1`$ is the occupation number of the $`j`$-th site. Everything related to fermions can be expressed in terms of annihilation and creation operators $`a_j,a_j^{}`$, ($`j=0,\mathrm{},m1`$). The operator $`a_j`$ acts on basis vectors as follows:

$$\begin{array}{c}a_j|n_0,\mathrm{},n_{j1},1,n_{j+1},\mathrm{},n_{m1}=\left(1\right)^{_{s=0}^{j1}n_s}|n_0,\mathrm{},n_{j1},0,n_{j+1},\mathrm{},n_{m1},\hfill \\ a_j|n_0,\mathrm{},n_{j1},0,n_{j+1},\mathrm{},n_{m1}=\mathrm{\hspace{0.17em}0};\hfill \end{array}$$
(1)
$`a_j^{}`$ is the Hermitian conjugate. Note that the definition depends on the order of LFMs! (One may rather say that the basis depends on the order while $`a_j,a_j^{}`$ do not, since all relations between them are permutation-invariant). The annihilation and creation operators generate the algebra $`\overline{}=𝐋()`$ and have the following commutation rules:

$$\begin{array}{ccc}\hfill a_ja_k+a_ka_j& =& 0,\hfill \\ \hfill a_j^{}a_k^{}+a_k^{}a_j^{}& =& 0,\hfill \\ \hfill a_ja_k^{}+a_k^{}a_j& =& \delta _{jk}.\hfill \end{array}$$
(2)
The Hilbert space of $`m`$ LFMs splits into two parts: $`=_0_1`$, where “0” and “1” refers to the total fermionic parity $`n=_{j=0}^{m1}n_j(mod2)`$. Physical operators are those which preserve the parity. Note that the Hamiltonian of a real Fermi system always satisfies this condition,222In electon systems, the Hamiltonian also preserves the electric charge, so terms with different numbers of $`a_j`$ and $`a_j^{}`$ are usually forbidden. Our model is mostly relevant to superconductors where the total charge of excitations is not conserved, so terms like $`a_ja_k`$ appear in the effective Hamiltonian. unlike the operators $`a_j,a_j^{}`$ alone. The algebra of physical operators $`=𝐋(_0)𝐋(_1)`$ is spanned by products of even number of $`a_j,a_j^{}`$. (The notation $`𝒢`$ in the previous section referred to the general case whereas $``$ is reserved for LFMs).

Let $`S\{0,\mathrm{},m1\}`$ be a set of LFMs. Physical operators on S are linear combinations of even products of $`a_j,a_j^{}`$, $`jS`$. The algebra of such operators is $`(S)=\overline{}(S)`$, where $`\overline{}(S)\overline{}`$ is generated by $`a_j,a_j^{}`$, $`jS`$. The conditions (1) and (2) from Sec. 1 are obviously satisfied. Moreover, $`(S_1)`$ commutes with $`\overline{}(S_2)`$ if $`S_1S_2=\mathrm{}`$.

The occupation number $`n_j`$ is an eigenvalue of the operator $`\widehat{n}_j=a_j^{}a_j(\{j\})`$, which means it can be measured locally (by acting on the $`j`$-th LFM and some external device). The occupation number can not be changed locally, though.

Here are some examples of unitary operators acting on one or two LFMs: $`\mathrm{exp}(i\beta a_j^{}a_j)`$ (action by an external potential), $`\mathrm{exp}(i\beta a_j^{}a_ja_k^{}a_k)`$ (two-particle’s interaction), $`\mathrm{exp}(i(\gamma a_j^{}a_k+\gamma ^{}a_k^{}a_j))`$ (tunneling) and $`\mathrm{exp}(i(\gamma a_ka_j+\gamma ^{}a_j^{}a_k^{}))`$ (interaction with a superconductor). We will show that these operators (for all or for some particular values of $`\beta 𝐑`$ and $`\gamma 𝐂`$) form a universal set, i.e. any unitary operator can be represented as a composition of these ones to any given precision, using ancillas.

In our computation model we allow to use ancillas in the state $`|0`$. (To be more accurate, we should say that the input state is padded by some number of zeros to the right. Actually, the order does not matter in this case). If we speak about implementing a unitary operator, the ancillas must return to the state $`|0`$ by the end of the procedure. As is usual, this restriction does not apply to computing a Boolean function which proceeds as follows. One starts from a basis vector $`|n_0,\mathrm{},n_{m1}`$ representing the input data, adds some ancillas, applies some sequence of local unitary operators and reads the result by measuring some of the occupation numbers.

## 3 Relation between LFMs and qubits

The Hilbert space of $`m`$ LFMs can be identified with the Hilbert space of $`m`$ qubits $`^m`$ (where $``$ stands for the two-dimensional space $`𝐂^2`$ endowed with the standard basis $`\{|0,|1\}`$):

$$|n_0,n_1,\mathrm{},n_{m1}|n_0|n_1\mathrm{}|n_{m1},n_j=0,1.$$
(3)
Measurement of $`n_j`$ is the same as eigenvalue measurement of $`\sigma _j^z`$. A physical fermionic operator corresponds to a qubit operator which preserves the parity, i.e. commutes with $`_{j=0}^{m1}\sigma _j^z`$. However, “applying a gate to a set of LFMs” is very different from “applying a gate to a set of qubits”.

Let $`X`$ be a parity-preserving $`p`$-qubit operator acting on qubits numbered $`0`$ through $`p1`$. Applying it to the qubits $`j_0,\mathrm{},j_{p1}`$ is a straightforward procedure. The Hilbert space of $`m`$ qubits $`^m`$ can be identified with $`^p^{(mp)}`$ by the qubit permutation $`P:|n_0,\mathrm{}n_{m1}|n_{j_0},\mathrm{}n_{j_{p1}}|\text{the other}n_j`$. Then the action of $`X`$ is defined as follows:

$$X[j_0,\mathrm{},j_{p1}]=P^1(XI_{^{(mp)}})P.$$

If we want to apply $`X`$ to the LFMs $`j_0,\mathrm{},j_{p1}`$, the procedure is different. First, we should expand $`X`$ into products of $`a_0,\mathrm{},a_{p1},a_0^{},\mathrm{},a_{p1}^{}`$. Then we replace each $`a_r`$ by $`a_{j_r}`$ and each $`a_r^{}`$ by $`a_{j_r}^{}`$. The resulting operator will be denoted by $`X\{j_0,\mathrm{},j_{p1}\}`$. For example, if $`X=|1,00,1|=a_0^{}a_1`$ then $`X\{j,k\}=a_j^{}a_k`$. This operator acts as follows:

$$\begin{array}{ccc}\hfill a_j^{}a_k|\mathrm{},0,n_{j+1},\mathrm{},n_{k1},0,\mathrm{}& =& 0,\hfill \\ \hfill a_j^{}a_k|\mathrm{},0,n_{j+1},\mathrm{},n_{k1},1,\mathrm{}& =& \left(1\right)^{_{s=j+1}^{k1}n_s}|\mathrm{},1,n_{j+1},\mathrm{},n_{k1},0,\mathrm{},\hfill \\ \hfill a_j^{}a_k|\mathrm{},1,n_{j+1},\mathrm{},n_{k1},0,\mathrm{}& =& 0,\hfill \\ \hfill a_j^{}a_k|\mathrm{},1,n_{j+1},\mathrm{},n_{k1},1,\mathrm{}& =& 0.\hfill \end{array}$$

Not only $`X\{j,k\}X[j,k]`$ but also $`X\{j,k\}`$ is non-local in terms of qubits: it involves all the qubits with numbers from $`j`$ to $`k`$.

A unitary qubit gate (LFM, or fermionic gate) is a unitary operator $`U`$ meant to be applied to a number of qubits (LFMs); a $`p`$-qubit or a $`p`$-LFM gate acts on the standard Hilbert space $`^p`$. Operators of the form $`U[j,k]`$ or $`U\{j,k\}`$ are called gate applications. We will usually consider unitary gates up to overall phase factors. A set of gates is also called a basis. A circuit of size $`s`$ in a basis $`𝒜`$ is a composition of $`s`$ applications of gates from $`𝒜`$, i.e. an expression of the form $`U_s\{j_{s,0},\mathrm{},j_{s,p_s1}\}\mathrm{}U_1\{j_{1,0},\mathrm{},j_{1,p_11}\}`$, where $`U_k𝒜`$. Such an expression is evaluated by a unitary operator which is said to be represented by the circuit.

Note that $`X\{j\}=X[j]`$, so one-LFM gates are simply parity-preserving one-qubit gates. Up to an overall phase, such gates have the form $`\mathrm{\Lambda }(e^{i\varphi })`$, where $`\mathrm{\Lambda }(U)`$ denotes the controlled $`U`$. (If $`U`$ acts on $`p`$ qubits then $`\mathrm{\Lambda }(U)`$ acts on $`p+1`$ qubits; in our case $`p=0`$).

More generally, $`X\{j,j+1,\mathrm{},j+p1\}=X[j,j+1,\mathrm{},j+p1]`$. This allows one to represent fermionic gates in terms of qubit gates and vice versa. We will now show how to do that in the case $`p=2`$.

Suppose we want to execute a two-LFM operator $`X\{j,k\}`$ (w. l. .o. g. $`j<k`$). First, we move the $`k`$-th qubit next to the $`j`$-th one by swapping it with its nearest neighbors. Then we apply $`X\{j,j+1\}=X[j,j+1]`$ and move the $`k`$-th qubit back to its original position. However, what we actually need here is to interchange LFMs, not qubits. This is different even if the LFMs (qubits) are next to each other!

A swap between two qubits (with numbers $`0`$ and $`1`$) is defined in the obvious way: $`():|n_0,n_1|n_1,n_0`$. A swap between two LFMs is a unitary operator $`()`$ such that

$$()a_0()^{}=a_1,()a_1()^{}=a_0.$$
(4)
These equations have a unique solution (up to an overall phase factor):

$$()=Ia_0^{}a_0a_1^{}a_1+a_1^{}a_0+a_0^{}a_1=\mathrm{exp}\left(i\frac{\pi }{2}(a_0^{}a_1^{})(a_0a_1)\right):\{\begin{array}{c}|0,0|0,0\hfill \\ |0,1|1,0\hfill \\ |1,0|0,1\hfill \\ |1,1|1,1.\hfill \end{array}$$
(5)
This differs from the qubit swap by the “-” sign. So,

$$()=()D,$$
(6)
where $`D=\mathrm{\Lambda }(\sigma ^z):|a,b(1)^{ab}|a,b`$ is a “swap defect” operator.

To perform the procedure described above, we do not have to actually interchange LFMs or qubits. Instead, we can simply apply operators $`D\{l,r\}=D[l,r]`$ to all pairs of qubits that otherwise would be interchanged. So, any two-LFM operator $`X\{j,k\}`$ ($`j<k`$) can be represented by a qubit circuit as follows:

$$X\{j,k\}=D[k1,k]\mathrm{}D[j+1,k]X[j,k]D[j+1,k]\mathrm{}D[k1,k].$$
(7)
Conversely, any parity-preserving two-qubit operator is represented by a fermionic circuit:

$$X[j,k]=D\{k1,k\}\mathrm{}D\{j+1,k\}X\{j,k\}D\{j+1,k\}\mathrm{}D\{k1,k\}.$$
(8)
This method also works for operators which act on more than two LFMs (qubits).

## 4 A universal set of LFM gates.

We have shown that fermionic gates are equivalent to parity-preserving qubit gates modulo the swap defect operator $`D`$. So, to obtain a universal set of fermionic gates, we only need to find a universal set of parity-preserving qubit gates. It will be possible to represent the operator $`D`$ by these gates too, exactly or approximately. (If only approximate representation is possible, one may have to pay extra cost when simulating a single fermionic gate because the more qubit gates are used, the more accurate they should be. We will avoid this problem, though).

We claim that the following gates are sufficient to represent any parity-preserving operator to any given precision (using ancillas):

$$\mathrm{\Lambda }(e^{i\pi /4}),\mathrm{\Lambda }(\sigma ^z),\stackrel{~}{H}:|a,b\frac{1}{\sqrt{2}}\underset{c}{}(1)^{bc}|a+b+c,c.$$
(9)
(Here $`a,b,c𝐅_2=\{0,1\}`$, so the expression $`a+b+c`$ is considered modulo $`2`$). Note that $`D=\mathrm{\Lambda }(\sigma ^z)`$ belongs to this set of gates.

Any parity-preserving operator $`U`$ can be considered as a pair of operators $`(U_0,U_1)`$, where $`U_0`$ acts on the even sector $`_0`$ whereas $`U_1`$ acts on the odd sector $`_1`$. We will first show how to get a given $`U_0`$ while not caring about $`U_1`$ — we will actually get $`U_1=U_0`$. (The comparison between $`U_0`$ and $`U_1`$ is made through identifying $`_0`$ and $`_1`$ by the map $`\sigma ^x[0]`$). Then we will implement operators of the form $`(I,Y)`$ which can be used to correct the first step.

Any operator $`X`$ on $`m1`$ qubits can be transformed to a parity-preserving operator $`\stackrel{~}{X}`$ on $`m`$ qubits by using the extra qubit to maintain the parity:

$$\stackrel{~}{X}=V^1(I_{}X)V,V:|n_0,n_1,\mathrm{},n_{m1}|n_0+\mathrm{}+n_{m1},n_1,\mathrm{},n_{m1}.$$
(10)
Note that the gate $`\stackrel{~}{H}`$ (see eq. (9)) corresponds to the Hadamard gate $`H=\frac{1}{\sqrt{2}}\left(\begin{array}{cc}\hfill 1& \hfill 1\\ \hfill 1& \hfill 1\end{array}\right)`$. If $`X`$ already preserves the parity, as it is the case with the operators $`\mathrm{\Lambda }(e^{i\pi /4})`$ and $`\mathrm{\Lambda }(\sigma ^z)`$, then $`\stackrel{~}{X}=I_{}X`$. (This equality is actually a characteristic property of parity-preserving operators).

The operator $`V`$ is unitary. It maps the even sector $`_0`$ onto the subspace $`_0`$ which consists of vectors $`|0|\xi `$ ($`|\xi ^{(m1)}`$). Any operator on this subspace extends to an operator of the form $`I_{}X`$. Hence any $`U_0𝐋(_0)`$ extends to an operator of the form $`\stackrel{~}{X}`$. Note that $`V`$ and $`I_{}X`$ commute with $`\sigma ^x[0]`$, so $`\stackrel{~}{X}`$ also commutes with $`\sigma ^x[0]`$. Therefore $`\stackrel{~}{X}=(U_0,U_1)`$, where $`U_1=\sigma ^x[0]U_0\sigma ^x[0]`$, or simply $`U_1=U_0`$ if the identification between $`_0`$ and $`_1`$ is used.

If an operator $`X`$ is represented by a quantum circuit $`A_L\mathrm{}A_1`$, one can replace each gate application $`A_k`$ by $`\stackrel{~}{A_k}`$ to get a quantum circuit for $`\stackrel{~}{X}`$. Indeed, eq. (10) defines a $``$-algebra homomorphism, i.e.

$$\stackrel{~}{X_1+X_2}=\stackrel{~}{X_1}+\stackrel{~}{X_2},\stackrel{~}{cX}=c\stackrel{~}{X},\stackrel{~}{X_1X_2}=\stackrel{~}{X_1}\stackrel{~}{X_2},\stackrel{~}{X^{}}=\stackrel{~}{X}^{},\stackrel{~}{I}=I.$$

It follows that any universal gate set $`𝒜`$ transforms to a set of parity-preserving gates $`\stackrel{~}{𝒜}`$ which are universal on the even sector. The following gate set is known to be universal : $`𝒜=\{\mathrm{\Lambda }(e^{i\pi /4}),\mathrm{\Lambda }(\sigma ^z),H\}`$. The corresponding gate set $`\stackrel{~}{𝒜}`$ is given by eq. (9). (The parity-preserving gates $`\mathrm{\Lambda }(e^{i\pi /4})`$ and $`\mathrm{\Lambda }(\sigma ^z)`$ are copied from $`𝒜`$ to $`\stackrel{~}{𝒜}`$ unchanged). Thus the basis (9) allows one to obtain at least unitary gates of the form $`(U_0,U_0)`$.

With parity-preserving operators, we can still use one of the standard techniques in quantum circuit design — gates with quantum control. Indeed, if $`U`$ preserves the parity then $`\mathrm{\Lambda }(U)`$ also does. More generally, $`\stackrel{~}{\mathrm{\Lambda }(X)}=\mathrm{\Lambda }(\stackrel{~}{X})`$ (up to a permutation of the control qubit and the parity qubit). So, if we can represent $`\mathrm{\Lambda }(X)`$ by a circuit,333Implementing $`\mathrm{\Lambda }(X)`$ in the basis $`𝒜`$ is only slightly harder than implementing $`X`$. Indeed, for each gate $`X`$ from the basis $`𝒜`$, the operator $`\mathrm{\Lambda }(X)`$ can be represented by a circuit in the same basis exactly. Therefore, the circuit for $`\mathrm{\Lambda }(X)`$ will be larger than the circuit for $`X`$ only by a constant factor. Note, however, that $`X`$ may have been implemented up to a phase factor; this phase factor becomes important when we consider $`\mathrm{\Lambda }(X)`$. The necessary correction can be achieved by an operator $`\mathrm{\Lambda }(e^{i\varphi })`$ which should be implemented separately. we can also obtain a circuit for $`\mathrm{\Lambda }(\stackrel{~}{X})`$ by the procedure described above. For example, the operator $`\mathrm{\Lambda }(\sigma ^x)[1,2]`$ can be represented as $`H[2]\mathrm{\Lambda }(\sigma ^z)[1,2]H[2]`$, hence

$$\mathrm{\Lambda }(\stackrel{~}{\sigma ^x})[1,0,2]=\stackrel{~}{H}[0,2]\mathrm{\Lambda }(\sigma ^z)[1,2]\stackrel{~}{H}[0,2].$$

Here we use qubit $`0`$ to maintain the parity whereas $`1`$ is the control qubit. (The notation $`\mathrm{\Lambda }(\stackrel{~}{X})[\mathrm{}]`$ suggests that the control qubit goes first).

Now we are in a position to implement operators of the form $`(I,Y)`$ using the gates (9). We will also use one ancilla which will be assigned the number $`m`$. First, we execute the operator

$$\begin{array}{c}W:|n_0,n_1,\mathrm{},n_{m1},n_m|n_0+\mathrm{}+n_{m1},n_1,\mathrm{},n_{m1},n_1+\mathrm{}+n_m,\hfill \\ W=\mathrm{\Lambda }(\stackrel{~}{\sigma ^x})[m1,0,m]\mathrm{}\mathrm{\Lambda }(\stackrel{~}{\sigma ^x})[1,0,m],\hfill \end{array}$$
(11)
where $`\mathrm{\Lambda }(\stackrel{~}{\sigma ^x}):|a,b,c|a,b+a,c+a`$. Now qubit $`0`$ indicates the total parity.

Let $`\stackrel{~}{X}=(Y,Y)`$. Since $`\stackrel{~}{X}`$ can be represented according to (10), and because

$$W=V^1[m,1,\mathrm{},m1]V,\text{where}V=V[0,\mathrm{},m1],$$

we conclude that

$$W^1\mathrm{\Lambda }(\stackrel{~}{X})[0,m,1,\mathrm{},m1]W=V^1\mathrm{\Lambda }(X)[0,1,\mathrm{},m1]V=UI_{},U=(I,Y).$$
(12)
Note that in this case, the ancilla is not affected no matter what its initial state was; one can even use a data qubit as the ancilla.

We have proved that the gate set (9) is universal in the class of parity-preserving operators. It remains to represent these gates in terms of creation and annihilation operators. The first two are simple:

$$\mathrm{\Lambda }(e^{i\pi /4})=\mathrm{exp}\left(i\frac{\pi }{4}a_0^{}a_0\right),\mathrm{\Lambda }(\sigma ^z)=\mathrm{exp}(i\pi a_0^{}a_0a_1^{}a_1).$$
(13)
Unfortunately, the gate $`\stackrel{~}{H}`$ in the fermionic representation looks ugly, so we first represent it as follows:

$$\stackrel{~}{H}[0,1]=\mathrm{\Lambda }(i)[1]\stackrel{~}{G}[0,1]\mathrm{\Lambda }(i)[1],G=\left(\begin{array}{cc}1& i\\ i& 1\end{array}\right).$$

So, the fermionic gates (13), together with

$$\stackrel{~}{G}=\mathrm{exp}\left(i\frac{\pi }{4}(a_0a_0^{})(a_1+a_1^{})\right)=\mathrm{exp}\left(i\frac{\pi }{4}(a_0^{}a_1+a_1^{}a_0)\right)\mathrm{exp}\left(i\frac{\pi }{4}(a_1a_0+a_0^{}a_1^{})\right),$$
(14)
form a universal set. Obviously, this gate set is also universal:

$$\left\{\begin{array}{c}\mathrm{exp}\left(i\frac{\pi }{4}a_0^{}a_0\right),\hfill \\ \mathrm{exp}\left(i\frac{\pi }{4}(a_0^{}a_1+a_1^{}a_0)\right),\hfill \\ \mathrm{exp}\left(i\frac{\pi }{4}(a_1a_0+a_0^{}a_1^{})\right),\hfill \\ \mathrm{exp}(i\pi a_0^{}a_0a_1^{}a_1)\hfill \end{array}\right\}.$$
(15)
## 5 Fast simulation procedures

So far we have been using the standard identification (3) between the Foch space $``$ and the Hilbert space of $`m`$ qubits $`^m`$. This identification has allowed us to consider qubit gate applications $`X[j,k]𝐋(^m)`$ and LFM gate applications $`X\{j,k\}𝐋()`$ as operators acting on the same space. Now we are going to discuss a more general way of simulating LFMs by qubits (or vice versa). Let $`J`$ be an encoding of $`m`$ LFMs by $`m^{}`$ qubits, i.e. $`J:^m^{}`$ is a unitary embedding. ($`J`$ being a unitary embedding means that $`J^{}J=I_{}`$. Note that $`JJ^{}`$ is the projector onto $`=ImJ^m^{}`$). We say that an operator $`U^{}𝐋(^m^{})`$ represents an operator $`U𝐋()`$ if

$$\begin{array}{ccc}& \stackrel{U}{}& \\ J& & J\\ ^m^{}& \stackrel{U^{}}{}& ^m^{}\end{array}\text{commutes},\text{i.e.}JU=U^{}J.$$
(16)
The operator $`U`$, as well as the LFMs or qubits equivalent to them, are called logical. The $`m^{}`$ qubits the operator $`U^{}`$ acts on are called code qubits.

In this section we will show that each LFM gate can be simulated by $`O(\mathrm{log}m)`$ qubit gates. Surprisingly, this does not require quantum codes in the proper sense, i.e. $`J:^m`$ is a map onto. Moreover, $`J`$ takes basis vectors to basis vectors. We will also show how to simulate qubit gates by LFM gates at a constant cost using a subspace of the Foch space.

Gate action on a set of qubits (LFMs) can be described as follows. First, we extract two (or some other number) qubits or LFMs from the quantum memory which is now considered as a “black box”. We place these qubits at positions $`2`$ and $`1`$. Then we apply the gate and put the qubits (LFMs) back into the memory. In this description, it does not matter what gate we apply, a qubit one or a fermionic one (because $`X\{2,1\}=X[2,1]`$). Once extracted, LFMs can be regarded as qubits — the difference is in the way we extract them. With qubits, we apply the operator

$$[j]:^m^m:|n_0\mathrm{}|n_j\mathrm{}|n_{m1}|n_j|n_0\mathrm{}|0\mathrm{}|n_{m1}.$$

This is a unitary embedding into a larger Hilbert space; it can be represented as adding an ancilla in the state $`|0`$ followed by a unitary operator. With fermions, we move the $`j`$-th LFM through all the LFMs left to it, so we should take swap defects into account. Thus we get another unitary embedding:

$$\begin{array}{c}\{j\}:,\hfill \\ \{j\}|n_0,\mathrm{},n_j,\mathrm{},n_{m1}=(1)^{n_j_{s=0}^{j1}n_s}|n_j|n_0,\mathrm{},0,\mathrm{},n_{m1}.\hfill \end{array}$$
(17)
It is easy to verify that our recipe is correct, i.e. applying the operator $`X[2,1]`$ after extracting two LFMs is equivalent to applying $`X\{j,k\}`$ before the extraction:

$$X[2,1](I_{}\{k\})\{j\}=(I_{}\{k\})\{j\}X\{j,k\}.$$
(18)
(Our notations are somewhat confusing so this comment could be helpful. When we extract the $`j`$-th LFM by applying $`\{j\}`$, we add one qubit at position $`1`$. When we then extract the $`k`$-th LFM, this qubit moves to position $`2`$ while another one is being inserted; this can be described by the operator $`I_{}\{k\}`$.)

Suppose we want to simulate LFMs by qubits at low cost. The problem with the standard encoding (3) is that multiplication by the factor $`\left(1\right)^{n_j_{s=0}^{j1}n_s}`$ requires too many operations. The simplest solution would be to store $`y_j=_{s=0}^{j1}n_s`$ instead of $`n_j`$. (Remember that we consider $`n_s`$ as residues$`(mod2)`$, so the sum is also taken$`(mod2)`$). This does solve the problem but also creates a new one: when $`n_j`$ becomes $`0`$ as a result of extraction, we have to modify all $`y_k`$, $`k>j`$. So, we need to balance the complexity of computing $`_{s=0}^{j1}n_s`$ and that of updating the encoded quantum memory when $`n_j`$ changes. This kind of trade-off can be achieved by storing some partial sums $`_{s=a}^bn_s`$.

In general, we will use encodings of the form

$$\begin{array}{c}J:^m:|n_0,\mathrm{},n_{m1}|x_0\mathrm{}|x_{m1},\hfill \\ x_j=\underset{sS(j)}{}n_s,S(j)\{0,\mathrm{},m1\}.\hfill \end{array}$$

We start with an example of such an encoding for $`m=8`$ (the diagram next to the equation illustrates grouping of $`n_s`$ into $`x_j`$):

$$\begin{array}{cccc}x_0=n_0\hfill & x_2=n_2\hfill & x_4=n_4\hfill & x_6=n_6\hfill \\ \multicolumn{2}{c}{x_1=n_0+n_1}& \multicolumn{2}{c}{x_5=n_4+n_5}\\ \multicolumn{4}{c}{x_3=n_0+n_1+n_2+n_3}\\ \multicolumn{4}{c}{x_7=n_0+n_1+n_2+n_3+n_4+n_5+n_6+n_7}\end{array}\overline{)\overline{)\overline{)\overline{)n_0}n_1}\overline{)n_2}n_3}\overline{)\overline{)n_4}n_5}\overline{)n_6}n_7}$$

A binary tree structure is apparent here. To proceed, we will represent the qubit indices $`0,\mathrm{},m1`$ by binary strings. The length of these strings is not fixed; we may add an arbitrary number of zeros to the beginning of a string, e.g. $`3=\overline{11}=\overline{011}=\overline{0011}`$.

Let us define a partial order $``$ on the set of binary strings. We write $`\overline{\alpha _{t1}\mathrm{}\alpha _0}\overline{\beta _{t1}\mathrm{}\beta _0}`$ if $`\alpha _l=\beta _l`$ for $`ll_0`$ while $`\beta _{l_01}=\mathrm{}=\beta _0=1`$ (for some $`l_0`$). For example,

$$\begin{array}{c}\hfill \begin{array}{c}\hfill \overline{000}\overline{001}\\ \hfill \overline{010}\end{array}\}\overline{011}\\ \hfill \overline{100}\overline{101}\\ \hfill \overline{110}\end{array}\}\overline{111},$$

where $`jk`$ means that $`jk`$ but $`jk`$. Note that if $`jk`$ then $`j<k`$.

Now we can specify our encoding for arbitrary $`m`$:

$$|n_0,\mathrm{},n_{m1}|x_0\mathrm{}|x_{m1},x_j=\underset{sj}{}n_s.$$
(19)
It is important that each $`n_s`$ enters only $`O(\mathrm{log}m)`$ of $`x_j`$. Hence applying $`\sigma ^x[s]`$ to one logical qubit amounts to logarithmically many $`\sigma ^x`$ gates being applied to the code qubits.

The inverse transformation (from $`x_j`$ to $`n_s`$) is also simple:

$$\begin{array}{c}n_j=x_j\underset{sK(j)}{}x_s,\\ \overline{\alpha _{t1}\mathrm{}\alpha _0}K\left(\overline{\beta _{t1}\mathrm{}\beta _0}\right)\text{if and only if}\hfill \\ \beta _{l_0}=\mathrm{}=\beta _0=1,\alpha _l=\beta _l\text{for}ll_0,\alpha _{l_0}=0\text{(for some }l_0\text{)}.\hfill \end{array}$$
(20)
The sum in (20) contains only $`O(\mathrm{log}m)`$ terms. Moreover, $`y_j=_{s=0}^{j1}n_s`$ can be also expressed as a sum of $`O(\mathrm{log}m)`$ numbers $`x_s`$:

$$\begin{array}{c}y_j=\underset{sL(j)}{}x_s,\\ \overline{\alpha _{t1}\mathrm{}\alpha _0}L\left(\overline{\beta _{t1}\mathrm{}\beta _0}\right)\text{if and only if}\hfill \\ \beta _{l_0}=1,\alpha _l=\beta _l\text{for}l>l_0,\alpha _{l_0}=0,\alpha _{l_01}=\mathrm{}=\alpha _0=1\text{(for some }l_0\text{)}.\hfill \end{array}$$
(21)
It remains to actually represent the LFM extraction operator $`\{j\}`$ by acting on the code qubits. Since $`\{j\}`$ increases the number of qubits by $`1`$, we should add this extra qubit first. We place it at position $`1`$ and initialize by $`|0`$. Then we make its value equal to $`n_j`$ by applying the operators $`\mathrm{\Lambda }(\sigma ^x)[s,1]`$, $`sK(j)\{j\}`$ (see eq. (20)). After that, $`n_j`$ can be turned into $`0`$ by executing the operators $`\mathrm{\Lambda }(\sigma ^x)[1,k]`$, $`kj`$ (see eq. (19)). Finally, we multiply by $`(1)^{n_jy_j}`$ by applying $`\mathrm{\Lambda }(\sigma ^z)[1,s]`$, $`sL(j)`$ (see eq. (21)). To summarize, we execute the operator

$$U^{}=\underset{sL(j)}{}\mathrm{\Lambda }(\sigma ^z)[1,s]\underset{kj}{}\mathrm{\Lambda }(\sigma ^x)[1,k]\underset{sK(j)\{j\}}{}\mathrm{\Lambda }(\sigma ^x)[s,1]$$
(22)
which has the property $`(I_{}J)\{j\}|\xi =U^{}(|0J|\xi )`$ for any $`|\xi `$. This requires $`O(\mathrm{log}m)`$ operations.

Simulating qubits by LFMs is easier and faster. One can use this simple encoding:

$$|n_0|n_1\mathrm{}|n_{m1}|n_0,n_0,n_1,n_1,\mathrm{},n_{m1},n_{m1},$$
(23)
i.e. each qubit is represented by a pair of LFMs with an even number of fermions, $`|0|00`$, $`|1|11`$. Each two-qubit operator $`X`$ is represented by a four-qubit operator $`X^{}`$. The operators $`X^{}[2j,2j+1,2k,2k+1]`$ and $`X^{}\{2j,2j+1,2k,2k+1\}`$ act the same way on the code subspace. So, when we use the encoding (23), it does not matter whether the code elements are qubits or LFMs. The simulation cost is just a constant.

## 6 Majorana fermions

It is possible, at least mathematically, to split each local fermionic mode into two objects. These halves of LFMs are called Majorana fermions.444 In field theory, this term usually means something more specific, but it is sometimes used in this sense too.

Let us introduce a set of Hermitian operators $`c_j`$ ($`j=0,\mathrm{},2m1`$):

$$c_{2k}=a_k+a_k^{}=\sigma ^x[k]\underset{j=0}{\overset{k1}{}}\sigma ^z[j],c_{2k+1}=\frac{a_ka_k^{}}{i}=\sigma ^y[k]\underset{j=0}{\overset{k1}{}}\sigma ^z[j].$$
(24)
These operators satisfy the commutation relations

$$c_jc_k+c_kc_j=2\delta _{jk}.$$
(25)
We can define new locality rules on the algebra $`=𝐋(_0)𝐋(_1)`$ which will be now denoted by $``$. (Also $`\overline{}=𝐋()`$ will be denoted by $`\overline{}`$). We say that there are $`2m`$ sites called Majorana fermions. For each set of sites $`S\{0,\mathrm{},2m1\}`$, let $`\overline{}(S)\overline{}`$ be the subalgebra generated by $`c_j`$, $`jS`$. (Such an algebra is known as complex Clifford algebra). Then $`(S)=\overline{}(S)`$, i. e. physical operators on $`S`$ are linear combinations of even products of $`c_j`$, $`jS`$.

According to this definition, Majorana fermions “exist” in any Fermi system. A nontrivial thing is that it is possible (at least theoretically) to pair them up by interaction, so that few Majorana fermions remain unpaired and separated from each other . Such systems could be used as decoherence-free quantum memory. Indeed, a single Majorana fermion can not interact with the environment by itself (because the operator $`c_j`$ is not physical), so the decoherence can only arise from environment-mediated interaction of two Majorana fermions. But if they are well separated in space, such interaction should be exponentially small (a finite correlation length in the environment is assumed). Roughly speaking, we keep two halves of a qubit apart, so the qubit is decoherence-free!

An application of a Majorana gate is defined as in the case of LFMs. Let $`X`$ be a physical operator acting on $`p`$ Majorana fermions numbered $`0`$ through $`p1`$. Then $`X`$ can be expanded into (even) products of $`c_j`$, $`j=0,\mathrm{},p1`$. If we substitute $`c_{j_r}`$ for $`c_r`$, we will get an operator $`X\{\{j_0,\mathrm{},j_{p1}\}\}(\{j_0,\mathrm{},j_{p1}\})`$.

To find a universal set of Majorana gates, it suffice to rewrite the operators (13), (14) in terms of $`c_0=a_0+a_0^{}`$, $`c_1=i(a_0a_0^{})`$, $`c_2=a_1+a_1^{}`$, $`c_3=i(a_1a_1^{})`$.

$$\begin{array}{c}a_0^{}a_0=\frac{1}{2}(1+ic_0c_1),a_1^{}a_1=\frac{1}{2}(1+ic_2c_3),\\ \mathrm{exp}\left(i\frac{\pi }{4}a_0^{}a_0\right)=e^{i\pi /8}\mathrm{exp}\left(\frac{\pi }{8}c_0c_1\right),\mathrm{exp}\left(i\frac{\pi }{4}(a_0a_0^{})(a_1+a_1^{})\right)=\mathrm{exp}(\frac{\pi }{4}c_1c_2),\\ \mathrm{exp}\left(i\pi a_0^{}a_0a_1^{}a_1\right)=e^{i\pi /4}\mathrm{exp}\left(\frac{\pi }{4}c_0c_1\right)\mathrm{exp}\left(\frac{\pi }{4}c_2c_3\right)\mathrm{exp}\left(i\frac{\pi }{4}c_0c_1c_2c_3\right).\end{array}$$

Hence the following gate set is universal (up to phase factors):

$$\{\mathrm{exp}\left(\frac{\pi }{8}c_0c_1\right),\mathrm{exp}\left(i\frac{\pi }{4}c_0c_1c_2c_3\right)\}.$$
(26)
The second gate in the set (26) describes four-particle interaction. When it comes to physical implementation, this gate will be particularly difficult to realize. Unfortunately, it is not possible to do universal quantum computation by acting on three or fewer Majorana fermions at a time. This way one can only generate the group of unitary operators which act by conjugation as follows:

$$Uc_jU^{}=\underset{k}{}\beta _{jk}c_k,$$
(27)
where $`\beta SO(m)`$, i.e. $`(\beta _{jk})`$ is a real orthogonal matrix with determinant $`+1`$.

## 7 An alternative to the four-particle Majorana gate

In this section we show that, for the purpose of universal computation with Majorana fermions, the gate $`\mathrm{exp}(i\frac{\pi }{4}c_0c_1c_2c_3)`$ can be replaced by a nondestructive eigenvalue measurement of the operator $`c_0c_1c_2c_3`$. (A measurement being nondestructive means that vectors in each of the eigenspaces remain intact; in other words, no extra information is learned or leaks to the environment). Such measurements might be easier to implement, they are also useful in some theoretical application of fermionic computation .

Let us assume that the following operations are possible:

1. Applying the unitary gate $`R=\mathrm{exp}\left(\frac{\pi }{4}c_0c_1\right)`$. (Note that $`Rc_0R^{}=c_1`$, $`Rc_1R^{}=c_0`$).
2. Creation of an ancilla pair in a state which is the eigenstate of $`c_{2k}c_{2k+1}=i(12a_k^{}a_k)`$ corresponding to the eigenvalue $`i`$.
3. Eigenvalue measurement of $`c_jc_k`$.
4. Nondestructive eigenvalue measurement of $`c_jc_kc_rc_s`$.

Moreover, we can base the choice of the next operation on the previous measurement outcomes. (One may call such quantum computation adaptive). Of course, the amount of classical computation involved in this choice should not be too large, so we should better include it into the overall size of the quantum circuit.

Remark. In the standard scheme of quantum computation, measurements in the middle of computation are redundant and can be simulated by unitary gates (e. g. see ). However, this is only true if one uses a universal set of unitary gates. Otherwise measurements and adaptiveness can indeed add extra power to unitary operators.

Suppose we want to apply the operator $`\mathrm{exp}(i\frac{\pi }{4}c_0c_1c_2c_3)`$. Let Majorana fermions 4 and 5 form an ancilla pair, so the input state of the system satisfies

$$(c_4+ic_5)|\mathrm{\Psi }_{\mathrm{in}}=0.$$
(28)
We measure the eigenvalue of $`c_0c_1c_3c_4`$. The outcome is either $`+1`$ or $`1`$, which means that $`|\mathrm{\Psi }_{\mathrm{in}}`$ gets multiplied by the projector $`\mathrm{\Pi }_{+1}^{(4)}=\frac{1}{2}(1+c_0c_1c_3c_4)`$ or $`\mathrm{\Pi }_1^{(4)}=\frac{1}{2}(1c_0c_1c_3c_4)`$, respectively. (More exactly, $`|\mathrm{\Psi }_{\mathrm{in}}p_{\pm 1}^{1/2}\mathrm{\Pi }_{\pm 1}^{(4)}|\mathrm{\Psi }_{\mathrm{in}}`$, where $`p_z`$ is the probability to get outcome $`z`$). Then we measure the eigenvalue of $`c_2c_4`$. The possible eigenvalues $`+i`$ and $`i`$ correspond to the projectors $`\mathrm{\Pi }_{+i}^{(2)}=\frac{1}{2}(1ic_2c_4)`$ and $`\mathrm{\Pi }_i^{(2)}=\frac{1}{2}(1+ic_2c_4)`$. We claim that after some correction depending on the measurements outcomes, we will effectively execute the operator $`\mathrm{exp}(i\frac{\pi }{4}c_0c_1c_2c_3)`$ while leaving the ancilla pair intact. Indeed,

$$\begin{array}{cc}\multicolumn{2}{c}{\mathrm{exp}\left(i\frac{\pi }{4}c_0c_1c_2c_3\right)|\mathrm{\Psi }_{\mathrm{in}}=}\\ \hfill =2\mathrm{exp}\left(\frac{\pi }{4}c_2c_5\right)\frac{1}{2}\left(1ic_2c_4\right)\frac{1}{2}\left(1+c_0c_1c_3c_4\right)|\mathrm{\Psi }_{\mathrm{in}}& =\\ \hfill =2i\mathrm{exp}\left(\frac{\pi }{2}c_0c_1\right)\mathrm{exp}\left(\frac{\pi }{2}c_2c_3\right)\mathrm{exp}\left(\frac{\pi }{4}c_2c_5\right)\frac{1}{2}\left(1ic_2c_4\right)\frac{1}{2}\left(1c_0c_1c_3c_4\right)|\mathrm{\Psi }_{\mathrm{in}}& =\\ \hfill =2i\mathrm{exp}\left(\frac{\pi }{2}c_0c_1\right)\mathrm{exp}\left(\frac{\pi }{2}c_2c_3\right)\mathrm{exp}\left(\frac{\pi }{4}c_2c_5\right)\frac{1}{2}\left(1+ic_2c_4\right)\frac{1}{2}\left(1+c_0c_1c_3c_4\right)|\mathrm{\Psi }_{\mathrm{in}}& =\\ \hfill =2\mathrm{exp}\left(\frac{\pi }{4}c_2c_5\right)\frac{1}{2}\left(1+ic_2c_4\right)\frac{1}{2}\left(1c_0c_1c_3c_4\right)|\mathrm{\Psi }_{\mathrm{in}}& \end{array}$$
(29)
(we have used eq. (28)). Thus we can apply a suitable correction operator $`U_{yz}`$ in each of the four cases ($`U_{+i,+1}=\mathrm{exp}(\frac{\pi }{4}c_2c_5)`$ if the outcomes were $`+1`$ and $`+i`$, etc.) so that

$$\mathrm{exp}\left(i\frac{\pi }{4}c_0c_1c_2c_3\right)|\mathrm{\Psi }_{\mathrm{in}}=\mathrm{\hspace{0.17em}2}U_{yz}\mathrm{\Pi }_y^{(2)}\mathrm{\Pi }_z^{(4)}|\mathrm{\Psi }_{\mathrm{in}}.$$

Each of the four outcome combinations occurs with probability $`2^2=\frac{1}{4}`$. The final state is always the desired one, $`|\mathrm{\Psi }_{\mathrm{fin}}=\mathrm{exp}(i\frac{\pi }{4}c_0c_1c_2c_3)|\mathrm{\Psi }_{\mathrm{in}}`$.

## 8 Superfast simulation of fermions on a graph

The results of Sec. 5 suggest that fermions have slightly more computational power than qubits. The logarithmic slowdown in simulation of fermions seems to be inevitable in the general case. However, in the physical world fermions (e. g. electrons) interact locally not only in the sense that the interaction is pairwise, but also in the geometric sense: a particle can not instantly jump to another position far away. Such physical interactions might be easier to simulate. In this section we study an abstract model of geometrically local interactions. The result is that geometrically local gates can indeed be simulated without any substantial slowdown, i. e. the simulation cost is constant. Therefore one can speculate that, in principle, electrons might not be fundamental particles but, rather, excitations in a (nonperturbative) system bosons. Of course, this is only a logical possibility which may or may not be true.

What follows is a definition of the model. Consider a connected unoriented graph $`\mathrm{\Gamma }=(M,E)`$, where $`M=\{0,\mathrm{},m1\}`$ is the set of vertices, and $`EM\times M`$ is the set of edges. (As the graph is unoriented, $`(j,k)`$ and $`(k,j)`$ either both belong to $`E`$ or both do not belong to $`E`$). We will assume that the degree of each vertex is bounded by some constant $`d`$. Let us put a local fermionic mode on each vertex. We will consider only the even sector of the system, $`_0`$, i. e. the total number of fermions is required to be even. The allowed unitary operations are one-LFM gates and two-LFM gates applied to any pair of vertices connected by an edge.

We are going to identify the Hilbert space $`_0`$ with a codespace of a certain symplectic (stabilizer) code 555The term “stabilizer code” has become traditional but it is somewhat confusing because any code can be defined in terms of stabilizer operators. (It is actually practical to do so for nonbinary codes related to anyons ). We prefer to use the more specific terms “symplectic code” . so that each elementary operator of the form $`a_k^{}a_k`$, as well as $`a_j^{}a_k`$, $`a_k^{}a_j`$, $`a_ja_k`$ or $`a_k^{}a_j^{}`$, where $`(j,k)E`$, be represented by operators acting on $`O(d)`$ qubits. Then each one-LFM gate and each two-LFM gate applied to neighboring vertices will be also represented by an operator acting on $`O(d)`$ qubits. As $`d=\mathrm{const}`$, this means one can simulate each of the allowed fermionic operations by a constant number of one-qubit and two-qubit gates.

It will be convenient to use the Majorana fermions operators $`c_{2k}`$, $`c_{2k+1}`$ (see eq. (24)) instead of $`a_k`$, $`a_k^{}`$. The list of elementary operators to be represented can be reduced to these ones:

$$\begin{array}{cccc}\hfill B_k& =& ic_{2k}c_{2k+1}\hfill & \text{for each vertex}k,\hfill \\ \hfill A_{jk}& =& ic_{2j}c_{2k}\hfill & \text{for each edge}(j,k)E.\hfill \end{array}$$
(30)
These operators satisfy the following relations:

$$B_k^{}=B_k,A_{jk}^{}=A_{jk},B_k^2=1,A_{jk}^2=1,A_{kj}=A_{jk},$$
(31)
$$B_kB_l=B_lB_k,A_{jk}B_l=(1)^{\delta _{jl}+\delta _{kl}}B_lA_{jk},A_{jk}A_{ls}=(1)^{\delta _{jl}+\delta _{js}+\delta _{kl}+\delta _{ks}}A_{ls}A_{jk},$$
(32)
$$i^pA_{j_0,j_1}A_{j_1,j_2}\mathrm{}A_{j_{p2},j_{p1}}A_{j_{p1},j_0}=\mathrm{\hspace{0.17em}1}\text{for any closed path on the graph}.$$
(33)
It is easy to prove that $`B_k`$, $`A_{jk}`$ modulo these relations generate the algebra of physical operators $`=𝐋(_0)𝐋(_1)`$. However, we are considering only the even sector now. Having been restricted to $`_0`$, the operators $`B_k`$ satisfy an additional relation (which was false in $``$):

$$\underset{k}{}B_k=1.$$
(34)
Hence the algebra $`𝐋(_0)`$ is generated by $`B_k`$, $`A_{jk}`$ modulo the relations (31)–(34).

To construct the code, we put a qubit on each edge of the graph. Thus $`\sigma _{jk}^\alpha =\sigma _{kj}^\alpha `$ denotes the Pauli operator $`\sigma ^\alpha `$$`(\alpha =x,y,z)`$ acting on the edge $`(j,k)`$. The operators $`B_k`$, $`A_{jk}`$ defined above will be identified with some operators $`\stackrel{~}{B}_k`$, $`\stackrel{~}{A}_{jk}`$ acting on the code subspace $``$ (which will be defined later). We start with defining the action of $`\stackrel{~}{B}_k`$ and $`\stackrel{~}{A}_{jk}`$ on the entire Hilbert space of the qubits. Our construction depends on two arbitrary choices. Firstly, we choose orientation for each edge of the graph. This can be described by a matrix $`(ϵ_{jk})`$ such that $`ϵ_{kj}=ϵ_{jk}`$, $`ϵ_{jk}=\pm 1`$ for each edge $`(j,k)E`$. Secondly, for each vertex $`k`$, we order all incident edges $`(j,k)`$. This order will be denoted by $`\underset{k}{<}`$. Now we put

$$\begin{array}{ccc}\hfill \stackrel{~}{B}_k& =& \underset{j:(j,k)E}{}\sigma _{jk}^z,\hfill \\ \hfill \stackrel{~}{A}_{jk}& =& ϵ_{jk}\sigma _{jk}^x\underset{l:(l,j)\underset{j}{<}(k,j)}{}\sigma _{lj}^z\underset{s:(s,k)\underset{k}{<}(j,k)}{}\sigma _{sk}^z.\hfill \end{array}$$
(35)
These operators satisfy the relations analogous to (31), (32) and (34), but not (33).

Finally, we define the code subspace $`^u`$ (where $`u`$ is the number of qubits) by imposing stabilizer conditions:

$$\begin{array}{c}|\psi \text{if and only if}\stackrel{~}{C}_{j_0,\mathrm{},j_{p1}}|\psi =|\psi \text{for any closed path}(j_0,\mathrm{},j_{p1},j_0),\\ \stackrel{~}{C}_{j_0,\mathrm{},j_{p1}}=i^p\stackrel{~}{A}_{j_0,j_1}\stackrel{~}{A}_{j_1,j_2}\mathrm{}\stackrel{~}{A}_{j_{p2},j_{p1}}\stackrel{~}{A}_{j_{p1},j_0}.\end{array}$$
(36)
The stabilizer operators $`\stackrel{~}{C}_{j_0,\mathrm{},j_{p1}}`$ are Hermitian and can be represented in the form $`\pm _{(j,k)}\sigma _{jk}^{\alpha _{jk}}`$, where $`(j,k)`$ runs over a set of different qubits. The set of stabilizer operators is obviously redundant but it is consistent, meaning that (i) they commute with each other, and (ii) whenever the product of several stabilizer operators is a constant, this constant is $`1`$. The number of independent stabilizer operators equals the number of linearly$`(mod2)`$ independent cycles which in turn equals $`um+1`$. Hence

$$dim=2^{u(um+1)}=2^{m1}=dim_0.$$
(37)
The operators $`\stackrel{~}{B}_k`$, $`\stackrel{~}{A}_{jk}`$ commute with $`\stackrel{~}{C}_{j_0,\mathrm{},j_{p1}}`$, so they leave the code subspace invariant. The restrictions of these operators, $`\stackrel{~}{B}_k|_{}`$ and $`\stackrel{~}{A}_{jk}|_{}`$, satisfy the relations analogous to (31)–(34). Thus the correspondence $`B_k\stackrel{~}{B}_k|_{}`$, $`A_{jk}\stackrel{~}{A}_{jk}|_{}`$ extends to a $``$-algebra homomorphism $`\mu :𝐋(_0)𝐋()`$. But $`dim=dim_0`$, hence $`\mu `$ is an isomorphism. It can be represented as $`\mu (X)=JXJ^{}`$, where $`J:_0`$ is a unitary map which is unique up to an overall phase.

Now that the main construction is complete, we can give exact rules for converting the allowed (geometrically local) operations on LFMs into qubit gates. These rules are almost obvious but still worth putting them into a rigorous form. For most generality, consider a two-LFM gate application $`U\{j,k\}`$, where $`(j,k)E`$. Here $`U`$ is a physical operator acting on 2 LFMs ($`=`$ 4 Majorana fermions $`=`$ 2 qubits), so it can be expressed in terms of $`A=ic_0c_2=\sigma ^y[0]\sigma ^x[1]`$, $`B^{}=ic_0c_1=\sigma ^z[0]`$ and $`B^{\prime \prime }=ic_2c_3=\sigma ^z[1]`$. Applying $`U`$ to LFMs $`j`$ and $`k`$ means substituting $`A_{jk}`$, $`B_j`$, $`B_k`$ for $`A`$, $`B^{}`$, $`B^{\prime \prime }`$. Instead of that, we actually do another substitution:

$$\nu _{jk}:A\stackrel{~}{A}_{jk},B^{}\stackrel{~}{B}_j,B^{\prime \prime }\stackrel{~}{B}_k.$$
(38)
It extends to a $``$-algebra homomorphism $`𝒢𝐋(^{S_{jk}})`$, where $`𝒢`$ is the algebra generated by $`A`$, $`B^{}`$ and $`B^{\prime \prime }`$ ($`=`$ the algebra of parity-preserving operators on two qubits), and $`S_{jk}`$ is the set of qubits consisting of all edges incident to $`j`$ and $`k`$. (Note that we do not have to restrict $`\stackrel{~}{A}_{jk}`$, $`\stackrel{~}{B}_j`$, $`\stackrel{~}{B}_k`$ to the subspace $``$ because the cycle relation (33) is irrelevant in this context). So, $`U\{j,k\}`$ is simulated by $`\nu _{jk}(U)`$.

It turns out that this simulation is pretty efficient even if $`d`$ ($`=`$ the largest degree of a vertex in the graph) is not a constant. W. l. o. g. $`m>2`$, so $`S_{jk}`$ contains at least one edge besides $`(j,k)`$, say, $`(j,l)`$. Then $`\stackrel{~}{B}_j`$, $`\stackrel{~}{B}_k`$ and $`\stackrel{~}{A}_{jk}`$ have no nontrivial relations (like $`\stackrel{~}{B}_j\stackrel{~}{B}_k=1`$). More exactly, the map $`\nu _{jk}`$ is injective, so $`\stackrel{~}{B}_j`$, $`\stackrel{~}{B}_k`$ and $`\stackrel{~}{A}_{jk}`$ satisfy exactly the same relations as $`\sigma ^z[0]`$, $`\sigma ^z[1]`$ and $`\sigma ^y[0]\sigma ^x[1]`$. It follows that there is a “symplectic transformation”  of the form $`XWXW^{}`$ which takes $`\stackrel{~}{B}_j`$, $`\stackrel{~}{B}_k`$ and $`\stackrel{~}{A}_{jk}`$ to $`\sigma _{jl}^z`$, $`\sigma _{jk}^z`$ and $`\sigma _{jl}^y\sigma _{jk}^x`$. The unitary operator $`W`$ acts on the qubits from $`S_{jk}`$ and can be represented as a product of elementary “symplectic gates”: $`H`$, $`\mathrm{\Lambda }(\sigma ^x)`$ and $`\mathrm{\Lambda }(i)`$. It is easy to show that $`O(d)`$ applications of these gates are sufficient. Hence executing the operator

$$\nu _{jk}(U)=W^{}U[(j,l),(j,k)]W$$
(39)
takes $`O(d)`$ one-qubit and two-qubit gate applications.

In the above analysis, we did not take into account the number of operations required to prepare an initial state $`|\psi `$, which is necessary to begin simulation. For definiteness, we will consider the unique quantum state $`|\xi `$ which satisfies additional constraints:

$$\stackrel{~}{B}_k|\xi =|\xi \text{for each}k.$$
(40)
Note that $`B_k=ic_{2k}c_{2k+1}=12a_k^{}a_k`$, so $`|\xi `$ represents the fermionic state $`|0,\mathrm{},0`$. By a general argument, the qubit state $`|0\mathrm{}|0`$ can be transformed into $`|\xi `$ by applying $`O(u^2)`$ symplectic gates.

However, if we continue the speculations about fermions being possibly mimicked by bosons, the vacuum state of the bosonic system must absorb new degrees of freedom as the Universe expands. Certainly, this process should be reversible, i. e. it should also work when the space shrinks. In our model, shrinking the space corresponds to contracting some edges. More specifically, contracting an edge $`(j,k)`$ means removing it while identifying the vertices $`j`$ and $`k`$. If both $`j`$ and $`k`$ are connected to the same vertex $`l`$, a double edge between $`jk`$ and $`l`$ appears; it must be then reduced to a single one. We should be able to update our “vacuum state” $`|\xi `$ through these transformations. (The qubit being removed should come out in the state $`|0`$). One can show that a single contraction or reduction step requires $`O(d)`$ symplectic gates. This does not involve any nonlocality and can be done simultaneously in different places, which is quite consistent with the idea of adiabatic vacuum transformation in the expanding Universe.

## 9 Quantum codes by Majorana fermions

Some symplectic codes on qubits can be conveniently described in terms of Majorana fermions. We will show how it works for the Shor code . Whether this approach can help to find new codes still remains to be seen.

By inverting the formula (24), we can represent the operators $`a_k,a_k^{}`$ in terms of the Majorana operators: $`a_k=\frac{1}{2}(c_{2k}+ic_{2k+1})`$, $`a_k^{}=\frac{1}{2}(c_{2k}ic_{2k+1})`$. However, one can also introduce another set of annihilation and creation operators which will satisfy the same commutation relations:

$$b_k=\frac{1}{2}\left(c_{\tau (2k)}+ic_{\tau (2k+1)}\right),b_k^{}=\frac{1}{2}\left(c_{\tau (2k)}ic_{\tau (2k+1)}\right),$$
(41)
where $`\tau :\{0,\mathrm{},2m1\}\{0,\mathrm{},2m1\}`$ is arbitrary permutation on $`2m`$ elements. One can define a quantum code by fixing the occupation numbers of some of the new LFMs, e. g. by requiring that each codevector $`|\psi `$ satisfies $`b_k^{}b_k|\psi =0`$ for $`k=1\mathrm{}m1`$. In other words, the set of stabilizer operators is

$$X_k=ic_{\tau (2k)}c_{\tau (2k+1)},k=1,\mathrm{}m1.$$
(42)
The number of encoded qubits is $`m(m1)=1`$. The logical operators for this code are generated by $`c_{\tau (0)}`$ (the encoded $`\sigma ^x`$) and $`c_{\tau (1)}`$ (the encoded $`\sigma ^y`$).

Thus each permutation $`\tau :\{0,\mathrm{},2m1\}\{0,\mathrm{},2m1\}`$ defines a quantum code which encodes $`1`$ qubit into $`m`$ qubits. It turns out that these codes can have arbitrary large code distances. We are to define a family of such codes which can be considered as slightly modified Shor codes. Let $`l2`$ be an integer (the index of a code in the family), $`m=l^2`$. There will be two types of stabilizer operators:

$$\begin{array}{cccc}\hfill Z_k& =& ic_{2kl+1}c_{2(k+2)l2},\hfill & k=0\mathrm{}l2,\hfill \\ \hfill Y_{k,j}& =& ic_{2kl+2j+3}c_{2kl+2j},\hfill & k=0,\mathrm{}l1,j=0,\mathrm{}l2.\hfill \end{array}$$
(43)
They can be expressed in terms of the Pauli operators as follows :

$$Z_k=\sigma ^x[kl]\sigma ^x[(k+2)l1]\underset{s=kl+1}{\overset{(k+2)l2}{}}\sigma ^z[s],Y_{k,j}=\sigma ^y[kl+j]\sigma ^y[kl+j+1]$$
(44)
For example, let us consider the $`l=3`$ code. Its 9 qubits can be arranged into a $`3\times 3`$ array as follows

$$\begin{array}{ccc}0,& 1,& 2,\\ 3,& 4,& 5,\\ 6,& 7,& 8.\end{array}$$

Then the stabilizer operators of the first type become:

$$Z_0=\left(\begin{array}{ccc}\sigma ^x,& \sigma ^z,& \sigma ^z,\\ \sigma ^z,& \sigma ^z,& \sigma ^x,\\ I,& I,& I\end{array}\right),Z_1=\left(\begin{array}{ccc}I,& I,& I,\\ \sigma ^x,& \sigma ^z,& \sigma ^z,\\ \sigma ^z,& \sigma ^z,& \sigma ^x\end{array}\right).$$

(These are not matrices. We just mean that, for example, $`Z_0=\sigma ^x\sigma ^z\sigma ^z\sigma ^z\sigma ^z\sigma ^xIII`$). The stabilizer operators of the second type are

$$\begin{array}{c}Y_{0,0}=\left(\begin{array}{ccc}\sigma ^y,& \sigma ^y,& I,\\ I,& I,& I,\\ I,& I,& I\end{array}\right),Y_{0,1}=\left(\begin{array}{ccc}I,& \sigma ^y,& \sigma ^y,\\ I,& I,& I,\\ I,& I,& I\end{array}\right),Y_{1,0}=\left(\begin{array}{ccc}I,& I,& I,\\ \sigma ^y,& \sigma ^y,& I,\\ I,& I,& I\end{array}\right),\text{}\\ Y_{1,1}=\left(\begin{array}{ccc}I,& I,& I,\\ I,& \sigma ^y,& \sigma ^y,\\ I,& I,& I\end{array}\right),Y_{2,0}=\left(\begin{array}{ccc}I,& I,& I,\\ I,& I,& I,\\ \sigma ^y,& \sigma ^y,& I\end{array}\right),Y_{2,1}=\left(\begin{array}{ccc}I,& I,& I,\\ I,& I,& I,\\ I,& \sigma ^y,& \sigma ^y\end{array}\right).\end{array}$$

If one performs the cyclic permutation $`\sigma ^x\sigma ^y\sigma ^z\sigma ^x`$, the operators $`Y_{k,j}`$ turn into certain stabilizer operators of the Shor code. The operators $`Z_k`$ will not become exactly the same as in the Shor code. Each of them will contain two $`\sigma ^y`$ instead of $`\sigma ^x`$. However, the code distance of this code is the same, namely, $`3`$.

For arbitrary $`l`$, the code distance is $`d_l=l`$. (The proof is essentially the same as for the Shor code).