An Efficient Algorithmic Way to Construct Boltzmann Machine Representations for Arbitrary Stabilizer Code

Abstract

Restricted Boltzmann machines (RBMs) have demonstrated considerable success as variational quantum states; however, their representational power remains incompletely understood. In this work, we present an analytical proof that RBMs can exactly and efficiently represent stabilizer code states—a class of highly entangled quantum states that are central to quantum error correction. Given a set of stabilizer generators, we develop an efficient algorithm to determine both the RBM architecture and the exact values of its parameters. Our findings provide new insights into the expressive power of RBMs, highlighting their capability to encode highly entangled states, and may serve as a useful tool for the classical simulation of quantum error-correcting codes.

1. Introduction

To conquer one of the main challenges, the dimensionality problem (also known as Hamiltonian complexity [1,2]), in condensed matter physics, many different representations of quantum many-body states are developed. For example, the well-known tensor network representations [3,4,5] including density-matrix renormalization group (DMRG) [6], matrix product states (MPS) [5], projected entangled pair states (PEPS) [5,7], folding algorithm [8], entanglement renormalization [9], time-evolving block decimation (TEBD) [10], string-bond state, [11] etc., have gradually became standard methods for solving quantum many-body problems. The efficiency of tensor network representations is known to be partially based on the entanglement properties of the state.

In recent years, a new representation based on a shallow neural network—the restricted Boltzmann machine (RBM)—was introduced by Carleo and Troyer [12]. They demonstrated the expressive power of this representation by computing the ground states and unitary dynamics of the transverse-field Ising model and the antiferromagnetic Heisenberg model. Subsequently, various aspects of the RBM representation have been explored. Deng et al. analyzed the entanglement properties of RBM states [13], while Gao and Duan extended the framework to deep Boltzmann machines (DBM) [14], and the entanglement property of DBM state is given in [15]. The connections between tensor networks and RBM representations have also been investigated in Refs. [14,16,17,18]. Moreover, many other neural network architectures, like convolutional neural network, transformer neural network, etc., have been proposed for the efficient representation of quantum many-body states (and density operator), see, e.g., [19,20,21,22,23,24]; see Refs. [25,26,27,28] for comprehensive reviews and outlooks.

A central problem in the study of RBM states is trying to understand their representational power. Although the universality of RBMs has long been established [29], the number of hidden neurons required to represent an arbitrary distribution generally scales exponentially, rendering such constructions impractical. For RBM-based quantum states, despite numerous numerical investigations, analytical results remain scarce.

Notable analytical results on RBM representations for specific quantum states include the toric code state [30], the one-dimensional symmetry-protected topological (SPT) cluster state [30], and the graph state [14]. In Ref. [31], we investigated the RBM representation of the planar code within the stabilizer formalism and explicitly constructed sparse RBM architectures for specific stabilizer groups. However, a general construction remains elusive. Since the publication of the preprint version of this work, several studies have further explored neural network representations of code states of stabilizer codes (or equivalently ground state of local commutative Hamiltonian); see, for example, Refs. [32,33,34].

In this work, we comprehensively investigate the RBM representation for stabilizer code states [35,36] that cover a larger class of states than studied before. An algorithmic way to construct RBM parameters of an arbitrary stabilizer group is given, which gives a complete solution for the problem of understanding the representational power of RBM in the stabilizer formalism.

The paper is organized as follows. In Section 2 and Section 3, we begin by reviewing some basic concepts of RBM states and stabilizer codes. In Section 4, we provide a detailed discussion on how to construct an RBM state for a given stabilizer code. The final section offers concluding remarks and an outlook for future work.

2. Preliminary Notions

An RBM is a two-layer neural network consisting of n visible neurons $v_i\in {\{0,1\}}^n$ and m hidden neurons $h_j\in {\{0,1\}}^m$; see Figure 1. The connections between the visible and hidden layers are specified by a weight matrix $W_{ij}$, while $a_i$ and $b_j$ denote the bias terms for the visible and hidden neurons, respectively. These parameters define a joint probability distribution over visible and hidden units:

$$p(\mathbf{v},\mathbf{h})={\displaystyle \frac{1}{Z}}exp\left(\sum _i{a}_i{v}_i+\sum _j{b}_j{h}_j+\sum _{i,j}{W}_{ij}{v}_i{h}_j\right),$$

