On the Exploration of Quantum Polar Stabilizer Codes and Quantum Stabilizer Codes with High Coding Rate

Abstract

Inspired by classical polar codes, whose coding rate can asymptotically achieve the Shannon capacity, researchers are trying to find their analogs in the quantum information field, which are called quantum polar codes. However, no one has designed a quantum polar coding scheme that applies to quantum computing yet. There are two intuitions in previous research. The first is that directly converting classical polar coding circuits to quantum ones will produce the polarization phenomenon of a pure quantum channel, which has been proved in our previous work. The second is that based on this quantum polarization phenomenon, one can design a quantum polar coding scheme that applies to quantum computing. There are several previous work following the second intuition, none of which has been verified by experiments. In this paper, we follow the second intuition and propose a more reasonable quantum polar stabilizer code construction algorithm than any previous ones by using the theory of stabilizer codes. Unfortunately, simulation experiments show that even the stabilizer codes obtained from this more reasonable construction algorithm do not work, which implies that the second intuition leads to a dead end. Based on the analysis of why the second intuition does not work, we provide a possible future direction for designing quantum stabilizer codes with a high coding rate by borrowing the idea of classical polar codes. Following this direction, we find a class of quantum stabilizer codes with a coding rate of 0.5, which can correct two of the Pauli errors.

1. Introduction

Due to the great potential to solve certain problems that cannot be solved by classical computers with reasonable resources and time, quantum computing has attracted worldwide attention in the past twenty years. Nowadays, researchers have studied many physical systems that can be used to realize quantum computing, including superconducting circuits [1,2,3], trapped ions [4], and quantum dots [5]. However, limited by the hardware, none of these systems has realized reliable large-scale quantum computing, since qubits in these physical systems are easily influenced by the environment, which makes the state of qubits and hence the quantum information carried by them prone to error. Fortunately, quantum error-correcting (QEC) proposed by Shor and Steane [6,7] provides us with a solution to this problem.

Though quantum error-correcting codes (QECCs) provide us with a promising approach for fault-tolerant large-scale quantum computing, the high qubit overhead results from the low coding rate of most QECCs and challenges the current hardware level. Similar to classical error-correcting codes (CECCs), QECCs encode n (which is called code length) less reliable physical qubits (with error rate p) to obtain k more reliable logical qubits (with error rate $p_L<p$ after decoding and recovery). The ratio $k/n$ is called the coding rate. Improving the coding rate is beneficial to reducing qubit overhead.

No matter whether for CECCs or QECCs, in general, we often increase the code length n to improve the reliability of the logical bits/qubits. Good CECCs have constant or even asymptotically increasing coding rates with the increase in code length n [8,9,10,11]. For instance, experimental results show that the coding rate of classical low-density parity check (CLDPC) codes [8,9,10] seems to achieve Shannon capacity. Another example is that Arikan has proved the coding rate of classical polar code [11] can asymptotically achieve the Shannon capacity.

These CECCs with high coding rates have inspired researchers to look for efficient QECCs. For example, inspired by CLDPCs, researchers proposed quantum low-density parity check (QLDPC) codes whose coding rate can remain constant [12,13,14,15,16,17,18,19,20]. However, the relationship between the coding rate of QLPDCs and quantum channel capacity is still not clear. If we take maximum single-letter coherent information (MSLCI), which is explained in Section 2.2, as quantum channel capacity, the asymptotic coding rate of certain QLDPCs seems to be rather lower than quantum channel capacity [21]. Another example of efficient QECCs research inspired by CECCs is quantum polar codes inspired by classical polar codes [11]. In previous work [22,23,24,25,26,27,28,29,30,31], some quantum polar coding schemes have been proposed. However, either they are based on the classical-quantum channel [22,23,24,26,28,29,31], or they ask for destructive measurements [25,27], which refers to the measurements that destruct the quantum information carried by quantum states. This makes them not applicable to quantum computing, where the computing channel is a pure quantum channel and destructive measurement should be avoided.

There are two intuitions in current research on quantum polar coding [22,23,24,25,26,27,28,29,30,31,32,33]. The first is that directly converting the classical polar coding circuits into quantum ones will lead to polarization phenomenon of quantum channels. The second is that based on the polarization phenomenon of quantum channels that arises from directly converting the classical polar coding circuits into quantum ones, one can design a quantum polar coding scheme for quantum computing. In our previous work [21], we proved the first intuition in two-dimensional-input quantum symmetric channels (QSCs). There are several previous works following the second intuition [22,25,27,32,33]. However, none of them are a quantum stabilizer code for quantum computing in a real sense, except the one in ref. [33]—either they are based on classical-quantum channels [22] or they ask for destructive measurement [25,27]. In ref. [33], the authors give a method to construct so-called “entanglement assisted quantum polar stabilizer codes”. However, there is no experiment to support the validity of these codes. The validity that we refer to is the error-correcting capability of the codes, which means one can decrease the logical error rate after error-correcting by increasing the code length, and a noise threshold can be observed. In this paper, we follow the second intuition and propose two construction algorithms, called the coherent-information-achieving (CA) algorithm and the block-selection (BS) algorithm, to construct quantum polar stabilizer codes (QPSCs). CA is the same as the construction in ref. [33], while we believe BS is more reasonable than CA because it is designed using the theory of stabilizer codes. By saying “using the theory of stabilizer codes”, we mean that the more reasonable construction has considered the weight of logical operators and stabilizers. Unfortunately, simulation experiments show that even the stabilizer codes obtained from this more reasonable construction algorithm, called the BS algorithm, do not work, which implies that the second intuition leads to a dead end.

Quantum stabilizer codes are an important class of QECCs. They avoid destructive measurements in error syndrome detection by measuring stabilizers. Different from the decoders of CECCs, which decode the value of the received bits into the value of bits before encoding, the decoders of quantum stabilizer codes decode the error syndromes which are composed of the measurement result of stabilizers into the errors that happen to each qubit. Quantum stabilizer codes can be represented by their stabilizer generators. Determining a stabilizer generator’s construction method is equivalent to determining a kind of quantum stabilizer code construction method. According to the code construction of classical polar code and the ranking of quantum coordinate channels, we propose two algorithms for constructing stabilizer generators of QPSCs. The first one ranks the quantum coordinate channels by the Bhattacharyya parameters. Since it allows the coding rate to achieve the channel capacity if we take MSLCI as quantum channel capacity, we name it the coherent-information-achieving (CA) construction algorithm. The second one ranks the quantum coordinate channels by the weight of their corresponding stabilizer generators. Since this algorithm ranks the coordinate channels in a block-by-block way, we name it the block-selection (BS) construction algorithm.

In classical polar codes, the frozen bits are frozen to a fixed value such as zero before encoding, which is a priori knowledge for decoders. In decoding, decoders will use this priori knowledge and decode all frozen bits into the fixed value. Hence, in the whole encoding-transmitting-decoding process, the frozen bits seem to suffer no error. This point is crucial to guarantee the reliability of polar codes, since the decoding of frozen bits will influence the decoding of information bits. For QPSCs, there are two kinds of assumptions about the frozen qubits—unreliable frozen qubits assumption and reliable frozen qubits assumption. The unreliable frozen qubits assumption assumes that the frozen qubits suffer from errors, as the information qubits do, which is the common assumption in the error correction of quantum computing, while the reliable frozen qubits assumption assumes that the frozen qubits do not suffer from errors, which might be too strong for quantum computing.

To test the error-correcting capability of QPSCs under these two construction algorithms, we perform simulation in a bit-flip channel under the above two assumptions, respectively. The simulation results show that, under both assumptions, for both CA and BS construction algorithms, in the range of p from $1\times {10}^{-5}$ to $1\times {10}^{-2}$, no evidence shows that the logical error rate (LER) of the single logical qubit $LE{R}_{slq}$ can be decreased by increasing code length, and we cannot find the noise threshold. That is to say, these QPSCs do not work for quantum computing. Therefore, we come to a conclusion that the second intuition is too naive to guide us to design quantum polar coding scheme for quantum computing.

Based on the analysis of why QPSCs do not work, an alternative idea is proposed to construct stabilizer codes with high coding rate, which is to recursively expand the Tanner graph of certain stabilizer codes. Following this idea, we propose a class of stabilizer codes with a constant coding rate of 0.5, which can correct two of the Pauli errors.

The rest of this paper is organized as follows. Some preliminaries are introduced in Section 2, including stabilizer codes, quantum channel and its capacity, classical polar code and its code construction, and the polarization of two-dimensional-input quantum symmetric channels. In Section 3, we reveal the relationship between the channel quality of quantum coordinate channels and the weight of stabilizer generators and logical operators of QPSCs. In Section 4, we give the CA and BS construction algorithms of QPSCs. In Section 5, simulation results are given and analyzed. In Section 6, we provide a possible future direction of designing quantum stabilizers with high coding rates by borrowing the idea of classical polar codes. We conclude our work in Section 7.

2. Preliminaries

2.1. Stabilizer Codes

This section briefly introduces quantum stabilizer codes. Quantum stabilizer codes are an important class of QECCs, whose code construction is analogous to classical linear codes [34].

In quantum information theory, errors acting on a single qubit are generally modeled as elements of the Pauli group denoted by ${\mathcal{G}}_1$, which consists of all Pauli operators together with multiplicative constants $\{\pm 1,\pm i\}$, namely,

$${\mathcal{G}}_1=\left\{\pm I,\pm iI,\pm X,\pm iX,\pm Y,\pm iY,\pm Z,\pm iZ\right\}$$

(1)

The general Pauli group ${\mathcal{G}}_n$ on n qubits is the n-fold tensor product of ${\mathcal{G}}_1$, namely, ${\mathcal{G}}_n={\mathcal{G}}_1^{\otimes n}$. Here, we use notation $w\left(·\right)$ to denote the weight of an operator $E\in {\mathcal{G}}_n$, namely, the number of qubits on which it acts nontrivially (with a Pauli operator other than the identity I). For instance, $w\left(X_1{X}_2{I}_3\right)=2$.

A quantum stabilizer code C encodes k logical qubits into n physical qubits. Denote the code space by ${\mathcal{Q}}_C$ which is a subspace of ${\left({\mathbb{C}}^2\right)}^{\otimes n}$. The code space ${\mathcal{Q}}_C$ is stabilized by a stabilizer group $𝒮$ which is a subgroup of ${\mathcal{G}}_n$. Giving the stabilizer group $𝒮$ of a code C is equivalent to explicitly giving its code space ${\mathcal{Q}}_C$. Using the stabilizer group $𝒮$, the code space ${\mathcal{Q}}_C$ can be defined as

$$\begin{array}{c}\hfill {\mathcal{Q}}_C=\{|\psi ⟩\in {\left({\mathbb{C}}^2\right)}^{\otimes n}:S|\psi ⟩=|\psi ⟩,\forall S\in 𝒮\}\end{array}$$

(2)

A group G can be generated by a set of independent elements $g_1,\cdots ,g_l$, which means each element in G can be written as a product of elements from the list $g_1,\cdots ,g_l$. We say $g_1,\cdots ,g_l$ are generators of group G, and we write $G=⟨g_1,\cdots ,g_l⟩$.

Similar to classical linear codes, a stabilizer code C can be expressed as a 3-tuple $\left[n,k,d\right]$, which means it encodes k logical qubits into n physical qubits and its code distance is d. For an $\left[n,k,d\right]$ code C, its stabilizer group $𝒮$ has $n-k$ independent generators, namely, $𝒮=⟨S_1,\cdots ,S_{n-k}⟩$. Besides, we can also find another subgroup $\mathcal{L}$ of ${\mathcal{G}}_n$ that has k pairs of generators, namely, $\mathcal{L}=⟨{\overline{X}}_1,{\overline{Z}}_1,\cdots ,{\overline{X}}_k,{\overline{Z}}_k⟩$, whose elements commute with all elements in $𝒮$ [35]. The elements in group $\mathcal{L}$ are called the logical operators of code C. Code distance d is defined as the minimum weight of the logical operators, namely,