(1)

where the partition function Z is given by

$$Z=\sum _{\mathbf{v},\mathbf{h}}exp\left(\sum _i{a}_i{v}_i+\sum _j{b}_j{h}_j+\sum _{i,j}{W}_{ij}{v}_i{h}_j\right).$$

(2)

To represent a quantum many-body state, we map the local degrees of freedom of the quantum system onto the visible neurons and trace out the hidden neurons, yielding

$$\begin{array}{cc}\hfill {\psi }_{\mathrm{RBM}}\left(\mathbf{v}\right)& =\sum _{\mathbf{h}}p(\mathbf{v},\mathbf{h})\hfill \\ \hfill & ={\displaystyle \frac{1}{Z}}exp\left(\sum _i{a}_i{v}_i\right)\prod _j\left(1+exp\left(b_j+\sum _i{v}_i{W}_{ij}\right)\right),\hfill \\ \hfill |{\mathsf{\Psi }}_{\mathrm{RBM}}\rangle & =\sum _{\mathbf{v}}{\psi }_{\mathrm{RBM}}\left(\mathbf{v}\right)|\mathbf{v}\rangle .\hfill \end{array}$$

(3)

The parameters of the RBM can be chosen as complex numbers, in which case the resulting joint distribution $p(\mathbf{v},\mathbf{h})$ can take complex values. For more details, see, e.g., Refs. [12,26,31].

A stabilizer group $\mathbf{S}$ is defined as an Abelian subgroup of the Pauli group ${\mathbf{P}}_n={\{I,X,Y,Z\}}^{\otimes n}\times \{\pm 1,\pm i\}$ that stabilizes an invariant subspace $\mathcal{C}$ of the total space $\mathcal{H}={\left({\mathbb{C}}^2\right)}^{\otimes n}$ with n physical qubits. The space $\mathcal{C}$ is called the code space of the stabilizer group $\mathbf{S}$. More precisely, $\forall T\in \mathbf{S},\forall |\mathsf{\Psi }\rangle \in \mathcal{C}$, the equation $T|\mathsf{\Psi }\rangle =|\mathsf{\Psi }\rangle$ is always satisfied. Suppose $\mathbf{S}$ is generated by m independent operators, $\mathbf{S}=\langle T_1,T_2,\cdots ,T_m\rangle$. It is easy to check the following properties for the stabilizer operators:

• $T_j^2=I$ for all j, $[T_i,T_j]=0$ and $-I,\pm iI\notin \mathbf{S}$.
• $\langle T_1,\cdots ,T_k,\cdots ,T_m\rangle =\langle T_1,\cdots ,T_j{T}_k,\cdots ,T_m\rangle$, for any $j\ne k$.

We refer the reader to Ref. [37] for more details about the stabilizer code.

Our goal is to find the RBM representation of code states $|{\mathsf{\Psi }}_L\rangle \in \mathcal{C}$. We present an explicit algorithm to construct a set of basis code states $\left\{\right|{\mathsf{\Psi }}_L\rangle \}$ that span the code space $\mathcal{C}$ for an arbitrary stabilizer group. To summarize, we aim to address the following problem:

Problem 1.

Given a stabilizer group $\mathbf{S}$ generated by m independent stabilizer operators $T_1,\cdots ,T_m$, does an efficient RBM representation of the code states $|{\mathsf{\Psi }}_L\rangle$ exist? If so, how can one determine the corresponding RBM parameters?

To answer this, we first introduce the standard form of a stabilizer code [35,36,37].

3. Standard Form of Stabilizer Code

Every Pauli operator $T_k$ that squares to identity can be written as ${\alpha }_{k}P(x_1,z_1)\otimes P(x_2,z_2)\otimes \cdots \otimes P(x_n,z_n)$, where ${\alpha }_k=\pm 1$ is a phase factor, and $P(x_i,z_i)$ is one of the Pauli matrices,