$$\begin{array}{c}\hfill d=\underset{P\in \mathcal{L}}{min}w\left(P\right)\end{array}$$

(3)

For a $\left[n,k\right]$ stabilizer code $\mathcal{C}$, its encoding process can be depicted by a unitary operator $U_{enc}$ acting on n qubits. These n qubits can be divided into two different sets. The first set consists of kdata qubits (or called logical qubits) which contains information to be encoded, and the second set consists of $n-k$ ancilla qubits which are set to a fixed state, such as ${|0⟩}^{\otimes n-k}$. The Pauli operators acting on k logical qubits before encoding will be transformed to k sets of logical operators by the encoding operator $U_{enc}$ after encoding, namely, ${\overline{L}}_i=U_{enc}{P}_i{U}_{enc}^{†}$, $1\le i\le k$. The Pauli operators acting on $n-k$ ancilla qubits are transformed to stabilizer generators by the encoding operator $U_{enc}$ after encoding, namely, $S_i=U_{enc}{P}_i{U}_{enc}^{†}$, $k+1\le i\le n$.

2.2. Pure Quantum Channel and Its Capacity

2.2.1. Pure Quantum Channel

If the inputs and outputs of a channel are both arbitrary quantum states, it is a pure quantum channel. Different from it, if the channel input or output is restricted to some sets of quantum states, not arbitrary states, it is not a pure quantum channel. A typical instance is the classical-quantum channel [22,23,24,26,28,29,31], whose input is classical variables or quantum states corresponds to the sets of value that these variables can take. The behavior of a quantum channel $\mathcal{E}$ acting on a quantum system P can be described by a set of operator elements ${\left\{E_i\right\}}_{i=1,\cdots n}$, which satisfies ${\sum }_{i=1}^n{E}_i^{†}{E}_i=I$ [34]. Suppose the state of quantum system P is ${\rho }^P$, and P is subject to the quantum channel $\mathcal{E}$, which changes system P to $P^{\prime }$ and maps the state ${\rho }^P$ to ${\rho }^{P^{\prime }}$. Using operator-sum representation [34], the transformation of state ${\rho }^P$ can be described as

$$\begin{array}{c}\hfill {\rho }^{P^{\prime }}=\mathcal{E}\left({\rho }^P\right)=\sum _{i=1}^n{E}_i{\rho }^P{E}_i^{†}\end{array}$$

(4)

Common quantum channels include bit-flip channel, phase-flip channel and depolarizing channel, whose operator elements are $\{\sqrt{p}X,\sqrt{1-p}I\}$, $\{\sqrt{p}Z,\sqrt{1-p}I\}$, and $\{\sqrt{p/3}X,\sqrt{p/3}Y,\sqrt{p/3}Z,\sqrt{1-p}I\}$, respectively.

In our previous work [21], we propose a mathematical tool, basis transition probability matrix (BTPM), which is inspired by the transition probability matrix (TPM) of classical channels, to depict the behavior of quantum channels. Besides, we prove that, for a quantum channel $\mathcal{E}$ having BTPM, giving its BTPM is equivalent to giving its operator elements ${\left\{E_i\right\}}_{i=1,\cdots n}$, which satisfies ${\sum }_{i=1}^n{E}_i^{†}{E}_i=I$. We take the bit flip channel and two-dimensional-input Pauli channel as examples and choose the computational basis $\{|0⟩,|1⟩\}$ to be the basis of their input space. For the bit flip channel that flips $|0⟩$ and $|1⟩$ with the same probability p, its BTPM is

$$\begin{array}{c}\hfill |0⟩|1⟩\hfill \\ \begin{array}{c}|0⟩\hfill \\ |1⟩\hfill \end{array}\left(\begin{array}{cc}1-p& p\\ p& 1-p\end{array}\right)\hfill \end{array}$$

(5)

And for the two-dimensional-input Pauli channel, which has four operation elements $\{\sqrt{p_1}I,$$\sqrt{p_2}X,\sqrt{p_3}Y,\sqrt{p_4}Z\}({\sum }_{i=1}^4{p}_i=1)$, its BTPM is

$$\begin{array}{c}\hfill |0⟩|1⟩\hfill \\ \begin{array}{c}|0⟩\hfill \\ |1⟩\hfill \end{array}\left(\begin{array}{cc}{p}_1+p_4& p_2+p_3\\ p_2+p_3& p_1+p_4\end{array}\right)\hfill \end{array}$$

(6)

In [21], we also define two classes of quantum channel, quantum symmetric channel (QSC) and quantum quasi symmetric channel (QQSC). For a quantum channel that has BTPM, if each row of the BTPM is a permutation of the first row, then this quantum channel is symmetric with respect to its input. If each column of the BTPM is a permutation of the first column, then this quantum channel is symmetric with respect to its output. If a quantum channel is symmetric with respect to both its input and output, then this channel is called QSC. If a channel is symmetric with respect to its input but might not to its output, and its BTPM can be divided into several submatrices by column, each of which satisfies that each column of it is a permutation of the first column of it, then this channel is called a QQSC.

2.2.2. Quantum Channel Capacity

Coherent information of a quantum channel $\mathcal{E}$, denoted by $I({\rho }^P,\mathcal{E})$, is the quantity measuring the amount of quantum information transmitted in the channel [36], where ${\rho }^P$ is the state of quantum system P before being transformed by $\mathcal{E}$. Coherent information is believed to be the analog of classical mutual information in quantum information theory [34] and a quantity to measure the channel capacity of pure quantum channels [37,38,39,40,41,42,43,44,45,46]. However, since the coherent information has superadditivity, it is still not clear how to calculate quantum channel capacity precisely by coherent information. Here, we use maximum single letter coherent information (MSLCI) [21] to measure quantum channel capacity, which is believed to be a lower bound of the average coherent information of multiple uses of a quantum channel [47].

For a classical symmetric channel, Arikan has proved that its symmetric capacity is its Shannon capacity. Similarly, in [21] we prove that the MSLCI of a two-dimensional-input QQSC equals its symmetric coherent information, whose definition is as follows.

 Definition 1 (Symmetric coherent information). 

For a quantum channel $\mathcal{E}$, the number of whose input qubits is n, its input state can be represented by $\rho ={\sum }_{i=1}^{2^n}{q}_i|i⟩⟨i|$, its symmetric information $I_U$ is defined as the coherent information $I(\rho ,\mathcal{E})$ when $q_1=\cdots =q_{2^n}={\displaystyle \frac{1}{2^n}}$, namely,

$$I_U\equiv I\left(\rho =\sum _{i=1}^{2^n}{\displaystyle \frac{1}{2^n}}|i⟩⟨i|,\mathcal{E}\right)$$

(7)

2.3. Classical Polar Code and Its Code Construction

For a binary-input discrete memoryless channel (B-DMC) $W:\mathcal{X}\to \mathcal{Y}$ with input alphabet $\mathcal{X}$, output alphabet $\mathcal{Y}$ and transition probabilities $W\left(y|x\right)$, $x\in \mathcal{X}=\{0,1\}$, $y\in \mathcal{Y}$, Arikan defines two parameters [11], the symmetric capacity and the Bhattacharyya parameter, to measure its quality. The symmetric capacity of a B-DMC is defined as

$$I\left(W\right)\triangleq \sum _{y\in \mathcal{Y}}\sum _{x\in \mathcal{X}}{\displaystyle \frac{1}{2}}W(y\mid x)log{\displaystyle \frac{W(y\mid x)}{\frac{1}{2}W(y\mid 0)+\frac{1}{2}W(y\mid 1)}}$$

(8)

and its Bhattacharyya parameter is defined as

$$Z\left(W\right)\triangleq \sum _{y\in \mathcal{Y}}\sqrt{W(y\mid 0)W(y\mid 1)}$$

(9)

Arikan has proved that the symmetric capacity $I\left(W\right)$ is equal to the Shannon capacity when W is a symmetric channel. One can see $Z\left(W\right)$ takes values in $\left[0,1\right]$, and $I\left(W\right)$ also take values in $\left[0,1\right]$ if we use base-2 logarithms. When $I\left(W\right)$ tends to 1, $Z\left(W\right)$ tends to 0, and when $I\left(W\right)$ tends to 0, $Z\left(W\right)$ tends to 1.

Classical polar coding proposed by Arikan [11] is the only coding scheme whose coding rate is proved to achieve the symmetric capacity of any given B-DMC. This scheme is based on channel polarization, which consists of two processes, channel combining and channel splitting.

As shown in Figure 1, in channel combining, we combine N copies of a given B-DMC $W:\mathcal{X}\to \mathcal{Y}$ (whose symmetric capacity is $I\left(W\right)$) with input alphabet $\mathcal{X}$ and output alphabet $\mathcal{Y}$ in a recursive manner and obtain a combined channel $W_N:{\mathcal{X}}^N\to {\mathcal{Y}}^N$ (${\mathcal{X}}^N$ and ${\mathcal{Y}}^N$ are the N-power extension alphabet of $\mathcal{X}$ and $\mathcal{Y}$, respectively) which maps the vector $(x_1,\cdots ,x_N)$ to $(y_1,\cdots ,y_N)$. Here, we will use $x_1^N$ as a shorthand for vector $(x_1,\cdots ,x_N)$. In channel splitting, the combined channel $W_N$ is split back into a set of N binary-input coordinate channels ${\left\{W_N^{\left(i\right)}\right\}}_{1\le i\le N}$. The coordinate channel $W_N^{\left(i\right)}$ is define as

$$W_N^{\left(i\right)}:\mathcal{X}\to {\mathcal{Y}}^N\times {\mathcal{X}}^{i-1},1\le i\le N$$

(10)

Figure 1. Classical channel polarization. $R_N$ is the reverse shuffle operation. Two independent copies of $W_{N/2}$ are combined to produce the channel $W_N$. Please see ref. [11] for more detail.

As N becomes large, the symmetric capacity of $N\times I\left(W\right)$ coordinate channels will asymptotically tend to 1 and that of the rest $N\times (1-I\left(W\right))$ coordinate channels will asymptotically tend to 0. It means $N\times I\left(W\right)$ coordinate channels are noiseless, which can be used to perfectly transmit information bits, while the rest $N\times (1-I\left(W\right))$ coordinate channels are completely noisy and can be used to transmit frozen bits. After channel polarization, we compute the channel quality of each coordinate channel $W_N^{\left(i\right)}$, and rank the coordinate channels in descending order according to their channel quality. Then, we choose the former $⌊N\times I\left(W\right)⌋(⌊·⌋$ means the value is rounded down) coordinate channels to transmit information bits, and the rest to transmit frozen bits.

Arikan has proved that [11] if the primal channel W is a binary erasure channel (BEC), the channel quality of classical coordinate channels $\left\{W_N^{\left(i\right)}\right\}$ can be measured by the Bhattacharyya parameter, and they can be precisely computed through the following recursion:

$$\begin{array}{cc}\hfill Z\left(W_N^{(2j-1)}\right)& =2Z\left(W_{N/2}^{\left(j\right)}\right)-Z{\left(W_{N/2}^{\left(j\right)}\right)}^2\hfill \\ \hfill Z\left(W_N^{\left(2j\right)}\right)& =Z{\left(W_{N/2}^{\left(j\right)}\right)}^2\hfill \end{array}$$

(11)