$$P(x_i,z_i)=\left\{\begin{array}{cc}I\hfill & \mathrm{if}{x}_i=0,z_i=0\hfill \\ X\hfill & \mathrm{if}{x}_i=1,z_i=0\hfill \\ Y\hfill & \mathrm{if}{x}_i=1,z_i=1\hfill \\ Z\hfill & \mathrm{if}{x}_i=0,z_i=1\hfill \end{array}\right.$$

In this way, every stabilizer operator $T_k$ can be written as the combination of a phase factor ${\alpha }_k$ and a binary vector $a_k=(x_1,\cdots ,x_n,z_1,\cdots ,z_n)$. It is easy to prove that if $T_l=T_j{T}_k$, then $a_l=a_j\oplus a_k$, where ⊕ denotes the bitwise addition modulo 2.

For the set of stabilizer generators $\{T_1,\cdots ,T_m\}$, we can stack all binary vectors $a_k$ together to form an $m\times 2n$ matrix A, called the check matrix [37]. Each row of A is a vector $a_k$ that corresponds to a stabilizer operator $T_k$. To clarify the notation, we denote $A=\left(A_X\right|A_Z)$, where $A_X$ and $A_Z$ are $m\times n$ matrices denoting the x and z part of the binary vector a, respectively. Since $\{T_1,\cdots ,T_k,\cdots ,T_m\}$ and $\{T_1,\cdots ,T_j{T}_k,\cdots ,T_m\}$ generate the same stabilizer group, one can add one row of A to another row of A (modulo 2) without changing the code space $\mathcal{C}$. Meanwhile, swapping the p-th and q-th row of A corresponds to relabeling the stabilizer generators $T_p\leftrightarrow T_q$, and simultaneously swapping the p-th and q-th column of both $A_X$ and $A_Z$ corresponds to relabeling the qubits $v_p\leftrightarrow v_q$.

With adding and swapping operations, we can perform Gaussian elimination to the check matrix A [37,38]. This leads us to the standard form of a stabilizer group. This procedure is well-established, and one can refer to [37] for a detailed explanation. Here, we briefly outline the routine and clarify the notation:

We start from the original check matrix $A=\left(A_X\right|A_Z)$. Performing Gaussian elimination to $A_X$, we obtain

(4)

where $I_p$ is a $p\times p$ identity. Note that we must keep track of the phase factors $\{{\alpha }_1,\cdots ,{\alpha }_m\}$ during this procedure. Further performing Gaussian elimination to F, we can obtain another identity $I_q$:

(5)

Finally, we can use $I_q$ to eliminate $D_1$:

(6)

Equation (6) is called the standard form of a stabilizer code. There are $p+q$ independent stabilizer generators, and the number of qubits encoded is $k=n-p-q$. If the stabilizer generators we start with are not independent of each other, zero rows will be encountered during the elimination, which we can simply discard in order to reach a set of independent generators.

One advantage of Equation (6) is that it is easy to construct logical X and Z operators from it. The check matrix for logical X and Z operators, $\overline{X}$ and $\overline{Z}$, can be chosen as follows:

$$\begin{array}{cc}\hfill & A_{\overline{X}}=\left(0F_1^{T}I\right|D_3^{T}00),\hfill \\ \hfill & A_{\overline{Z}}=\left(000\right|B_2^{T}0I).\hfill \end{array}$$

(7)

One can verify that these operators all commute with the stabilizer generators and commute with each other, except that ${\overline{X}}_j$ anti-commutes with ${\overline{Z}}_j$ [37].

4. RBM Representation for an Arbitrary Stabilizer Group

In this section, we illustrate how to construct the RBM representation for any given stabilizer group.

Suppose the set of stabilizer generators have already been brought into a standard form like Equation (6). To start, we need to specify one code state in the code space $\mathcal{C}$. As an example, we choose the logical Z eigenstate with eigenvalue 1, i.e., ${\overline{Z}}_i|\mathsf{\Psi }\rangle =|\mathsf{\Psi }\rangle ,1\le i\le k$. We can see that we are actually treating the logical Z operators ${\overline{Z}}_i$ as new independent stabilizer operators, and the stabilized subspace is narrowed down to containing one state only. The set of independent stabilizer generators now becomes $\{T_1,\cdots ,T_m,{\overline{Z}}_1,\cdots ,{\overline{Z}}_k\}$, with the new check matrix being

(8)

Upon introducing new independent stabilizer operators, Equation (8) can be further simplified. Eliminating $D_3$ and $F_1$ with $I_k$, we obtain the final form of the check matrix:

(9)

where $r=q+k$, and $p+r=n$. Denote the n stabilizer generators corresponding to Equation (9) as $\{{\tilde{T}}_1,\cdots ,{\tilde{T}}_n\}$. We call ${\tilde{T}}_1,\cdots ,{\tilde{T}}_p$ X-type stabilizers, denoted by ${\tilde{T}}^x$, and ${\tilde{T}}_{p+1},\cdots ,{\tilde{T}}_n$ Z-type stabilizers, denoted by ${\tilde{T}}^z$.

With n qubits, the n stabilizer operators uniquely determines one stabilizer code state. Next, we explicitly construct this state and then translate it into the parameters of an RBM.

We start with the full expansion of the quantum state in the Pauli-Z basis

$$|\mathsf{\Psi }\rangle =\sum _{\mathbf{v}\in {\{0,1\}}^n}\psi \left(\mathbf{v}\right)|\mathbf{v}\rangle$$

(10)

where $\mathbf{v}=(v_1,v_2,\cdots ,v_n)$.

Because $|\mathsf{\Psi }\rangle$ is a stabilizer state, every generator ${\tilde{T}}_i$ satisfies ${\tilde{T}}_i|\mathsf{\Psi }\rangle =|\mathsf{\Psi }\rangle$. Applying ${\tilde{T}}_i$ on the expansion gives

$$\sum _{\mathbf{v}}\psi \left(\mathbf{v}\right)|\mathbf{v}\rangle =\sum _{\mathbf{v}}\psi \left(\mathbf{v}\right){\tilde{T}}_i|\mathbf{v}\rangle$$

(11)

To begin, we consider a Z-type stabilizer ${\tilde{T}}_i^z,i\in \{p+1,\cdots ,n\}$. By construction, it contains only the single-qubit operators Z or I and an overall phase ${\alpha }_i$. Therefore, it is diagonal in the computational basis:

$${\tilde{T}}_i^z|\mathbf{v}\rangle ={\varphi }_i\left(\mathbf{v}\right)|\mathbf{v}\rangle ,{\varphi }_i\left(\mathbf{v}\right)={\alpha }_i{(-1)}^{{\sum }_{j:Z_j\in {\tilde{T}}_z}{v}_j}\in \{+1,-1\}$$

(12)

Plugging this into Equation (11), we obtain

$$\psi \left(\mathbf{v}\right)={\varphi }_i\left(\mathbf{v}\right)\psi \left(\mathbf{v}\right)$$

(13)

Hence, for every basis string either ${\varphi }_i\left(\mathbf{v}\right)=+1$, in which case $\psi \left(\mathbf{v}\right)$ may be non-zero; or ${\varphi }_i\left(\mathbf{v}\right)=-1$, in which case $\psi \left(\mathbf{v}\right)$ must vanish. Each Z-type stabilizer therefore imposes a simple parity rule on the bit string: only those $\mathbf{v}$ whose selected qubits sum to an even (or odd) parity survive.

After Gaussian elimination, the full check matrix has the block form, Equation (9), and the bottom-right block corresponds to the $r=n-p$ Z-type stabilizers.

Crucially, each of these r generators acts with a single Z on a distinct one of the last r qubits. Because of this, once the first p qubits $(v_1,\cdots ,v_p)$ are fixed, the parity constraints from the Z-type stabilizers uniquely determine the remaining r bits.

Using the notation of the check matrix

$$\left(00|E{I}_r\right),$$

(14)

the parity constraint can be expressed as

$$\begin{array}{cc}\hfill d_j=& \left(1+{\alpha }_j{(-1)}^{{\sum }_k{E}_{jk}{v}_k}\right)/2\hfill \\ \hfill =& \left(1+exp(log{\alpha }_j+i\pi \sum _k{E}_{jk}{v}_k)\right)/2\hfill \\ \hfill =& \left\{\begin{array}{cc}1,\hfill & \mathrm{constraint}\mathrm{satisfied},\hfill \\ 0,\hfill & \mathrm{constraint}\mathrm{violated}.\hfill \end{array}\right.\hfill \end{array}$$

(15)

In an RBM, Equation (15) can be implemented by adding a hidden neuron $h_j$ with bias $log{\alpha }_j$ and weight $W_{kj}=i\pi$ between $v_k$ and $h_j$.

We will, therefore, label any basis state that does satisfy all Z-type constraints as

$$|v_1{v}_2\cdots v_p\times \cdots \times \rangle ,$$

(16)

where the “×” symbols stand for the uniquely determined values of qubits $p+1,\cdots ,n$. All other computational-basis states have an amplitude of zero.

We have already seen that the $r=n-p$ Z-type generators keep only those basis strings $|v_1{v}_2\cdots v_p\times \cdots \times \rangle$ that satisfy their parity rules. What remains is to determine the complex amplitude attached to each of those surviving strings. That information is contained in the p X-type stabilizers ${\tilde{T}}_1^x,\cdots ,{\tilde{T}}_p^x$.

In the reduced check matrix

$$\left(I_{p}B|C0\right),$$

(17)

• The identity block $I_p$ says that ${\tilde{T}}_j^x$ flips only qubit j;
• The matrix C tells us which qubits carry an extra Z in ${\tilde{T}}_j^x$;
• The matrix B flips the “×” qubits that are uniquely determined by the Z-type stabilizers. As stabilizers commute, the flips are consistent with the parity constraints, and we can ignore them for now;
• The zeros in the last r columns guarantee that none of the “×” qubits contributes any phase.

Because all generators commute, we can build any allowed basis string by starting from the “all-zero” string

$$|00\cdots 0\times \cdots \times \rangle ,$$

(18)

and applying ${\tilde{T}}_j^x$ exactly when $v_j=1$.

Acting with ${\tilde{T}}_j^x$ flips the bit $v_j\to {\overline{v}}_j=1-v_j$ and multiplies the state by a phase

$$c_j\left(\mathbf{v}\right)={\alpha }_j{(-1)}^{{\sum }_k{C}_{jk}{v}_k}=exp\left(log{\alpha }_j+i\pi \sum _k{C}_{jk}{v}_k\right)\in \{\pm 1,\pm i\}$$

(19)

where ${\alpha }_j\in \{\pm 1,\pm i\}$ is the overall phase appearing in ${\tilde{T}}_j^x$.

Because ${\tilde{T}}_j^x|\mathsf{\Psi }\rangle =|\mathsf{\Psi }\rangle$, we must have

$$\psi (v_1\cdots {\overline{v}}_j\cdots v_p\times \cdots \times )=c_j\left(\mathbf{v}\right)\psi (v_1\cdots v_j\cdots v_p\times \cdots \times )$$

(20)

for every admissible $\mathbf{v}$.

With an unnormalized state, without loss of generality, we start with the reference amplitude

$$\psi (0,0,\cdots ,0,\times ,\cdots ,\times )\equiv 1$$

(21)

and successively apply Equation (20) for $j=1$ up to p. Let ${\mathbf{v}}_j=(v_1,\cdots ,v_j,0,\cdots ,0,\times ,\cdots ,\times )$, this procedure yields

$$\begin{array}{cc}\hfill \psi (v_1,\cdots ,v_p,\times ,\cdots ,\times )=& \prod _{j=1}^p{\left[c_j\left({\mathbf{v}}_{j-1}\right)\right]}^{v_j}\hfill \\ \hfill =& exp\left(\sum _j{v}_{j}log{\alpha }_j+i\pi \sum _{k<j}{C}_{jk}{v}_j{v}_k\right)\hfill \end{array}$$

(22)

In other words, every time a bit $v_j=1$, we pick up a phase factor $c_j$. Equation (22) completely specifies the unnormalized wave function on all basis states that survive the Z-type constraints, and is already in the general form of a Boltzmann machine.

Combining Equation (22) with Equation (15), we obtain the full expression of the (unnormalized) wave function:

$$\begin{array}{cc}\hfill \psi (v_1,v_2,\cdots ,v_n)=& exp\left(\sum _{j=1}^p{v}_{j}log{\alpha }_j+i\pi \sum _{k<j}{C}_{jk}{v}_j{v}_k\right)\hfill \\ \hfill ·& \prod _{j=p+1}^n\left(1+exp(log{\alpha }_j+i\pi \sum _k{E}_{jk}{v}_k)\right)\hfill \\ \hfill |\mathsf{\Psi }\rangle =& \sum _{\mathbf{v}}\psi \left(\mathbf{v}\right)|\mathbf{v}\rangle \hfill \end{array}$$

(23)

In this procedure, we introduced terms like $exp\left(i\pi v_j\right)$ and $exp\left(i\pi v_j{v}_k\right)$. In the RBM representation, the former simply corresponds to setting the bias for the visible neuron $v_j$, and the latter means that we introduced a connection between visible neurons $v_j$ and $v_k$. Using the conclusion in [14], this corresponds to adding a hidden neuron that connects to $v_j$ and $v_k$, with the connection weights computed from Equation (24):

$$\begin{array}{cc}\hfill exp\left(J{v}_j{v}_k\right)=\sum _{h}exp& (a-ln2+b(v_j+v_k)(2h-1)\hfill \\ \hfill & +c(2h-1)+d(v_j+v_k))\hfill \end{array}$$

(24)

One solution is:

$$a=-d=-J/2,b=-c=-iarccos\left(e^{J/2}\right)$$

(25)

In this way, we have finished the construction of the logical Z eigenstate of an arbitrary stabilizer group, and the eigenstate of other logical operators can be constructed in the same way. The number of hidden neurons is at most $p(p-1)/2+r$, meaning that the representation is efficient. In summary, our method can be organized into Algorithm 1.

Example 1

([[5, 1, 3]] code). As an example, we take the $\left[\right[5,1,3\left]\right]$ code, the smallest quantum error correcting code that can correct an arbitrary single qubit error [39], to illustrate the construction procedure. The stabilizer generators are:

$$\begin{array}{cccccc}{T}_1=& X& Z& Z& X& I\\ T_2=& I& X& Z& Z& X\\ T_3=& X& I& X& Z& Z\\ T_4=& Z& X& I& X& Z\end{array}$$

(26)

After Gaussian elimination, the stabilizer generators become:

$$\begin{array}{cccccc}{T}_1=& Y& Z& I& Z& Y\\ T_2=& I& X& Z& Z& X\\ T_3=& Z& Z& X& I& X\\ T_4=& Z& I& Z& Y& Y\end{array}$$

(27)

Without loss of generality, we construct the eigenstate for the logical X operator with eigenvalue 1. The logical X operator $\overline{X}=ZIIZX$. Since $\overline{X}|\mathsf{\Psi }\rangle =|\mathsf{\Psi }\rangle$, treating $\overline{X}$ as the fifth stabilizer operator $T_5$ and further carrying out Gaussian elimination using $T_5$, we obtain the final form of the stabilizers:

$$\begin{array}{cccccc}{\tilde{T}}_1=& X& Z& I& I& Z\\ {\tilde{T}}_2=& Z& X& Z& I& I\\ {\tilde{T}}_3=& I& Z& X& Z& I\\ {\tilde{T}}_4=& I& I& Z& X& Z\\ {\tilde{T}}_5=& Z& I& I& Z& X\end{array}$$

(28)

There are no Z-type stabilizers, and $\mathsf{\Psi }\left(v_1{v}_2{v}_3{v}_4{v}_5\right)$ is obtained by the procedure specified in Algorithm 1. Explicitly writing down every term during the transition from $|00000\rangle$ to $|v_1{v}_2{v}_3{v}_4{v}_5\rangle$, we obtain the following:

$$\begin{array}{cc}\hfill & \psi \left(v_1{v}_2{v}_3{v}_4{v}_5\right)\hfill \\ \hfill =& exp(v_1·0)exp(v_2·i\pi v_1)exp(v_3·i\pi v_2)\hfill \\ \hfill \times & exp(v_4·i\pi v_3)exp(v_5·i\pi (v_1+v_4))\hfill \\ \hfill =& exp\left(i\pi (v_1{v}_2+v_2{v}_3+v_3{v}_4+v_4{v}_5+v_5{v}_1)\right)\hfill \end{array}$$

Explicitly converting the visible connections to hidden nodes using Equation (25), the result is:

$$\begin{array}{cc}\hfill & \psi \left(v_1{v}_2{v}_3{v}_4{v}_5\right)=exp\left((i\pi +\alpha )\sum _{i=1}^5{v}_i\right)\hfill \\ \hfill & \times \prod _{i=1}^5\left(1+exp\left(i\pi +2\alpha )(1-v_i-v_{i+1})\right)\right),\hfill \end{array}$$

(29)

where $\alpha =log(1+\sqrt{2})$ and $v_6=v_1$. A constant factor is omitted.

The structure of the RBM is shown in Figure 2.

Algorithm 1 Constructing RBM representation for the code state of the stabilizer group $\mathbf{S}=\langle T_1,\cdots ,T_n\rangle$

Require: A set of n commuting stabilizer generators $G=\{T_1,\cdots ,T_n\}$ acting on n qubits. Ensure: RBM parameters $\mathsf{\Omega }=\{a_i,b_{\mu },W_{i\mu }\}$ that realize the corresponding code state.  Initialize 1: Set all visible biases $a_i\leftarrow 0$. 2: Set the (temporary) visible–visible matrix $J_{ij}\leftarrow 0$. 3: Set hidden-layer size $n_h\leftarrow 0$ and initialize $b_{\mu },W_{i\mu }$ to 0.     Bring the generators into standard form 4: Use Gaussian elimination to put G into the check-matrix form $\left(I_{p}B|C0\right)\oplus \left(00|E{I}_r\right)$, keeping track of the phases $\{{\alpha }_1,\cdots ,{\alpha }_n\}$.        X–type generators $\left\{{\tilde{T}}_1,\cdots ,{\tilde{T}}_p\right\}$ 5: for  $j=1$  to  p  do 6:          $a_j\leftarrow a_j+log{\alpha }_j$              ▹${\tilde{T}}_j$ flips qubit j only 7:          for $k=1$ to $j-1$ do 8:               if $C_{jk}=1$ then             ▹Z on earlier qubit k 9:                    $J_{jk}\leftarrow J_{jk}+i\pi$ 10:             end if 11:        end for 12:  end for        Z–type generators $\left\{{\tilde{T}}_{p+1},\cdots ,{\tilde{T}}_n\right\}$ 13:  for  $\ell =p+1$  to  n  do 14:         Create a hidden neuron $h_{\ell }$; set $n_h\leftarrow n_h+1$ 15:         $b_{\ell }\leftarrow log{\alpha }_{\ell },W_{\ell \ell }\leftarrow i\pi$ 16:         for all k with $E_{\ell k}=1$ do            ▹Z on qubit k 17:             $W_{k\ell }\leftarrow i\pi$ 18:         end for 19:  end for        Remove visible–visible couplings 20:  for all$(j,k)$ with $J_{jk}\ne 0$ and $j<k$ do 21:         Introduce a new hidden neuron h 22:         Compute $a_j$, $a_k$, $b_h$, $W_{jh}$, $W_{kh}$ according to Equations (24) and (25) 23:         $J_{jk}\leftarrow 0$ 24:  end for 25:  return  $\mathsf{\Omega }=\left\{a_i,b_{\mu },W_{i\mu }\right\}$

Example 2

(Toric code). The toric code is a paradigmatic example of a topological quantum error-correcting code, playing a central role in quantum memory, topological quantum computation, and the study of topological phases of matter [40]. In this section, we demonstrate how to obtain the RBM representation of its code states using our proposed algorithm. For simplicity, we consider the toric code defined on a $2\times 2$ square lattice with periodic boundary conditions (i.e., a toric code on a torus); see Figure 3. In this setting, there are four vertex operators $A_v$ and four plaquette operators $B_p$:

$$\begin{array}{cccc}{A}_1=X_1{X}_2{X}_5{X}_8,\hfill & A_2=X_1{X}_4{X}_5{X}_6,\hfill & A_3=X_2{X}_3{X}_7{X}_8,\hfill & A_4=X_3{X}_4{X}_6{X}_7\hfill \\ B_1=Z_1{Z}_2{Z}_6{Z}_7,\hfill & B_2=Z_2{Z}_3{Z}_5{Z}_6,\hfill & B_3=Z_1{Z}_4{Z}_7{Z}_8,\hfill & B_4=Z_3{Z}_4{Z}_5{Z}_8\hfill \end{array}$$

(30)

One can check that $A_1{A}_2{A}_3{A}_4=I$ and $B_1{B}_2{B}_3{B}_4=I$, indicating that two operators are redundant. After Gaussian elimination, the independent stabilizer generators are as follows:

$$\begin{array}{ccc}{T}_1=X_1{X}_4{X}_5{X}_6,\hfill & T_2=X_2{X}_4{X}_6{X}_8,\hfill & T_3=X_3{X}_4{X}_6{X}_7\hfill \\ T_4=Z_3{Z}_4{Z}_5{Z}_8,\hfill & T_5=Z_2{Z}_4{Z}_6{Z}_8,\hfill & T_6=Z_1{Z}_4{Z}_7{Z}_8\hfill \end{array}$$

(31)

As an example, we construct the simultaneous eigenstate of the logical operators ${\overline{X}}_1=X_4{X}_8$, ${\overline{Z}}_2=Z_3{Z}_7$ with eigenvalue 1. Treating ${\overline{X}}_1$ and ${\overline{Z}}_2$ as additional stabilizer operators and further carrying out Gaussian elimination, we obtain

$$\begin{array}{cccc}{\tilde{T}}_1=X_1{X}_5{X}_6{X}_8,\hfill & {\tilde{T}}_2=X_2{X}_6,\hfill & {\tilde{T}}_3=X_3{X}_6{X}_7{X}_8,\hfill & {\tilde{T}}_4=X_4{X}_8\hfill \\ {\tilde{T}}_5=Z_1{Z}_5,\hfill & {\tilde{T}}_6=Z_1{Z}_2{Z}_3{Z}_6,\hfill & {\tilde{T}}_7=Z_3{Z}_7,\hfill & {\tilde{T}}_8=Z_1{Z}_3{Z}_4{Z}_8\hfill \end{array}$$

(32)

Following Algorithm 1, ${\tilde{T}}_1$ through ${\tilde{T}}_4$ do not introduce any terms into the RBM, while ${\tilde{T}}_5$ through ${\tilde{T}}_8$ each introduce a hidden neuron. Explicitly writing out all the terms, we obtain:

$$\begin{array}{cc}\hfill \psi \left(\mathbf{v}\right)=& \left(1+exp\left(i\pi (v_1+v_5)\right)\right)·\left(1+exp\left(i\pi (v_1+v_2+v_3+v_6)\right)\right)\hfill \\ \hfill ·& \left(1+exp\left(i\pi (v_3+v_7)\right)\right)·\left(1+exp\left(i\pi (v_1+v_3+v_4+v_8)\right)\right)\hfill \end{array}$$

(33)

The structure of the RBM is shown in Figure 4.

5. Conclusions and Discussions

In this work, we systematically investigate the RBM representations of stabilizer code states and present an algorithmic procedure to construct the RBM parameters for a given stabilizer group $\mathbf{S}$. To the best of our knowledge, this constitutes the first rigorous proof that RBMs can exactly and efficiently represent arbitrary stabilizer code states. While several related works (e.g., [32,33]) have emerged since our initial preprint appeared on arXiv in 2018 (see also earlier work [13,30,31], where certain special cases were addressed), this topic remains under active investigation.

Our results provide new insights into the representational power of RBMs and offer a theoretical foundation for their empirical success in modeling highly entangled quantum states. Furthermore, given the central role of stabilizer codes in quantum error correction, our work opens up new possibilities for the classical simulation of quantum error-correcting codes using RBMs, offering a practical tool for initializing code states.

Despite the progress that has been made, several crucial directions remain open for further investigation:

• In this work, we presented the construction for ${\mathbb{Z}}_2$ stabilizer codes. However, its generalization to ${\mathbb{Z}}_N$ (or more generally, to finite groups [40,41,42] and to the (weak) Hopf algebra setting, see e.g., [43,44,45,46,47,48,49,50,51,52,53]) remains largely unexplored. Such a generalization is not only of interest for applications in quantum memory and error correction, but also plays an essential role in understanding quantum phases of matter described by local commuting projector Hamiltonians, where efficient descriptions of ground and excited states are highly desirable.
• The relationship between RBM representations and tensor network representations has attracted significant attention in recent years (see, e.g., [17,34]). It would be interesting to relate our results to existing approaches for representing quantum codes using tensor networks. Furthermore, exploring connections between RBM representations and other neural network architectures—such as convolutional neural networks, transformers, and others—is another promising direction for future research [25,26,27].
• Since the code state can be represented using an RBM, establishing RBM representations of quantum operations—such as measurements and quantum channels—would allow one to embed a quantum code fully within the RBM framework. This may offer new perspectives on leveraging machine learning techniques to assist with quantum error detection and correction.