However, if the primal channel W is a binary symmetric channel (BSC), there is no such recursion to precisely compute the channel quality of classical coordinate channels $\left\{W_N^{\left(i\right)}\right\}$, only the following relationships:

$$\begin{array}{cc}\hfill Z\left(W_{2N}^{(2i-1)}\right)& \le 2Z\left(W_N^{\left(i\right)}\right)-Z{\left(W_N^{\left(i\right)}\right)}^2\hfill \\ \hfill Z\left(W_{2N}^{\left(2i\right)}\right)& =Z{\left(W_N^{\left(i\right)}\right)}^2\hfill \end{array}$$

(12)

Since the TPM of $W_N^{\left(i\right)}$ is exponential to the code length N, precisely computing the Bhattacharyya parameter of these $\left\{W_N^{\left(i\right)}\right\}$ is intractable. Fortunately, ref. [48] has proved that, if the primal channel W is a BSC, we can still use Equation (11) to approximately estimate the Bhattacharyya parameter of classical coordinate channels $\left\{W_N^{\left(i\right)}\right\}$.

2.4. Polarization of Two-Dimensional-Input Quantum Symmetric Channels

For a two-dimensional-input quantum channel that has a BTPM, except for its symmetric coherent information, we can also use the Bhattacharyya parameter to measure its channel quality, which is defined as

$$Z\left(\mathcal{E}\right)\triangleq \sum _{|i⟩\in B_{\mathrm{out}}}\sqrt{Pr(|i⟩\mid |0⟩)Pr(|i⟩\mid |1⟩)}$$

(13)

where $B_{\mathrm{out}}$ is the basis of output space of $\mathcal{E}$, $B_{\mathrm{in}}=\{|0⟩,|1⟩\}$ is the basis of input space of $\mathcal{E}$, and $Pr\left(|i⟩\right||k⟩)$, $|k⟩\in B_{\mathrm{in}}$,$|i⟩\in B_{\mathrm{out}}$ are basis transition probabilities.

Polarization of Channel Quality of Quantum Coordinate Channels

As shown in Figure 2, quantum channel polarization is similar to classical channel polarization and also consists of two processes—quantum channel combining and quantum channel splitting [21]. We only briefly introduce some concepts and conclusions here.

Figure 2. Quantum channel polarization circuits: (a) Two primal channel $\mathcal{E}$ combines to form channel ${\mathcal{E}}_2$. (b) Two ${\mathcal{E}}_2$ combines to form channel ${\mathcal{E}}_4$. (c) Two ${\mathcal{E}}_{N/2}$ combines to form channel ${\mathcal{E}}_N$, $R_N$ is the reverse shuffle operator [21].

Through quantum channel combining, one can combine N copies of primal quantum channel $\mathcal{E}:{\rho }^Q\to {\rho }^Y$ in a recursive way and obtain a quantum combined channel ${\mathcal{E}}_N:{\rho }^{Q_1\cdots Q_N}\to {\rho }^{Y_1\cdots Y_N}$. The difference is that we replace the XOR gates in classical channel combining by quantum CNOT gates, and use quantum SWAP gates to realize the reverse shuffle operator. One can see that this process is realized by converting the classical polar coding circuits to the quantum version. In the quantum channel splitting process, we split the quantum combined channel ${\mathcal{E}}_N$ back into N quantum coordinate channels ${\mathcal{E}}_N^{\left(i\right)}:{\rho }^{Q_i}\to {\rho }^{Y_1\cdots Y_N,R_1\cdots R_{i-1}}$, where $R_i$ is the reference system of $Q_i$, $1\le i\le N$. Here, we use notation ${\rho }^{Q_1^N}$ to denote ${\rho }^{Q_1\cdots Q_N}$ which is similar to Arikan’s shorthand for a vector. Hence the quantum combined channel and quantum coordinate channel can be rewritten as ${\mathcal{E}}_N:{\rho }^{Q_1^N}\to {\rho }^{Y_1^N}$ and ${\mathcal{E}}_N^{\left(i\right)}:{\rho }^{Q_i}\to {\rho }^{Y_1^N{R}_1^{i-1}}$, respectively.

It has been proved that if the primal quantum channel $\mathcal{E}$ is a two-dimensional-input QSC with two-dimensional output, the quantum combined channel ${\mathcal{E}}_N$ is a QSC, and the quantum coordinate channels $\left\{{\mathcal{E}}_N^{\left(i\right)}\right\}$ are all two-dimensional-input QQSCs [21]. Besides, if the BTPM of the primal QSC $\mathcal{E}$ and the TPM of classical primal BSC W are the same, the MSLCI $I({\rho }^{Q_i},{\mathcal{E}}_N^{\left(i\right)})$ of the quantum coordinate channel ${\mathcal{E}}_N^{\left(i\right)}$ equals to the Shannon capacity $I\left(W_N^{\left(i\right)}\right)$ of the classical coordinate channel $W_N^{\left(i\right)}$. Since classical coordinate channels $\left\{W_N^{\left(i\right)}\right\}$ polarize, quantum coordinate channels $\left\{{\mathcal{E}}_N^{\left(i\right)}\right\}$ polarize as well.

In this paper, the quantum channel $\mathcal{E}$ that we consider is a bit-flip channel, namely, only Pauli X error happens. The reason for this is that correcting Pauli X error is the prerequisite to correct arbitrary Pauli errors. If a quantum stabilizer code does not work in a bit-flip channel, then it will not work in a channel where arbitrary Pauli errors might happen.

The BTPM of a bit-flip channel is the same as the TPM of BSC W. Hence, we have $I\left({\rho }^{Q_i},{\mathcal{E}}_N^{\left(i\right)}\right)=I\left(W_N^{\left(i\right)}\right)$ and $Z\left({\mathcal{E}}_N^{\left(i\right)}\right)={Z(W}_N^{\left(i\right)})$. Same as for the approximation method of the Bhattacharyya parameter of classical channels mentioned in Section 2.3, we can approximately estimate the Bhattacharyya parameter of quantum coordinate channels $\left\{{\mathcal{E}}_N^{\left(i\right)}\right\}$ by the following recursion,

$$\begin{array}{cc}\hfill Z\left({\mathcal{E}}_N^{(2i-1)}\right)& =2Z\left({\mathcal{E}}_{N/2}^{\left(i\right)}\right)-{\left(Z\left({\mathcal{E}}_{N/2}^{\left(i\right)}\right)\right)}^2\hfill \\ \hfill Z\left({\mathcal{E}}_N^{\left(2i\right)}\right)& ={\left(Z\left({\mathcal{E}}_{N/2}^{\left(i\right)}\right)\right)}^2\hfill \end{array}$$

(14)

The greater $Z\left({\mathcal{E}}_N^{\left(i\right)}\right)$ is, the less reliable ${\mathcal{E}}_N^{\left(i\right)}$ is.

3. The Weight of Stabilizer Generators and Logical Operators of Quantum Polar Stabilizer Codes

This section reveals the relationship between the channel quality of quantum coordinate channels and the weight of their corresponding stabilizer generators and logical operators.

According to the intuition that one can design a quantum polar coding scheme for quantum computing based on the polarization phenomenon of quantum channels that arise from directly converting the classical polar coding circuits into quantum ones, the circuits shown in Figure 2 might correspond to a QPSC encoding circuit.

As shown in Figure 2, the process $|Q_1^N⟩\to |C_1^N⟩$ can be seen as a QPSC encoding circuit denoted by $E_N$, and this encoding circuit can be specified as a unitary operator $U_{enc}$. As we mention in Section 2.1, the Pauli Z operators (only the Z-type operators need to be considered since only Pauli X errors are considered) acting on the frozen qubits are transformed into stabilizer generators, while the Pauli operators acting on the data qubits are transformed into logical operators by $U_{enc}$. We denote the unitary operator of CNOT gate by notation $U_{CNOT}$, with qubit 1 as the target and qubit 2 as the control. Figure 3 shows that if a Pauli Z operator (whose weight is 1) “passes through” the target position of a CNOT gate, its weight becomes 2, while if it “passes through” the control position, its weight remains invariant. The transformation of a Pauli X operator is right the opposite.

Figure 3. Transformation of Pauli X operators and Pauli Z operators under conjugation by CNOT gate.

To reveal the relationship between the weight of stabilizer generators and logical operators of QPSCs and the channel quality of quantum coordinate channels, we first define two concepts “node” and “path” for the quantum polarization circuits.

 Definition 2 (Node). 

The operation which acts on a single qubit in a CNOT gate is defined to be a node. We use notation ⨁ to denote the target node which represents “XOR” operation of a CNOT gate, and notation ⨀ to denote the control node which represents the identity operation of a CNOT gate.

It is obvious that the encoding circuit $E_N$ consists of $n={log}_{2}N$ CNOT gate blocks, and each block contains $N/2$ CNOT gates (or equivalently N nodes). Arbitrary two adjacent CNOT gate blocks are connected by reverse shuffle operation realized by SWAP gates. The index of CNOT gate block is numbered from right to left, that is to say, the index of the rightmost CNOT gate block is 1, and that of the leftmost one is n. The index of a node located at a CNOT gate block is numbered from top to bottom. One can see that if the index of a node is an odd number, it must be a target node ⨁, if that of a node is an even number, it must be a control node ⨀.

 Definition 3 (Path of a qubit passing through an encoding circuit). 

A path ${\mathcal{P}}_j$ of the jth input qubit $Q_j$ in the encoding circuit $E_N$ with length N is defined as an ordered set $\left\{{node}_n^j,\cdots ,{node}_1^j\right\}$, where ${node}_i^j\in \{⨁,⨀\}$, $1\le i\le n$, $1\le j\le N$.

It is obvious that each ordered set which represents a complete path from the input of $E_N$ to the output contains $n={log}_{2}N$ nodes. Here, the reason for labeling the index i of node from n to 1 rather than 1 to n is to keep this index consistent with the index of the CNOT gate blocks (i.e., ${node}_i^j$ is located at the ith CNOT gate block).

Let us take the encoding circuit $E_4$ for example. As shown in Figure 2b, the path of the first qubit is ${\mathcal{P}}_1=\{\oplus ,\oplus \}$, the second is ${\mathcal{P}}_2=\left\{\odot ,\oplus \right\}$, the third is ${\mathcal{P}}_3=\left\{\oplus ,\odot \right\}$, and the fourth is ${\mathcal{P}}_4=\left\{\odot ,\odot \right\}$.

For path ${\mathcal{P}}_j$ in $E_N$, we observe that ${\mathcal{P}}_j$ corresponds to not only the jth stabilizer generator $S_j$, which comes from the transformation of Pauli Z operator acting on qubit $Q_j$, but also the jth quantum coordinate channel ${\mathcal{E}}_N^{\left(j\right)}$, whose input is $Q_j$.

 Definition 4 (Length of a path). 

For a path $\mathcal{P}=\left\{{node}_n,\cdots ,{node}_1\right\}$, its length is defined as the number of nodes that it contains, denoted by $\left|\mathcal{P}\right|$.

 Definition 5 (Subpath). 

For a path $\mathcal{P}=\left\{{node}_n,\cdots ,{node}_1\right\}$ and a path ${\mathcal{P}}^{\prime }=\left\{{node}_k,{node}_{k-1},\right.$$\left.\cdots ,{node}_{k-r}\right\}$, if ${\mathcal{P}}^{\prime }$ is part of $\mathcal{P}$, namely, $\mathcal{P}=\{{node}_n,\cdots ,{\mathcal{P}}^{\prime },\cdots ,{node}_1\}=\left\{{node}_n,\cdots ,\right.$$\left.{node}_k,{node}_{k-1}\cdots ,{node}_{k-r},\cdots ,{node}_1\right\}$, ${\mathcal{P}}^{\prime }$ is a subpath of path $\mathcal{P}$, denoted by ${\mathcal{P}}^{\prime }\in \mathcal{P}$. We notice that ${\mathcal{P}}^{\prime }$ follows ${node}_{k+1}$ and is followed by ${node}_{k-r-1}$. Specially, if $k=n$, $k-r>1$, we call ${\mathcal{P}}^{\prime }$ the former path   of $\mathcal{P}$, if $k<n$, $k-r=1$, we call ${\mathcal{P}}^{\prime }$ the  latter path   of $\mathcal{P}$, and if $k=n$, $k-r=1$, we say ${\mathcal{P}}^{\prime }$ is identical to $\mathcal{P}$, denoted by ${\mathcal{P}}^{\prime }=\mathcal{P}$.

For arbitrary two paths ${\mathcal{P}}_i$ and ${\mathcal{P}}_j$, as long as they have one node not the same, we say they are different, denoted by ${\mathcal{P}}_i\ne {\mathcal{P}}_j$. It is obvious that two paths with different lengths must be different.

 Lemma 1 (Uniqueness of path). 

Arbitrary two paths ${\mathcal{P}}_i$ and ${\mathcal{P}}_j$$(1\le i\ne j\le N)$ in the same encoding circuit $E_N$ are different, namely, ${\mathcal{P}}_i\ne {\mathcal{P}}_j$. That is to say, each path in $E_N$ is unique.

 Proof. 

Here, we apply the mathematical induction to prove it.

 Step 1: 

For $n=1$, as shown in Figure 2a, the encoding circuit $E_2$ only contains one CNOT gate, it is obvious these two paths are different.

 Step 2: 

For $n=k(k>1)$, we assume that arbitrary two paths in encoding circuit $E_{N/2}(N/2=2^k)$ are different.

 Step 3: 

For $n=k+1(k>1)$, two independent copies of $E_{N/2}$ are combined to produce a larger encoding circuit $E_N$ in a recursive way. As shown in Figure 2c, we call the upper encoding circuit $E_{N/2}$ block 1, and the lower encoding circuit $E_{N/2}$ block 2. There are 3 cases in total that we should consider.

 Case 1: 

For arbitrary two paths ${\mathcal{P}}_1^{\prime }$ and ${\mathcal{P}}_2^{\prime }$ both in block 1 or block 2, according to step 2, they are different, so we cannot find two identical paths ${\mathcal{P}}_1$ and ${\mathcal{P}}_2$ in $E_N$, which satisfies ${\mathcal{P}}_1^{\prime }\in {\mathcal{P}}_1$ and ${\mathcal{P}}_2^{\prime }\in {\mathcal{P}}_2$.

 Case 2: 

For two paths ${\mathcal{P}}_1^{\prime }$ in block 1 and ${\mathcal{P}}_2^{\prime }$ in block 2, if they are different, we also cannot find two identical paths ${\mathcal{P}}_1$ and ${\mathcal{P}}_2$ in $E_N$, which satisfies ${\mathcal{P}}_1^{\prime }\in {\mathcal{P}}_1$ and ${\mathcal{P}}_2^{\prime }\in {\mathcal{P}}_2$.

 Case 3: 

For two paths ${\mathcal{P}}_1^{\prime }$ in block 1 and ${\mathcal{P}}_2^{\prime }$ in block 2, if they are identical, according to the recursive construction of $E_N$ from two copies of $E_{N/2}$, we can see that path ${\mathcal{P}}_1^{\prime }$ follows a target node ⊕, and path ${\mathcal{P}}_2^{\prime }$ follows a control node ⊙. These target node ⊕ and control node ⊙ belong to the same CNOT gate. Hence, we have two different paths ${\mathcal{P}}_1=\{\oplus ,{\mathcal{P}}_1^{\prime }\}$ and ${\mathcal{P}}_1=\{\odot ,{\mathcal{P}}_2^{\prime }\}$.

Therefore, no matter in which case, we cannot find two identical paths in the same encoding block ${\mathcal{E}}_N$, which completes the proof.    □

 Lemma 2 (Relation between two paths which have only one different node). 

For two paths ${\mathcal{P}}_i=\left\{{node}_n^i,\cdots ,{node}_1^i\right\}$ and ${\mathcal{P}}_j=\left\{{node}_n^j,\cdots ,{node}_1^j\right\}(i<j)$ in encoding circuit $E_N$, the number of target node ⊕ contained by ${\mathcal{P}}_i$ is $n_{\oplus }^i$ and that contained by ${\mathcal{P}}_j$ is $n_{\oplus }^j$. We have $n_{\oplus }^i=n_{\oplus }^j+1$ if and only if these two paths pass through the same CNOT gate.

 Proof. 

(1) Necessity: Assuming that the mth ($2\le m\le lo{g}_2(n-1)$) nodes of ${\mathcal{P}}_i$ and ${\mathcal{P}}_j$ belong to the same CNOT gate, namely, ${\mathcal{P}}_i=\left\{{\mathcal{P}}_i^{for},\oplus ,{\mathcal{P}}_i^{lat}\right\}$ and ${\mathcal{P}}_j=\left\{{\mathcal{P}}_j^{for},\odot ,{\mathcal{P}}_j^{lat}\right\}$, where ${\mathcal{P}}_i^{for}$ and ${\mathcal{P}}_j^{for}$ are the former path of ${\mathcal{P}}_i$ and ${\mathcal{P}}_j$ respectively, and ${\mathcal{P}}_i^{lat}$ and ${\mathcal{P}}_j^{lat}$ are the latter path of ${\mathcal{P}}_i$ and ${\mathcal{P}}_j$, respectively.

Since the mth nodes of ${\mathcal{P}}_i$ and ${\mathcal{P}}_j$ belong to the same CNOT gate, according to the recursive construction of the encoding circuit, we must have ${\mathcal{P}}_i^{lat}={\mathcal{P}}_j^{lat}$.

Suppose the indexes of ⊕ and ⊙ are a and b, respectively, since they belong to the same CNOT gate, we have $b=a+1$. According to the recursive construction of encoding circuit, the node ⊕ with index a located at the $(m+1)$th CNOT gate block of $E_N$ must following ${node}_{m+2}$ with index $2a$ (or $2a-1$) located at the $(m+2)$th CNOT gate block, and node ⊙ with index $b=a+1$ located at the $(m+1)$th CNOT gate block must following ${node}_{m+2}^{\prime }$ with index $2b$ (or $2b-1$) located at the $(m+2)$th CNOT gate block, which means the index of ${node}_{m+2}$ and ${node}_{m+2}^{\prime }$ must both be odd or even numbers. If they are both even numbers, these two nodes are both control nodes, and if they are both odd numbers, these two nodes are both target nodes. Recursively using this relation, we have ${\mathcal{P}}_i^{for}={\mathcal{P}}_j^{for}$; thus, $n_{\oplus }^i=n_{\oplus }^j+1$.

(2) Sufficiency: Using proof by contradiction, we assume that there exists a $pat{h}_h$, which satisfies $n_{\oplus }^h=n_{\oplus }^j+1$, but $pat{h}_h$ and $pat{h}_j$ do not pass through the same CNOT gate. Suppose that the lth nodes of $pat{h}_h$ and $pat{h}_j$ are different, according to the necessity above, at the CNOT gates block corresponding to the lth node, there is a path $pat{h}_i$ that passes through the same CNOT gate as $pat{h}_j$, which satisfies $n_{\oplus }^i=n_{\oplus }^j+1$, and their former paths and latter paths are the same. Thus, we have $pat{h}_h=pat{h}_i$, which contradicts Lemma 1. Thus, the path $pat{h}_h$ above does not exist.

The proof is completed.    □

 Lemma 3 (The weight of stabilizer generator and logical operator). 

For the ith path ${\mathcal{P}}_i=\left\{{node}_n^i,\cdots ,{node}_1^i\right\}$ in encoding circuit $E_N$, the number of target node ⊕ that it contains is denoted by $n_{\oplus }^i$ and that of control node ⊙ is denoted by $n_{\odot }^i$ (we can see that $n_{\oplus }^i+n_{\odot }^i=\left|\mathcal{P}\right|=n={log}_{2}N$). If the ith input qubit $Q_i$ of $E_N$ is a frozen qubit and its state is set to $|0⟩$, the weight of the ith stabilizer generator (Z-type) $S_i$ is $2^{n_{\oplus }^i}$. Likewise, if it is logical qubit, the weight of ith logical X operator $\overline{X_i}$ is $2^{n_{\odot }^i}$.

 Proof. 

Since, as mentioned in Section 2.1, the behavior of $E_N$ can be specified as a unitary operator $U_{E_N}$. If the ith input qubit $Q_i$ of $E_N$ is set to state $|0⟩$, it is a frozen qubit, and the Pauli Z operator $Z_i$ acting on $Q_i$ is transformed to the ith stabilizer generators $S_i$ under conjugation by $U_{E_N}$, namely, $S_i=U_{E_N}{Z}_i{U}_{E_N}^{†}$. If $Q_i$ is a logical qubit, the Pauli X operator acting on it are transformed to logical X operator under conjugation by $U_{E_N}$, namely, $\overline{X_i}=U_{E_N}{X}_i{U}_{E_N}^{†}$.

If $Q_i$ is a frozen qubit, we consider how the Pauli Z operator $Z_i$ transforms under conjugation by $U_{E_N}$. As shown in Figure 3, if a Pauli Z operator (whose weight is 1) passes through a target node ⊕ of a CNOT gate, its weight becomes 2, while if it passes through a control node ⊙, its weight remains invariant. If we assume that ${node}_n^i$ of ${\mathcal{P}}_i$ is target node ⊕, $Z_i$ become $Z_i{Z}_{i-1}$ under conjugation by the first CNOT gate. After the conjugation, $Z_i$ continues along a subpath ${\mathcal{P}}_i^{\prime }\in {\mathcal{P}}_i$, while $Z_{i-1}$ along another path ${\mathcal{P}}_{i-1}^{\prime }$. However, as we prove in Lemma 1, we must have ${\mathcal{P}}_i^{\prime }={\mathcal{P}}_{i-1}^{\prime }$, since ${\mathcal{P}}_{i-1}^{\prime }$ follows a control node ⊙ while ${\mathcal{P}}_i^{\prime }$ follows a target node ⊕, and these two nodes belong to a same CNOT gate. Thus, the transformation of weight of $Z_{i-1}$ along ${\mathcal{P}}_{i-1}^{\prime }$ is the same as that of $Z_i$ along ${\mathcal{P}}_i^{\prime }$, which simultaneously multiplies by 2 or remains invariant dependent on the first node of ${\mathcal{P}}_i^{\prime }$ is ⊕ or ⊙. Recursively using this law, the weight of the ith stabilizer generators $S_i$ must be $2^{n_{\oplus }^i}$.

Likewise, if $Q_i$ is a logical qubit, the analysis process is the same and the weight of the ith logical X operator $\overline{X_i}$ is $2^{n_{\odot }^i}$.    □

 Theorem 1 (Negative correlation between the weight of stabilizer generators and the channel quality of quantum coordinate channels). 

For two paths ${\mathcal{P}}_a=\left\{{node}_n^a,\cdots ,{node}_1^a\right\}$ and ${\mathcal{P}}_b=\left\{{node}_n^b,\cdots ,{node}_1^b\right\}$ in encoding circuit $E_N$, the number of target node ⊕ contained by ${\mathcal{P}}_a$ is $n_{\oplus }^a$ and that contained by ${\mathcal{P}}_b$ is $n_{\oplus }^b$. If $n_{\oplus }^a>n_{\oplus }^b$, the Bhattacharyya parameter of quantum coordinate channel ${\mathcal{E}}_N^{\left(a\right)}$ is greater than that of ${\mathcal{E}}_N^{\left(b\right)}$, namely, $Z\left({\mathcal{E}}_N^{\left(a\right)}\right)>Z\left({\mathcal{E}}_N^{\left(b\right)}\right)$.

 Proof. 

Since $n_{\oplus }^a>n_{\oplus }^b$, we can suppose $n_{\oplus }^a=n_{\oplus }^b+x$. Here, we only consider the case that $x=1$ (i.e., $n_{\oplus }^a=n_{\oplus }^b+1$). If in this case we can prove $Z\left({\mathcal{E}}_N^{\left(a\right)}\right)>Z\left({\mathcal{E}}_N^{\left(b\right)}\right)$, this relation holds for arbitrary $x\ge 1$.

By Lemma 2, when $n_{\oplus }^a=n_{\oplus }^b+1$, ${\mathcal{P}}_a$ and ${\mathcal{P}}_b$ can be rewritten as ${\mathcal{P}}_a=\left\{{\mathcal{P}}_a^{for},\oplus ,{\mathcal{P}}_a^{lat}\right\}$ and ${\mathcal{P}}_b=\left\{{\mathcal{P}}_b^{for},\odot ,{\mathcal{P}}_b^{lat}\right\}$, where ${\mathcal{P}}_a^{for}={\mathcal{P}}_b^{for}$, ${\mathcal{P}}_a^{lat}={\mathcal{P}}_b^{lat}$, and the two nodes ⊕ and ⊙ belong to a same CNOT gate. Suppose this CNOT gate is located at the $\left(m+1\right)$th CNOT gates block and the index of nodes ⊕ located at this CNOT gates block is $i^{\prime }$, the index of nodes ⊙ must be $j^{\prime }=i^{\prime }+1$. According to Equation (14), we have,

$$\begin{array}{c}\hfill \begin{array}{c}Z\left({\mathcal{E}}_{{\displaystyle \frac{N}{2^{n-m-1}}}}^{\left(i^{\prime }\right)}\right)=2Z\left({\mathcal{E}}_{{\displaystyle \frac{N}{2^{n-m}}}}^{\left(i^{″}\right)}\right)-{\left(Z\left({\mathcal{E}}_{{\displaystyle \frac{N}{2^{n-m}}}}^{\left(i^{″}\right)}\right)\right)}^2\\ Z\left({\mathcal{E}}_{{\displaystyle \frac{N}{2^{n-m-1}}}}^{\left(j^{\prime }\right)}\right)={\left(Z\left({\mathcal{E}}_{{\displaystyle \frac{N}{2^{n-m}}}}^{\left(i^{″}\right)}\right)\right)}^2\end{array}\end{array}$$

(15)

where $i^{\prime }=2i^{″}-1$ and $j^{\prime }=2i^{″}$. One can verify that

$$\begin{array}{c}\hfill Z\left({\mathcal{E}}_{{\displaystyle \frac{N}{2^{n-m-1}}}}^{\left(i^{\prime }\right)}\right)-Z\left({\mathcal{E}}_{{\displaystyle \frac{N}{2^{n-m-1}}}}^{\left(j^{\prime }\right)}\right)=2Z\left({\mathcal{E}}_{{\displaystyle \frac{N}{2^{n-m}}}}^{\left(i^{″}\right)}\right)-{\left(Z\left({\mathcal{E}}_{{\displaystyle \frac{N}{2^{n-m}}}}^{\left(i^{″}\right)}\right)\right)}^2-{\left(Z\left({\mathcal{E}}_{{\displaystyle \frac{N}{2^{n-m-1}}}}^{\left(i^{″}\right)}\right)\right)}^2\end{array}$$

(16)

Since $Z\left({\mathcal{E}}_{{\displaystyle \frac{N}{2^{n-m}}}}^{\left(i^{″}\right)}\right)$ takes values in $\left[0,1\right]$, we must have $Z\left({\mathcal{E}}_{{\displaystyle \frac{N}{2^{n-m-1}}}}^{\left(i^{\prime }\right)}\right)-Z\left({\mathcal{E}}_{{\displaystyle \frac{N}{2^{n-m-1}}}}^{\left(j^{\prime }\right)}\right)\ge 0$, with equality holds for $Z\left({\mathcal{E}}_{{\displaystyle \frac{N}{2^{n-m}}}}^{\left(i^{″}\right)}\right)=0$ or 1.

Suppose the ith and the jth nodes in the $\left(m+2\right)$th CNOT gates block connect to the $i^{\prime }$th node ⊕ and the $j^{\prime }$th node ⊙ in the $\left(m+1\right)$th CNOT gates block, respectively, according to Equation (14), the index i and j satisfy $(i=2i^{\prime },j=2j^{\prime })$ or $(i=2i^{\prime }-1,j=2j^{\prime }-1)$.

 Case 1: 

if $i=2i^{\prime }$, $j=2j^{\prime }$, we have

$$\begin{array}{c}\hfill Z\left({\mathcal{E}}_{{\displaystyle \frac{N}{2^{n-m-2}}}}^{\left(i\right)}\right)=Z{\left({\mathcal{E}}_{{\displaystyle \frac{N}{2^{n-m-1}}}}^{\left(i^{\prime }\right)}\right)}^2\\ \hfill Z\left({\mathcal{E}}_{{\displaystyle \frac{N}{2^{n-m-2}}}}^{\left(j\right)}\right)=Z{\left({\mathcal{E}}_{{\displaystyle \frac{N}{2^{n-m-1}}}}^{\left(j^{\prime }\right)}\right)}^2\end{array}$$

(17)

 Case 2: 

if $i=2i^{\prime }-1$, $j=2j^{\prime }-1$, we have

$$\begin{array}{c}\hfill Z\left({\mathcal{E}}_{{\displaystyle \frac{N}{2^{n-m-2}}}}^{\left(i\right)}\right)=2Z\left({\mathcal{E}}_{{\displaystyle \frac{N}{2^{n-m-1}}}}^{\left(i^{\prime }\right)}\right)-Z{\left({\mathcal{E}}_{{\displaystyle \frac{N}{2^{n-m-1}}}}^{\left(i^{\prime }\right)}\right)}^2\\ \hfill Z\left({\mathcal{E}}_{{\displaystyle \frac{N}{2^{n-m-2}}}}^{\left(j\right)}\right)=2Z\left({\mathcal{E}}_{{\displaystyle \frac{N}{2^{n-m-1}}}}^{\left(j^{\prime }\right)}\right)-Z{\left({\mathcal{E}}_{{\displaystyle \frac{N}{2^{n-m-1}}}}^{\left(j^{\prime }\right)}\right)}^2\end{array}$$

(18)

Since $Z\left({\mathcal{E}}_{N/2^{n-m-1}}^{\left(i^{\prime }\right)}\right)\ge Z\left({\mathcal{E}}_{{\displaystyle \frac{N}{2^{n-m-1}}}}^{\left(j^{\prime }\right)}\right)$, no matter which case, we have,

$$Z\left({\mathcal{E}}_{{\displaystyle \frac{N}{2^{n-m-2}}}}^{\left(i\right)}\right)>Z\left({\mathcal{E}}_{{\displaystyle \frac{N}{2^{n-m-2}}}}^{\left(j\right)}\right)$$

(19)

Using this recursion of the Bhattacharyya parameter, one can obtain

$$Z\left({\mathcal{E}}_N^{\left(a\right)}\right)>Z\left({\mathcal{E}}_N^{\left(b\right)}\right)$$

(20)

which completes the proof.    □

It should be noted that when $n_{\oplus }^a>n_{\oplus }^b$, it is uncertain which of either $Z\left({\mathcal{E}}_N^{\left(a\right)}\right)$ or $Z\left({\mathcal{E}}_N^{\left(b\right)}\right)$ is greater.

Using Theorem 1 and Lemma 3, we can obtain Corollary 1, namely, the weight of stabilizer generators and logical X operators of QPSCs will polarize.

 Corollary 1 (Polarization of the weight of stabilizer generators and logical X operators of QPSCs). 

For the encoding circuit $E_N$ as shown in Figure 2c, the corresponding stabilizer generators of quantum coordinate channels are $S_1,\cdots ,S_N$, which can be divided into $n+1(n={log}_{2}N)$ parts according to their weight, namely,

$$S=\{S_{weight=2^0},S_{weight=2^1},\cdots ,S_{weight=2^n}\}$$

(21)

where $S_{weight=2^i}\in S$ is the subset of S, which contains all stabilizer generators whose weight is $2^i$. Likewise, the corresponding logical X operators of quantum coordinate channels are $L=\{\overline{X_1},\cdots ,\overline{X_N}\}$ which can be divided into $n+1$ parts according to their weight, namely,

$$L=\{L_{weight=2^0},L_{weight=2^1},\cdots ,L_{weight=2^n}\}$$

(22)

Since the channel quality will polarize, according to Lemma 3 and Theorem 1, the weight of stabilizer generators and logical X operators of QPSCs will polarize.

 Proof. 

For a path $\mathcal{P}=\left\{{node}_n,\cdots ,{node}_1\right\}$ in the encoding circuit $E_N$, where $n={log}_{2}N$ and ${node}_i\in ⨁,⨀$, $1\le i\le n$, suppose the number of target node ⨁ of $\mathcal{P}$ is $n_{\oplus }=x(0\le x\le n)$, by Lemma 3, its weight is $2^x$. Since each ${node}_i(1\le i\le n)$ only takes values in $⨁,⨀$, and all paths in $E_N$ are unique, there are $\left({\displaystyle \genfrac{}{}{0pt}{}{n}{x}}\right)$ different paths whose number of target node ⨁ are x. Moreover, these $\left({\displaystyle \genfrac{}{}{0pt}{}{n}{x}}\right)$ different paths correspond to $\left({\displaystyle \genfrac{}{}{0pt}{}{n}{x}}\right)$ stabilizer generators whose weights are all $2^x$. Hence, the set $S=S_1,\cdots ,S_N$ can be divided into $n+1$ parts according to the weight, namely, $S=\{S_{weight=2^0},S_{weight=2^1},\cdots ,S_{weight=2^n}\}$.

By Theorem 1, the Bhattacharyya parameter of the $\left({\displaystyle \genfrac{}{}{0pt}{}{n}{i}}\right)$ quantum coordinate channels whose corresponding $\left({\displaystyle \genfrac{}{}{0pt}{}{n}{i}}\right)$ stabilizer generators are all $2^i$ is lager than that of the $\left({\displaystyle \genfrac{}{}{0pt}{}{n}{j}}\right)$ quantum coordinate channels whose corresponding $\left({\displaystyle \genfrac{}{}{0pt}{}{n}{j}}\right)$ stabilizer generators are all $2^j$, for arbitrary $0\le j<i\le n$. As the Bhattacharyya parameter will polarize, the weight of the stabilizer will polarize.

For the set of logical X operators $L=\{\overline{X_1},\cdots ,\overline{X_N}\}$, we have the same conclusion and the similar proof is omitted.    □

For a stabilizer code C, suppose its stabilizer group is $𝒮=⟨S_1,\cdots ,S_{N-k}⟩$, there is a useful way to represent $𝒮$ by using parity-check matrix H. In bit-flip channels, all stabilizer generators of $𝒮$ only contains Pauli Z operator, Hence H is a $(N-k)\times N$ matrix whose rows correspond to generators $S_1$ through $S_{N-k}$. For generator $S_i$, if it contains a Z on the jth qubit, the element $g_{i,j}$ of H located at the ith row and the jth column is 1, while it contains an I on the jth qubit, the element $g_{i,j}$ of H located at the ith row and the jth column is 0. For the logical operators of C, we can use a similar way, namely, logical operator matrix to represent it.

For QPSCs with code length $N=2^n,n\ge 1$, if the ith input qubit $Q_i$ is a frozen qubit, the ith element of $1\times N$ row vector representation $r\left(Z_i\right)$ of Pauli Z operator $Z_i$ acting on $Q_i$ is 1, while the rest of it is 0. The stabilizer generator $S_i$, which is transformed from $Z_i$ under conjugation by the encoding process $U_{E_N}$, is $S_i=U_{E_N}{Z}_i{U}_{E_N}^{†}$, and its corresponding row vector representation is

$$r\left(S_i\right)=r\left(Z_i\right)G_N$$

(23)

where $G_N=F^{\otimes n}$, $F=\left(\begin{array}{cc}1& 1\\ 0& 1\end{array}\right)$. Likewise, if $Q_i$ is a logical qubit, the Pauli X operator acting on $Q_i$ is $X_i$ and corresponding row vector representation is $r\left(X_i\right)$. Then the logical X operator, which is transformed from $X_i$ under conjugation by the encoding process $U_{E_N}$, is $\overline{X_i}=U_{E_N}{X}_i{U}_{E_N}^{†}$, and its corresponding row vector representation is

$$r\left(\overline{X_i}\right)=r\left(X_i\right)G_N^T$$

(24)

4. Construction Algorithms of Quantum Polar Stabilizer Codes

In this section, we propose two construction algorithms of QPSCs—CA algorithm and BS algorithm. The first algorithm is based on the ranking of channel quality of quantum coordinate channels which is similar to the code construction of classical polar code mentioned in Section 2.3. The second algorithm is based on the ranking of quantum coordinate channels according to the weight of their corresponding stabilizer generators. It is obvious that CA is the same as the construction in Ref. [33]. We believe BS is more reasonable than the existing constructions, because they are designed in a way from the point of view of stabilizer codes by considering the weight of logical operators and stabilizers and the code distance, which influence the correcting capability of stabilizer codes.

4.1. Coherent-Information-Achieving Construction

As mentioned in Section 2.4, the Bhattacharyya parameter can also be used to measure quantum channel quality, and we can approximately estimate the Bhattacharyya parameter of each ${\mathcal{E}}_N^{\left(i\right)}$ by Equation (14). In CA algorithm, we use the Bhattacharyya parameter to rank channel quality. The detailed process of CA is as follows,

 Step 1: 

For bit-flip channel $\mathcal{E}$ with error probability p, compute its symmetric coherent information (i.e., MSLCI) $I\left(\rho ={\displaystyle \frac{1}{2}}|0⟩⟨0|+{\displaystyle \frac{1}{2}}|1⟩⟨1|,\mathcal{E}\right)=1-H\left(p\right)$, where $H(·)$ is the Shannon entropy.

 Step 2: 

Determine code length N and compute the number of logical qubits $k=⌊N(1-H(p\left)\right)⌋$.

 Step 3: 

Use Equation (14) to approximately estimate the Bhattacharyya parameter $Z\left({\mathcal{E}}_N^{\left(i\right)}\right)$ of each ${\mathcal{E}}_N^{\left(i\right)}$, then rank the coordinate channels in descending order according to their Bhattacharyya parameter and choose the former k channels to transmit data qubits while the last $N-k$ channels transmit frozen qubits, which are set to state ${|0⟩}^{\otimes N-k}$.

 Step 4: 

Use Equation (23) and Equation (24) to compute the row vector representation of stabilizer generators and logical operators.

The pseudocode is shown in Algorithm 1.

Algorithm 1 Coherent-information-achieving construction

Require: primal error rate p, code length parameter n  Ensure: parity-check matrix H, logical operator matrix $H_L$  CodeLength $N=2^n$;  $k=⌊N\times (1-H(p\left)\right)⌋$;  Compute the Bhattacharyya parameter of all quantum coordinate channels: $Z_{BP}$;  $ChannelOrder=Sort(Z_{BP},‘descend\text{’})$;  $FrozenQubitsIndex=ChannelOrder(1:N-k)$;  $LogicalQubitsIndex=ChannelOrder(N-k+1:N)$;  Initialize $H=zeros(N-k,N)$, $H_L=zeros(k,N)$;  for $i=1$ to $N-k$ do     $H\left[i,FrozenQubitsIndex\left[i\right]\right]=1$  end for  for $i=1$ to k do     $H_L\left[i,LogicalQubitsIndex\left[i\right]\right]=1$;     $H=H{G}_N$;     $H_L=H_L{G}_N^T$;  end for

Under this construction algorithm, our simulation results in Section 5 show that the LERs increase with code lengths. It is obvious that the CA construction is equivalent to the construction in Ref. [33]. According to Theorem 1, one can understand why we choose the information position by channel quality—this will guarantee us to obtain a code with a distance as large as possible.

4.2. Block Selection Construction

According to Theorem 1, if the channel quality of the ith quantum coordinate channel is worse than that of the jth, the weight of the corresponding stabilizer generator of the ith must be no less than that of the jth. Using this, we can rank quantum coordinate channels according to the weight of their corresponding stabilizer generators in a block-by-block way. The second algorithm called block selection is based on this ranking.

For arbitrary stabilizer code, its code distance, which is defined as the minimum weight of its logical operators, determines the number of error qubits it can correct. Increasing its code distance will help to improve its error-correcting capability. Given a certain code length, more logical qubits (namely, less stabilizer generators) may lead to a smaller code distance. Hence, the goal of the block selection algorithm is to increase the number of stabilizer generators to increase the code distance of QPSCs.

For bit-flip channel $\mathcal{E}$ with error probability p, under the CA algorithm, the number of logical qubits of a QPSC is $k=⌊N(1-H(p\left)\right)⌋$. We rank the quantum coordinate channels in descending order according to the weight of their corresponding stabilizer generators. Since there might be more than one coordinate channel with the same stabilizer generator weight, this ranking method will rank the coordinate channels block by block, and those coordinate channels in the same block have the same stabilizer generator weight. Then we assume that the weight of stabilizer generators of the $\left(N-k\right)$th quantum coordinate channel is $2^x(0\le x\le n={log}_{2}N)$. According to Lemma 3, the minimum weight of logical operators is $2^{n-x}$. Notice that there are $\left({\displaystyle \genfrac{}{}{0pt}{}{n}{x}}\right)$ quantum coordinate channels that the weight of their corresponding stabilizer generators is equal to $2^x$. If these $\left({\displaystyle \genfrac{}{}{0pt}{}{n}{x}}\right)$ channels are all chosen to transmit frozen qubits, the total number of stabilizer generators will be ${\sum }_{m=x}^n\left({\displaystyle \genfrac{}{}{0pt}{}{n}{m}}\right)$, and the minimum weight of logical operators will increase to $2^{n-x+1}$. We can see that this can help to improve the error-correcting capability of QPSCs, since it increases the number of stabilizer generators and the code distance. Notice that we chose quantum coordinate channels in a block-wise way. If a coordinate channel is chosen to transmit frozen/data qubits, the whole block it belongs to will be chosen to transmit frozen/data. Hence, this algorithm is called block selection. The detailed process is as follows:

 Step 1: 

For bit-flip channel $\mathcal{E}$ with error probability p, compute its symmetric coherent information $I(\rho ={\displaystyle \frac{1}{2}}|0⟩⟨0|+{\displaystyle \frac{1}{2}}|1⟩⟨1|,\mathcal{E})=1-H\left(p\right)$, where $H(·)$ is the Shannon entropy.

 Step 2: 

Determine code length N and compute $k^{\prime }=⌊N(1-H(p\left)\right)⌋$. Different from the case in CA algorithm, we emphasize that $k^{\prime }$ here is not the number of logical qubits, but just an intermediate number which is used to determine the number of logical qubit k.

 Step 3: 

Through Equation (23), compute the stabilizer generator of each quantum coordinate channel, and rank these channels in descending order according to the weight of their corresponding stabilizer generators.

 Step 4: 

Find the $(N-k^{\prime })$th quantum coordinate channel and computing the weight of its corresponding stabilizer generator. Suppose the weight is $2^x(0\le x\le n={log}_{2}N)$, then choose all quantum coordinate channels that the weight of their corresponding stabilizer generators is greater than or equal to $2^x$ to transmit frozen qubits. We can see that the number of frozen qubits is ${\sum }_{a=x}^n\left({\displaystyle \genfrac{}{}{0pt}{}{n}{a}}\right)$.

 Step 5: 

Compute the number of logical qubits $k=N-{\sum }_{a=x}^n\left({\displaystyle \genfrac{}{}{0pt}{}{n}{a}}\right)$, and the former $N-k$ quantum coordinate channels are used to transmit frozen qubits which are set to state ${|0⟩}^{\otimes N-k}$ and the last k channels to transmit logical qubits.

 Step 6: 

Use Equation (23) and Equation (24) to compute the row vector representation of each logical operator and stabilizer generator.

The pseudocode is shown in Algorithm 2.

One can see that given the same error probability p, the coding rate of CA is greater than or equal to that of BS, and the number of stabilizer generators and hence the code distance of CA is no more than that of BS. Thus, intuitively, the error-correcting capability of the BS algorithm is greater than or equal to that of the CA algorithm. However, the simulation results in Section 5 do not show this feature so obviously. This is because, in the range of error probability we consider, the average number of error qubits in a single simulation test is much lower than the code distance for both BS and CA. Hence, the error-correcting capabilities of the BS and CA algorithms are similar to each other.

Algorithm 2 Block selection construction

Require: primal error rate p, code length parameter n  Ensure: parity-check matrix H, logical operator matrix $H_L$ CodeLength $N=2^n$;   $k^{\prime }=⌊N\times (1-H(p\left)\right)⌋$;   Initialize $S=zeros(N,N)$;   for $i=1$ to N do      $S\left[i,i\right]=1$   end for $S=S{G}_N$;   Compute the weight of all rows of S$Weight$;   $ChannelOrder=Sort(Weight,‘descend\text{’})$;   $w=ChannelOrder\left[k^{\prime }\right]$;   $x={log}_{2}w$;   $k={\sum }_{a=x}^n\left({\displaystyle \genfrac{}{}{0pt}{}{n}{a}}\right)$;   $FrozenQubitsIndex=ChannelOrder(1:N-k)$;   $LogicalQubitsIndex=ChannelOrder(N-k+1:N)$;   Initialize $H=zeros(N-k,N)$, $H_L=zeros(k,N)$;   for $i=1$ to $N-k$ do      $H\left[i,FrozenQubitsIndex\left[i\right]\right]=1$;   end for   for $i=1$ to k do      $H_L\left[i,LogicalQubitsIndex\left[i\right]\right]=1$;   end for$H=H{G}_N$;   $H_L=H_L{G}_N^T$;

5. Simulation Results and Analysis

There is an important concept of QECCs—noise threshold. For a certain class of QECCs, when the error probability is lower than its noise threshold, we can decrease the LER of a single logical qubit $LE{R}_{slq}$ by increasing the code length. When the error probability is higher than the noise threshold, the $LE{R}_{slq}$ will increase with the code length growth, which means this QECC fails. If a class of codes works for quantum computing, it should have such a threshold.

To test the error-correcting capability of QPSCs and find out whether they have such threshold, we perform simulations. In the range of p from $1\times {10}^{-5}$ to $1\times {10}^{-2}$, under both unreliable and reliable frozen qubits assumptions, no evidence shows that the LER of single logical qubit $LE{R}_{slq}$ of both CA and BS can be decreased by increasing the code length and we cannot find the noise threshold. Notice that reliable frozen qubits correspond to reliable entanglement qubits in ref. [33].

5.1. Simulation Results

In the simulations, we assume that the error syndrome measurement is perfect and perform 100,000 simulations for each data point. Besides, two decoders are used. The first decoders is named table-look-up decoders which is realized by creating a syndrome-to-error lookup table that exhaustively list the best recovery operation for each error syndrome. The time cost and memory space of creating such complete syndrome-to-error lookup table rapidly become intractable as code length growing. To reduce the time cost and memory space, we only create an approximate incomplete table that lists the error whose the number of error qubits is within $t_{error}$, where $t_{error}$ is a parameter to control the approximation and larger than the average number of error qubits $N{p}_0$ in a single simulation test, where N is the code length, p is the qubit error rate. This is because in each simulation the probability of the events that the number of error qubits does not equal to $N{p}_0$ tends to zero as N grows. Hence, setting $t_{error}$ to a sufficient large value can guarantee the lookup table sufficiently complete for practical decoding task. We also use another decoder called bit-flip decoder whose time cost and memory space is linear with the code length. The simulation results show that in the low error rate regime from $1\times {10}^{-5}$ to $1\times {10}^{-2}$, the error-correcting performance of these two decoders is close. However, we observed that the bit-flip decoder is sensitive to the primal error rate p, and it may fail in the high error rate regime with code length increasing. The details of the bit-flip decoder are shown in Appendix A.

Figure 4 shows the coding rate of the CA and BS algorithms with different physical qubit error rates and code lengths. We can see that in the range of p from $1\times {10}^{-5}$ to $1\times {10}^{-4}$, under different code lengths considered in the simulations, the coding rate of CA is the same as that of the BS algorithm. Hence, in the range of p from $1\times {10}^{-5}$ to $1\times {10}^{-4}$, we only need to perform simulations under CA algorithms.

Figure 4. The coding rate of CA and BS algorithms with different physical qubit error rates and code lengths $N=2^n$. (a) Physical error rate ranges from $1\times {10}^{-5}$ to $1\times {10}^{-4}$. (b) Physical error rate ranges from $1\times {10}^{-4}$ to $1\times {10}^{-3}$. (c) Physical error rate ranges from $1\times {10}^{-3}$ to $1\times {10}^{-2}$.

Figure 5 shows the simulation results with unreliable frozen qubits and table-look-up decoder. Figure 6 shows the simulation results with unreliable frozen qubits and the bit-flip decoder. It should be noticed that the LER of code blocks $LE{R}_{block}$, which is the rate of code blocks with logical error, is directly obtained by counting the simulation results, while the LER of the single logical qubit $LE{R}_{slq}$ is calculated from $LE{R}_{block}$ by Equation (25), which is also used in [49]. These two decoders have similar performance in the range of p from $1\times {10}^{-5}$ to $1\times {10}^{-2}$, which is shown in Figure 7. In Figure 7, the parameter that is used to control the approximation accuracy is set to 4 in the range of p from $1\times {10}^{-3}$ to $1\times {10}^{-2}$ and 2 in the range of p from $1\times {10}^{-5}$ to $1\times {10}^{-3}$. In the physical qubit error rate range considered in our simulation, even for the largest code length ($N=2^8$ with physical qubit error rate less than ${10}^{-4}$ and $N=2^6$ with physical qubit error rate less than ${10}^{-2}$) we used, the average number of error qubits is less than 1, which means the probability of an error event that contains more than 1 error qubit generated by the simulation program is almost 0 (in our simulation, for 100,000 times test, only around one to three simulations will produce an error event contains more than one error qubit). The performance of the table-look-up decoder under the CA algorithm with different $t_{error}$ is shown in Figure 8. Figure 9 shows the simulation results with reliable frozen qubits and the table-look-up decoder. Figure 10 shows the simulation results with reliable frozen qubits and bit-flip decoder. As shown in Figure 5, Figure 6, Figure 9 and Figure 10, in the range of p from $1\times {10}^{-5}$ to $1\times {10}^{-2}$, there is no evidence showing that the LER of single logical qubit $LE{R}_{slq}$ can be decreased by increasing the code length, and the noise threshold does not exist. (There are several points that seem abnormal in Figure 5d,f,g,i and Figure 10g,i. This is because of the abrupt change in the coding rate of BS algorithms.)

$${(1-LE{R}_{slq})}^k=1-LE{R}_{block}$$

(25)

Figure 5. The LER with unreliable frozen qubits and table-look-up decoder. “Logical error rate” represents $LE{R}_{block}$ and “Slq Logical error rate” represents $LE{R}_{slq}$. (a) The $LE{R}_{block}$ of QPSCs constructed by CA and BS algorithms with physical error rate ranging from $1\times {10}^{-5}$ to $1\times {10}^{-4}$. (b) The $LE{R}_{slq}$ of QPSCs constructed by CA algorithms with physical error rate ranging from $1\times {10}^{-5}$ to $1\times {10}^{-4}$. (c) The $LE{R}_{slq}$ of QPSCs constructed by BS algorithms with physical error rate ranging from $1\times {10}^{-5}$ to $1\times {10}^{-4}$. (d) The $LE{R}_{block}$ of QPSCs constructed by CA and BS algorithms with physical error rate ranging from $1\times {10}^{-4}$ to $1\times {10}^{-3}$. (e) The $LE{R}_{slq}$ of QPSCs constructed by CA algorithms with physical error rate ranging from $1\times {10}^{-4}$ to $1\times {10}^{-3}$. (f) The $LE{R}_{slq}$ of QPSCs constructed by BS algorithms with physical error rate ranging from $1\times {10}^{-4}$ to $1\times {10}^{-3}$. (g) The $LE{R}_{block}$ of QPSCs constructed by CA and BS algorithms with physical error rate ranging from $1\times {10}^{-3}$ to $1\times {10}^{-2}$. (h) The $LE{R}_{slq}$ of QPSCs constructed by CA algorithms with physical error rate ranging from $1\times {10}^{-3}$ to $1\times {10}^{-2}$. (i) The $LE{R}_{slq}$ of QPSCs constructed by BS algorithms with physical error rate ranging from $1\times {10}^{-3}$ to $1\times {10}^{-2}$.

Figure 6. The LER with unreliable frozen qubits and bit-flip decoder. “Logical error rate” represents $LE{R}_{block}$ and “Slq Logical error rate” represents $LE{R}_{slq}$. (a) The $LE{R}_{block}$ of QPSCs constructed by CA and BS algorithms with physical error rate ranging from $1\times {10}^{-5}$ to $1\times {10}^{-4}$. (b) The $LE{R}_{slq}$ of QPSCs constructed by CA algorithms with physical error rate ranging from $1\times {10}^{-5}$ to $1\times {10}^{-4}$. (c) The $LE{R}_{slq}$ of QPSCs constructed by BS algorithms with physical error rate ranging from $1\times {10}^{-5}$ to $1\times {10}^{-4}$. (d) The $LE{R}_{block}$ of QPSCs constructed by CA and BS algorithms with physical error rate ranging from $1\times {10}^{-4}$ to $1\times {10}^{-3}$. (e) The $LE{R}_{slq}$ of QPSCs constructed by CA algorithms with physical error rate ranging from $1\times {10}^{-4}$ to $1\times {10}^{-3}$. (f) The $LE{R}_{slq}$ of QPSCs constructed by BS algorithms with physical error rate ranging from $1\times {10}^{-4}$ to $1\times {10}^{-3}$. (g) The $LE{R}_{block}$ of QPSCs constructed by CA and BS algorithms with physical error rate ranging from $1\times {10}^{-3}$ to $1\times {10}^{-2}$. (h) The $LE{R}_{slq}$ of QPSCs constructed by CA algorithms with physical error rate ranging from $1\times {10}^{-3}$ to $1\times {10}^{-2}$. (i) The $LE{R}_{slq}$ of QPSCs constructed by BS algorithms with physical error rate ranging from $1\times {10}^{-3}$ to $1\times {10}^{-2}$.

Figure 7. The performance of table-look-up decoder and bit-flip decoder in the range of p from $1\times {10}^{-5}$ to $1\times {10}^{-2}$. The code length is set to $N=2^6$. “Logical error rate” represents $LE{R}_{block}$. (a) Physical error rate ranges from $1\times {10}^{-5}$ to $1\times {10}^{-4}$. (b) Physical error rate ranges from $1\times {10}^{-4}$ to $1\times {10}^{-3}$. (c) Physical error rate ranges from $1\times {10}^{-3}$ to $1\times {10}^{-2}$.

Figure 8. The performance of table-look-up decoder under CA algorithm with different $t_{error}$. “Logical error rate” represents $LE{R}_{block}$. (a) Physical error rate ranges from $1\times {10}^{-5}$ to $1\times {10}^{-4}$. (b) Physical error rate ranges from $1\times {10}^{-4}$ to $1\times {10}^{-3}$.

Figure 9. The LER with reliable frozen qubits and table-look-up decoder. “Logical error rate” represents $LE{R}_{block}$ and “Slq Logical error rate” represents $LE{R}_{slq}$. (a) The $LE{R}_{block}$ of QPSCs constructed by CA and BS algorithms with physical error rate ranging from $1\times {10}^{-5}$ to $1\times {10}^{-4}$. (b) The $LE{R}_{slq}$ of QPSCs constructed by CA algorithms with physical error rate ranging from $1\times {10}^{-5}$ to $1\times {10}^{-4}$. (c) The $LE{R}_{slq}$ of QPSCs constructed by BS algorithms with physical error rate ranging from $1\times {10}^{-5}$ to $1\times {10}^{-4}$. (d) The $LE{R}_{block}$ of QPSCs constructed by CA and BS algorithms with physical error rate ranging from $1\times {10}^{-4}$ to $1\times {10}^{-3}$. (e) The $LE{R}_{slq}$ of QPSCs constructed by CA algorithms with physical error rate ranging from $1\times {10}^{-4}$ to $1\times {10}^{-3}$. (f) The $LE{R}_{slq}$ of QPSCs constructed by BS algorithms with physical error rate ranging from $1\times {10}^{-4}$ to $1\times {10}^{-3}$. (g) The $LE{R}_{block}$ of QPSCs constructed by CA and BS algorithms with physical error rate ranging from $1\times {10}^{-3}$ to $1\times {10}^{-2}$. (h) The $LE{R}_{slq}$ of QPSCs constructed by CA algorithms with physical error rate ranging from $1\times {10}^{-3}$ to $1\times {10}^{-2}$. (i) The $LE{R}_{slq}$ of QPSCs constructed by BS algorithms with physical error rate ranging from $1\times {10}^{-3}$ to $1\times {10}^{-2}$.

Figure 10. The LER with reliable frozen qubits and bit-flip decoder. “Logical error rate” represents $LE{R}_{block}$ and “Slq Logical error rate” represents $LE{R}_{slq}$. (a) The $LE{R}_{block}$ of QPSCs constructed by CA and BS algorithms with physical error rate ranging from $1\times {10}^{-5}$ to $1\times {10}^{-4}$. (b) The $LE{R}_{slq}$ of QPSCs constructed by CA algorithms with physical error rate ranging from $1\times {10}^{-5}$ to $1\times {10}^{-4}$. (c) The $LE{R}_{slq}$ of QPSCs constructed by BS algorithms with physical error rate ranging from $1\times {10}^{-5}$ to $1\times {10}^{-4}$. (d) The $LE{R}_{block}$ of QPSCs constructed by CA and BS algorithms with physical error rate ranging from $1\times {10}^{-4}$ to $1\times {10}^{-3}$. (e) The $LE{R}_{slq}$ of QPSCs constructed by CA algorithms with physical error rate ranging from $1\times {10}^{-4}$ to $1\times {10}^{-3}$. (f) The $LE{R}_{slq}$ of QPSCs constructed by BS algorithms with physical error rate ranging from $1\times {10}^{-4}$ to $1\times {10}^{-3}$. (g) The $LE{R}_{block}$ of QPSCs constructed by CA and BS algorithms with physical error rate ranging from $1\times {10}^{-3}$ to $1\times {10}^{-2}$. (h) The $LE{R}_{slq}$ of QPSCs constructed by CA algorithms with physical error rate ranging from $1\times {10}^{-3}$ to $1\times {10}^{-2}$. (i) The $LE{R}_{slq}$ of QPSCs constructed by BS algorithms with physical error rate ranging from $1\times {10}^{-3}$ to $1\times {10}^{-2}$.

Notice that the noise threshold we are talking about is the code-capacity threshold, which does not consider the noise in encoding and measurement. According to many other QLDPC codes such as surface code, the circuit-level noise threshold, which considers the noise in encoding and measurement, is often one–two orders lower than the code capacity threshold. This means even if the circuit-level noise threshold of QPSCs exists, it is lower than ${10}^{-6}$ in the best case. However, we believe this best case is a naïve case. Because, unlike surface code or other QLDPC codes, the stabilizer weight of QPSCs will increase with its code length, which means the encoding and measurement process will be influenced by the noise more greatly for larger code lengths. This will do harm to the circuit-level noise threshold. Hence, we believe that even if the circuit-level noise threshold of QPSCs exists, it is lower than ${10}^{-7}$ or even much lower.

In fact, no one can exhaust all possible physical qubit error rates to prove whether the noise threshold exists. Hence, analyzing the code distance is relatively more powerful to judge whether a quantum stabilizer code can work or not. In our simulation, the weight of the logical X operators can be regarded as the effective code distance, because we only consider the Pauli X noise. Figure 11 shows the effective code distance of QPSCs constructed by CA and BS algorithms. Careful readers may notice that, given the same physical qubit error rate and code length, the effective code distance of CA may not be half of that of BS, which is not consistent with what we discuss in Section 4.2. This is because in CA algorithm the method used to estimate the Bhattacharyya parameter of the quantum coordinate channels is an approximate method, resulting that some chosen quantum coordinate channels are not consistent with the most reliable ones in theory, such that the corresponding effective code distance is lower than the theoretical value. This will not influence our judgment about the error-correcting capability, because we have clarified that the code distance of QPSCs constructed by CA algorithms will not surpass that obtained by BS algorithms.

Figure 11. The effective code distance of CA and BS algorithms with different physical qubit error rates and code lengths $N=2^n$. (a) The effective code distance of QPSCs constructed by CA algorithms. (b) The effective code distance of QPSCs constructed by BS algorithms.

As shown in Figure 11, we find that both the CA and BS construction algorithms cannot guarantee the code distance increase with the code length. This means that under the same physical qubit error rate, with the code length increasing, the average number of error qubits will increase, but the number of qubits this code can correct, which is determined by the code distance, does not increase with a sufficient rate and is almost invariant in low physical qubit error rate. That is to say, increasing the code length will only impair the code’s error-correcting capability and enlarge the logical error rate.

Notice that no matter for CA or BS construction algorithms, given a certain physical error rate and a certain code length, they both try to construct codes with a coding rate as high as possible according to the channel polarization theory. Though BS takes the code distance into consideration to some extent, it still regards the high coding rate as its primal target. Therefore, the effective code distance will be influenced by the physical error rate, instead of being determined by the code length alone. For example, in Figure 11, under the code distance $N=2^7$, when the physical qubit error rate p decreases from 0.01 to 0.001, the code distance decreases from 8 to 4 for the BS algorithm. The above characteristic of the effective code distance of the QPSCs constructed by CA and BS algorithms is the direct reason why the noise threshold does not exist.

5.2. Analysis

Why do QPSCs not work for quantum computing? We think this is due to the decoding channels and coordinate channels having no one-to-one relationships.

For classical polar codes, as shown in Figure 12a, the input of the classical coordinate channel $W_N^{\left(i\right)}$ is $u_i$, and its output is $y_1^N,u_1^{i-1}$. During the decoding procedure, as shown in Figure 12b, the decoder estimates ${\widehat{u}}_i$ after observing $y_1^N$ and the past estimated channel inputs ${\widehat{u}}_1^{i-1}$. Hence, we can see that the classical polar code construction builds a one-to-one relationship between the classical coordinate channels and decoding channels. The better the quality of the coordinate channels are, the more reliable the decoding channels will be.

Figure 12. Coordinate channels and decoding channels: (a) Classical coordinate channels. The input of classical coordinate channel $W_N^{\left(i\right)}$ is $u_i$, and its output is $y_1^N,u_1^{i-1}$. (b) Classical decoding channels. The input of decoding channel $D_N^{\left(i\right)}$ is ${\widehat{u}}_1^{i-1},y_1^N$ and the output is estimated ${\widehat{u}}_i$. (c) Quantum coordinate channels. The input of quantum coordinate channel ${\mathcal{E}}_N^{\left(i\right)}$ is ${\rho }^{Q_i}$, and its output is ${\rho }^{Y_1^N,R_1^{i-1}}$. (d) Quantum decoding channel. The input of decoding channel is an error syndrome and the output is the most likely error.

For QPSCs, as shown in Figure 12c, the input of the quantum coordinate channel ${\mathcal{E}}_N^{\left(i\right)}$ is ${\rho }^{Q_i}$, and its output is ${\rho }^{Y_1^N,R_1^{i-1}}$. However, for the quantum decoding channel as shown in Figure 12d, its input is an error syndrome and its output is the most likely error. Both CA and BS construction algorithms do not build a similar one-to-one relationship between the quantum coordinate channels and the decoding channel.

6. Possible Future Direction

Based on the analysis in Section 5.2, we argue that if researchers still try to borrow the idea of classical polar codes to design quantum stabilizer codes with high coding rate, the channels waiting to be analyzed and polarized should be the channels with the actual error on physical qubits as input and error syndrome as output, which corresponds to the channels in Figure 12d. What do these channels look like? The channels between the actual error on physical qubits and error syndrome can be depicted by the Tanner graph [50] as shown in Figure 13. However, it does not seem direct to polarize the Tanner graph by borrowing the idea of classical polar codes from the perspective of channel capacity, since the number of inputs (variable nodes) and outputs (check nodes) is different and each output may connect to more than one input, which leads to the difficulty in defining the primal channel used to realize polarization and analyzing the channel capacity.

Figure 13. The Tanner graph of 3-bit-flip code.

Arikan [11] uses the concept of channel capacity to design the recursive encoding of classical polar codes. It does no harm to put the concept of channel capacity of classical polar codes aside for a moment and focus on the recursive encoding itself. By recursive encoding, one can expand the encoding circuits and obtain classical polar codes with longer code lengths and stronger error-correcting capability from two shorter classical polar codes. Hence, can we recursively expand the Tanner graph of certain stabilizer codes by the idea of recursive encoding and obtain stabilizer codes with longer code lengths and stronger error-correcting capability? We have made some attempts in pure Pauli X noise channel and propose a class of stabilizer codes with a constant coding rate of 0.5 by recursively expanding the Tanner graph, which is shown in Figure 14. The scheme also applies to pure Pauli Z and Y noise channels.

Figure 14. Quantum stabilizer codes by the recursive expansion of Tanner graph. The arrow means the corresponding qubit it starts from will join in the corresponding stabilizer it ends with. The corresponding stabilizers and logical operators are shown in Table 1: (a) The Tanner graph $G_1$ used for recursive expansion. (b) The expanded Tanner graph $G_2$ by recursive expansion of two $G_1$. (c) The expanded Tanner graph $G_3$ by recursive expansion of two $G_2$. (d) The expanded Tanner graph $G_n$ by recursive expansion of two $G_{n-1}$.

As shown in Figure 14, the recursive expansion of the Tanner graph has the same form as the recursive encoding circuits of classical polar codes (Figure 8 in ref. [11]), and the coding rate of the corresponding code is the constant 0.5. For the minimum weight of logical X operators, if $logN$ is an even number, it is $logN$, while if $logN$ is an odd number, it is $logN+1$ (notice that in pure Pauli X noise, the error-correcting capability relies on the minimum weight of logical X operators, rather than the minimum weight of all logical operators, namely, the code distance).

It is easy to prove the coding rate and the minimum weight of logical X operators. The code length $N=2^n$, and notice that when n is an odd number, each stabilizer generator contains a unique Pauli Z operator with an even subscript, while when n is an even number, each stabilizer generator contains a unique Pauli Z operator with an odd subscript. Hence, each stabilizer generator can’t be generated by other stabilizer generators, which means that when the code length is $N=2^n$, the $2^{n-1}$ stabilizer generators in Figure 14d are independent. Therefore, the number of logical operators is $2^n-2^{n-1}=2^{n-1}$, which means the coding rate is 0.5. As for the minimum weight of logical X operators and stabilizer generators, one can easily prove this by mathematical induction from the code length $N=4$ to $N=2^n$.

To test the error-correcting capability of the codes, simulations with the table-look-up decoder are performed, whose results are shown in Figure 15. Figure 15 shows that the logical error rate will decrease with the increase in code length within the physical qubit error rate from 0.001 to 0.01. In the simulations, $t_{error}$ is set to 5. However, due to the complexity of the table-look-up decoder, we did not find the noise threshold of these codes. To find the noise threshold, simulations need to be performed at a larger physical qubit error rate. With the increase in physical qubit error rate, the average number of error qubits will increase. According to the results in Figure 16, for this class of codes, when $t_{error}$ is less than ten times the average number of error qubits, the decoding accuracy is sensitive to $t_{error}$. Hence, to perform simulations under a larger physical qubit error rate, $t_{error}$ needs to take a larger value, which leads to the required memory becoming intractable.

Figure 15. The LER with table-look-up decoder.

Figure 16. The decoding accuracy under different $t_{error}$.

The above attempts are made for Pauli X. It is obvious that it also applies to Pauli Y errors. And simply replacing Pauli Z in the stabilizers by Pauli X or Y can provide us code that apply to Pauli Z and Y errors or Pauli X and Z errors. Whether it can be generalized to correct all three Pauli errors is still unknown. To make this generalization, maybe one should modify the primal Tanner graph and the recursive expansion approach. However, even without this generalization, we can still obtain codes that apply to depolarizing channels by concatenating two codes—one corrects the Pauli X and Y errors, and the other corrects Pauli Z and Y errors.

7. Conclusions

In this paper, we follow the intuition that one can design a quantum polar coding scheme for quantum computing based on the polarization phenomenon of quantum channels that arises from directly converting the classical polar coding circuits into quantum ones, and we propose two possible and more reasonable construction algorithms—the CA and BS algorithms—to construct QSPCs. The CA construction is equivalent to the construction in ref. [33]. In the range of p from $1\times {10}^{-5}$ to $1\times {10}^{-2}$, under both unreliable and reliable frozen qubits assumptions, no evidence shows that the LER of a single logical qubit $LE{R}_{slq}$ of both CA and BS can be decreased by increasing the code length and we cannot find the noise threshold. Therefore, we come to the conclusion that the above intuition is too naive to guide us to design a quantum polar coding scheme for quantum computing. We also provide a possible future direction for designing quantum stabilizer codes with high coding rates by borrowing the idea of classical polar codes. Following this direction, we find a class of quantum stabilizer codes with a constant coding rate of 0.5, which can correct two kinds of Pauli errors.