Quantum Coding via Quasi-Cyclic Block Matrix

Abstract

An effective construction method for long-length quantum code has important applications in the field based on large-scale data. With the rapid development of quantum computing, how to construct this class of quantum coding has become one of the key research fields in quantum information theory. Motivated by the block jacket matrix and its circulant permutation, we proposed a construction method for quantum quasi-cyclic (QC) codes with two classical codes. This simplifies the coding process for long-length quantum error-correction code (QECC) using number decomposition. The obtained code length N can achieve $O\left(n^2\right)$ if an appropriate prime number n is taken. Furthermore, with a suitable parameter in the construction method, the obtained codes have four cycles in their generator matrices and show good performance for low density codes.

1. Introduction

Quantum communication requires that environmental effects and decoherence should be reduced with reliable quantum information processing. In practice, information reconciliation in quantum key distribution (QKD) is important for the secret key rate and also affects the maximum transmission distance [1,2,3,4]. Error-correcting code generally may be applied in a quantum channel to correct errors caused by channel noise and possible interventions from eavesdroppers. To obtain an acceptable level, QECC is an essential method because of its robustness and efficiency in quantum computation [5,6,7,8,9,10]. One of the advantages of quantum computation is that its high efficiency compares favorably to classical computation; it is able to handle large-scale data that classical computation cannot. Previously, most of the construction methods for QECC focused on the generation of stabilizers, and there was little research on the long code type. Furthermore, due to some fields in quantum information becoming gradually more practical, this has prompted researchers to identify a good coding method for quantum error-correcting codes of long length. For example, encoding large-scale data has potential applications in the field of machine learning (ML) with respect to big data [11,12,13,14]. Therefore, how to efficiently express classical massive data with physics-based codes is also an important research field. To obtain a general quantum code, the question is usually converted to a problem of stabilizer generation. One typical method is to obtain the generation matrix of a quantum code based on two classical codes, which are called Calderbank–Shor–Steane (CSS) codes [6,7]. By resorting to the generalization of cyclic codes, a class of classical codes called quasi-cyclic (QC) codes can build linear codes based on algebraic structure, which has improved some fundamental minimum distances [15,16,17,18]. For instance, it can satisfy the modified version of the Gilbert–Vashamov (GV) bound [19,20,21]. It has shown good performance when applied to form quantum codes.

In the construction process for long-sequence QECCs, how to design the generators of stabilizers based on the block matrix is key. Methods from QC low density parity check (LDPC) codes have been studied by Hagiwara et al. in terms of a probabilistic method [22,23]. In 2018, Galindo et al. applied two generators to construct a quantum version with dual-containing QC [24]. Some QC short-length codes were obtained with good parameters. Not long after that, Ezerman et al., in 2019, used QC codes with large Hermitian hulls to form QECCs over fields $F_4$ and $F_9$ [25], so that a record-breaking binary QECC was obtained. Furthermore, J. Lv et al. proposed some new binary quantum codes derived from one generator quasi-cyclic codes with a stabilizer [26,27]. Recently, some researchers have considered the application of this kind of quantum code in quantum key distribution [4]. However, few researchers have paid attention to the construction of long-length quantum QC code involved with massive data. Inspired by the previous work, we presented QC code constructions of long length to generate QECCs with a family of orthogonal jacket matrices, the main property of which are that the inverse matrix can be obtained by its element-wise inverse or block-wise inverse [28,29]. Therefore, it can be realized relatively easily with a physical circuit. Furthermore, since Gallager first proposed LDPC codes in the 1960s [30], this class of classical code has shown good performance approaching the channel capacity [31,32,33,34,35]. Subsequently, its quantum versions has been investigated [22,23]. However, the achievements in this field have been explored far less than their classical counterparts. The constructed quantum codes have shown good performance for low density codes based on iterative coding in our proposed construction method.

In this paper, with the advantage of the convenient implementation of the jacket transform, we applied a quasi-cyclic method via a low-density block matrix to gain long-length quantum codes. If a prime number in the proposed construction method is taken to properly choose the jacket matrix with a basic matrix and block circular matrix combined together, then a longer length of matrix to encode classical data can be obtained.

This paper is arranged as follows: In Section 2, we present some preliminary information which is necessary for QECCs. Then, in Section 3 and Section 4, we investigate the construction of long-length quasi-cyclic quantum codes which are generated from block jacket matrices based on a basic matrix and circulant permutation matrices. Furthermore, the construction conditions with low density are also analyzed. Finally, conclusions are drawn in Section 5.

2. Preliminaries

Some relevant notation and basic construction methods for quantum error correction codes are first briefly reviewed below.

2.1. General Construction Methods of QECCs

A linear binary quantum error-correcting code $\left[\right[N,k,d\left]\right]$ denotes that k-data vectors are encoded to N-dimensional vectors in space ${\mathcal{P}}_N$, where d is the minimum distance. Consider a $2^N$-dimensional Hilbert space based on a complex field $\mathbb{C}$

$${\mathcal{P}}_N={\mathbb{C}}^{2^N}={\left({\mathbb{C}}^2\right)}^{\otimes N},$$

(1)

where every $2^N$ standard basis vector in space ${\mathcal{P}}_N$ is indexed by a classical binary vector $u\in F_2^N$ and denoted by $|u\rangle$. It is generally called a N-qubit state space, for which each component in the tensor product corresponds to one qubit. Similar to classical coding, a fundamental problem in quantum error correction is to generate quantum codes based on the best possible minimum distance. The general construction method for QECCs usually relies on a so-called stabilizer. A stabilizer quantum code $\mathcal{C}\left[\right[N,k,d\left]\right]$ can be gained from the stabilizer denoted as

$$S=\prod _{i-1}^{N-k}(I+M_i^{m_i}):m_i\in \{0,1\},$$

(2)

where $M_1,M_2\cdots M_{N-k}$ are $N-k$ commuting generators of the stabilizer, which is the collection of orthogonal quantum state eigenvectors that refer to code words. Therefore, to form a stabilizer quantum code, $N-k$ generators of stabilizer S should first be designed, which are expressed by the following generator matrix

$$\begin{array}{cc}\hfill \mathcal{G}=({\mathcal{G}}^x& {\mathcal{G}}^z{)}_{(N-k)\times 2N}={\left(M_1,M_2,\dots ,M_{N-k}\right)}^T,\end{array}$$

(3)

where ${\mathcal{G}}^x={\left(g_{ij}^x\right)}_{(N-k)\times N},{\mathcal{G}}^z={\left(g_{ij}^z\right)}_{(N-k)\times N}$ for $1\le i\le N-k,1\le j\le N$, and $x,z$ are the Pauli transformation. According to the property of commuting generators, the elements of its row vector satisfy that the symplectic inner product is equal to zero.

Another well known construction method for quantum codes is the CSS code which is generated by a pair of classical codes $C_1[n,k_1,d_1]$ and $C_2[n,k_2,d_2]$, where $k_i$ and $d_i$ are the information code length and minimum distance, respectively. This means that this class of quantum error code is a complex vector space characterized by a pair of classical binary linear codes $C_1$ and $C_2$. Here, the parity-check matrices $H_1$ and $H_2$ of the two classical codes are required to satisfy $H_1·H_2^T=0$, i.e., every row of $H_1$ is orthogonal to every row of $H_2$. Hence, define a CSS code as a complex linear combination of vectors:

$$\sum _{d^{\prime }\in C_2^{\perp }}|c+d^{\prime }\rangle \mathrm{for}c\in C$$

(4)

where $C_2^{\perp }$ is the dual code of the classical code $C_2$. According to its definition, the obtained quantum CSS code $\mathcal{C}\left[[N,k_1+k_2-N,min\{d_1,d_2\}]\right]$ is a class of special stabilizer code, of which the generator matrix is

$$\begin{array}{c}\hfill {\mathcal{G}}_c=\left(\begin{array}{cc}{H}_1& O\\ O& H_2\end{array}\right).\end{array}$$

(5)

In light of the characteristics of big data processed in artificial intelligence and other fields, we shall apply the recursive relationship of a quasi-cyclic block jacket matrix to easily obtain long-length QECCs.

2.2. Error of Quantum Error-Correction Code and Bound

As with different quantum codes, errors are also labeled with strings in field $F_2$. This will occur when the states are transmitted through quantum channels. The traditional approach to error correction for quantum codes is to consider the single qubit flip error, the phase error or the phase-flip error, which can be described with three Pauli operators ${\sigma }_1$, ${\sigma }_2$ and ${\sigma }_3=\omega {\sigma }_1{\sigma }_2$, respectively. Here, $\omega$ is the primitive root of unity. Every error on N qubits can be denoted as $e={\sigma }_1^X{\sigma }_2^Z$, for $X=(x_1,x_2,\dots ,x_n)$ and $Z=(z_1,z_2,\dots ,z_n)\in F_2^N$. Reflexive stabilizer codes and CSS codes have a one-to-one correspondence by choosing a basis for the error group. In terms of the Pauli matrices, the single qubit quantum error can be described as $X\left(a\right)$ and $Z\left(a\right)$ for $a\in F_2$, whose action on $|x\rangle \in C$ is given by

$$X\left(a\right)|x\rangle =|x+a\rangle \mathrm{and}Z\left(a\right)|x\rangle ={\omega }^{ax}|x\rangle$$

(6)

Therefore, it acts on an N-qubit basis state $|Q\rangle =(q_1,q_2,\dots ,q_N)$ in $F_2^N$ as follows

$$\begin{array}{cc}\hfill e|Q\rangle & ={(-1)}^{Z·Q}|X+Q\rangle \hfill \\ & ={(-1)}^{z_1·q_1+\dots +z_N·q_N}|x_1+q_1,\dots ,x_N+q_N\rangle .\hfill \end{array}$$

(7)

Furthermore, the quantum Hamming bound of a general quantum code $\mathcal{C}\left[\right[N,k,d\left]\right]$ is required to satisfy the following inequality condition [36]

$$\begin{array}{c}\hfill \sum _{l=0}^t{3}^l\left(\genfrac{}{}{0pt}{}{N}{l}\right)\le 2^{N-k},\end{array}$$

(8)

which may correct up to $t=\left[\right(d-1)/2]$ quantum error bits.

3. Long-Length Coding Constructions Based on Jacket Matrix

Quasi-cyclic codes are the generalization of cyclic codes, which can generate a class of linear codes of algebraic structure. Assume C is a classical code of length N over field $F_2$, which is closed with a cyclic-shift operator $\gamma$. This means that any codeword $\overrightarrow{C}=(c_0,c_1,\dots ,c_{N-1})\in C$ satisfies $\gamma \overrightarrow{C}=\gamma (c_0,c_1,\dots ,c_{N-1})=(c_{N-1},c_0,\dots ,c_{N-2})\in C$. The circuit of the cyclic shift can be represented as in Figure 1. In this circuit, $\overrightarrow{C}$ as an input code vector can generate an output code vector with some integer s times of $\gamma$ operation, $1\le s\le N-1$.

More generally, if there is a smallest positive integer ℓ such that

$$\begin{array}{c}\hfill {\gamma }^{\ell }\left(c\right)=(c_{N-\ell },c_{N-\ell +1},\dots ,c_{N-1},c_0,\dots ,c_{N-\ell -1}),\end{array}$$

(9)

also belongs to C, the linear code C is called a quasi-cyclic code of index ℓ. Furthermore, given $C^{\perp }=\{\overrightarrow{v}\in F_2^N|\langle \overrightarrow{u},\overrightarrow{v}\rangle =0,\forall \overrightarrow{u}\in C\}$ is called its dual code. If $C\subseteq C^{\perp }$, the code C is self-orthogonal. In quantum theory, if any quantum code word $|c\rangle \in {\mathcal{P}}_N$ is still a quantum code state in this space after several cyclic shifts, the quantum codes will be correspondingly called quasi-cyclic quantum codes.

In mathematical theory, a cyclic code is an ideal in the quotient ring R; hence, it can be gained by a single polynomial. Here, the quotient ring is defined as $R=F_2\left[x\right]/\langle x^n-1\rangle$ for a prime number n. It is an isomorphic $\gamma :F_2^n\to R$ between the ring formed by all $n\times n$ circulant matrices and the ring R formed by the polynomial $x^n-1$. As a consequence, the circulant matrix corresponds to the following polynomial

$$\begin{array}{c}\hfill a=a_0+a_{1}x+\dots +a_{n-1}{x}^{n-1}.\end{array}$$

(10)

Under the isomorphism $\gamma$, it has $\gamma \overrightarrow{a}=a_{n-1}+a_{0}x+\dots +a_{n-2}{x}^{n-1}$, for $\overrightarrow{a}=(a_0,a_1,\dots ,a_{n-1})$$\in F_2^n$. If we define $K^n=I$, such as

$$\begin{array}{c}\hfill K=\left(\begin{array}{cccc}0& 0& \dots & 1\\ 1& 0& \dots & 0\\ 0& 1& \dots & 0\\ ⋮& ⋮& \ddots & ⋮\\ 0& 0& \dots & 0\end{array}\right)\end{array}$$

(11)

is a $n\times n$ matrix representing the right cyclic shift by one position, it is readily seen that a circulant matrix A over $F_2$ can be represented in the form

$$\begin{array}{c}\hfill A=a_{0}I+a_{1}K+\dots +a_{n-1}{K}^{n-1},\end{array}$$

(12)

where I is the $n\times n$ identity matrix. More generally, the $n\times n$ matrix $K=\left(k_{ij}\right)$ may be taken as

$$k_{ij}=\{\begin{array}{cc}\hfill 1\hfill & \mathrm{if}i=(j+h)\mathrm{mod}n\hfill \\ \hfill 0\hfill & \mathrm{otherwise},\hfill \end{array}$$

(13)

where, h is an integer for $1\le h\le n-1$. It is obvious that the matrix K can form an Abelian operator group $\mathcal{K}=\{I=K^0,K^1,\dots ,K^{n-1}\}$. The index i of $K^i\in \mathcal{K}$ is an exponent of matrix K, which is called a basic matrix. More generally, the matrix $G_e$ formed by the index of the basic matrix is defined as an exponent matrix. On the basis of the two matrices, we also introduce a circulant permutation matrix Q obtained by an operation “∧” between the matrices K and $G_e$ as

$$\begin{array}{cc}\hfill Q& ={\left(K^{a_{ij}}\right)}_{mn\times nn}=K\wedge G_e\hfill \\ & =\left(\begin{array}{cccc}{K}^{a_{11}}& K^{a_{12}}& \dots & K^{a_{1n}}\\ K^{a_{21}}& K^{a_{22}}& \dots & K^{a_{2n}}\\ ⋮& ⋮& \ddots & ⋮\\ K^{a_{m1}}& K^{a_{m2}}& \dots & K^{a_{mn}}\end{array}\right),\hfill \end{array}$$

(14)

where $a_{ij},1\le i\le m,1\le j\le n$, is the exponent of the basic matrix K, and

$$\begin{array}{c}\hfill G_e={\left(a_{ij}\right)}_{m\times n}=\left(\begin{array}{cccc}{a}_{11}& a_{12}& \dots & a_{1n}\\ a_{21}& a_{22}& \dots & a_{2n}\\ ⋮& ⋮& \ddots & ⋮\\ a_{m1}& a_{m2}& \dots & a_{mn}\end{array}\right).\end{array}$$

(15)

It is easily seen that Q is essentially an array of cyclic-shift operators.

On the other hand, a class of matrix $J_{n\times n}={\left(a_{ij}\right)}_{n\times n}$ is called a jacket matrix, which could lead to a simple encoding algorithm [28,29], if it satisfies

$$a_{ij}^{-1}=\{\begin{array}{cc}\hfill \left(a_{ij}\right)/a\hfill & \mathrm{if}{a}_{ij}\ne 0,\hfill \\ \hfill 0\hfill & a_{ij}=0,\hfill \end{array}$$

(16)

i.e., $J_{n\times n}^{-1}={\left(a_{ij}^{-1}\right)}^T/a$, where a is the normalized constant. It is obvious that Pauli matrices and the Hadamard matrix belong to a jacket matrix.

In addition, we also define an operation ‘$\widehat{\otimes }$’ between the Jacket matrix J and the cyclic-shift operator vector $\overrightarrow{K}=(I,K,\dots ,K^{n-1})$ as

$$\begin{array}{c}\hfill J\widehat{\otimes }\overrightarrow{K}=J\widehat{\otimes }(I,K,\dots ,K^{n-1})=(J,JK,\dots ,J{K}^{n-1}).\end{array}$$

(17)

Then, on the basis of the jacket matrix J and the circulant permutation matrix Q, we design a matrix G with length $N=n(n-1)$ constructed by the following circuit

$$\begin{array}{cc}\hfill G& =J\widehat{\otimes }(K\wedge G_e)=J\widehat{\otimes }Q\hfill \\ & =J\widehat{\otimes }\left(\begin{array}{cccc}{K}^{a_{11}}& K^{a_{12}}& \dots & K^{a_{1n}}\\ K^{a_{21}}& K^{a_{22}}& \dots & K^{a_{2n}}\\ ⋮& ⋮& \ddots & ⋮\\ K^{a_{m1}}& K^{a_{m2}}& \dots & K^{a_{mn}}\end{array}\right)\hfill \\ & =\left(\begin{array}{cccc}J{K}^{a_{11}}& J{K}^{a_{12}}& \dots & J{K}^{a_{1n}}\\ J{K}^{a_{21}}& J{K}^{a_{22}}& \dots & J{K}^{a_{2n}}\\ ⋮& ⋮& \ddots & ⋮\\ J{K}^{a_{m1}}& J{K}^{a_{m2}}& \dots & J{K}^{a_{mn}}\end{array}\right),\hfill \end{array}$$

(18)

where, $G_e={\left(a_{ij}\right)}_{mn}$ is the exponent matrix of the basic matrix K in Equation (13).

4. Long-Length Quantum Coding via Quasi-Cyclic Jacket Matrix

Based on the above mathematical definitions, we mainly consider how to obtain the exponent matrix $G_e$ and the jacket matrix J as follows.

4.1. The Construction Method of Jacket Matrix

Firstly, the construction manner of the low-parity jacket matrix J in Equation (18) is investigated. According to their definition, it is obvious that the Hadamard matrix and the Pauli matrices are special jacket matrices. Consider the 2-order Hadamard matrix

$$H_2=\left(\begin{array}{cc}1& 1\\ 1& -1\end{array}\right),$$

(19)

as the smallest basic matrix. A binary $n_1$-size Hadamard matrix $H={\left(h_{ij}\right)}_{n_1\times n_1}$ for $n_1=2^m,m\ge 3$, under mapping: $1\to 1,-1\to 0$, may be obtained with the following recursive relation

$$\begin{array}{c}\hfill H_{n_1}=H_{n_1/2}\otimes H_2.\end{array}$$

(20)

Generally, on the basis of the tensor product, the $n_1=2^m$-order jacket matrix can be shown as

$$\begin{array}{c}\hfill J_{n_1}=\prod _{i=1}^m{I}_{2^{m-i}}\otimes J_2\otimes I_{2^{i-1}},\end{array}$$

(21)

where $J_2$ may also be chosen as Pauli matrices except for the Hadamard matrix,

$$\begin{array}{c}\hfill {\sigma }_0=\left(\begin{array}{cc}1& 0\\ 0& 1\end{array}\right)or{\sigma }_1=\left(\begin{array}{cc}0& 1\\ 1& 0\end{array}\right).\end{array}$$

(22)

Correspondingly, one obtains

$$\begin{array}{c}\hfill J_{n_1}{J}_{n_1}^T=(\prod _{i=3}^m{I}_{2^{m-i}}\otimes \left(J_2{J}_2^T\right)\otimes I_{2^{i-1}})\otimes \left(J_{2^3}^T{J}_{2^3}\right).\end{array}$$

(23)

Similarly, we also consider a jacket matrix with size $n_2=3^m$ based on the fundamental matrix $J_3$ as follows: Denoting a $1\times 1$ Jacket matrix as $J_1=1$, the direct sum $J_3$ may be written as

$$J_3=J_1\oplus J_2=\left(\begin{array}{cc}1& 0\\ 0& J_2\end{array}\right).$$

(24)

It is easy to check that

$$\begin{array}{ccc}\hfill J_3{J}_3^{-1}& =& \left(\begin{array}{cc}1& O\\ O& J_2\end{array}\right)\left(\begin{array}{cc}1& O\\ O^T& J_2^{-1}\end{array}\right)=I_3,\hfill \end{array}$$

(25)

Then, one may obtain

$$\begin{array}{c}\hfill J_{n_2}=J_{n_2/3}\otimes J_3,\end{array}$$

(26)

for $n_2=3^m,m\in \{1,2,\cdots \}$.

In terms of number theory, any finite prime number n may be decomposed into a Kronecker product and the direct sum of 2 and 3 resort to the following form

$$\begin{array}{c}\hfill n=2^{n_1^{\prime }}+2^{n_2^{\prime }}+\cdots +2^{n_r^{\prime }}+3^{m_1^{\prime }}+\cdots +3^{m_s^{\prime }},\end{array}$$

(27)

where $n_{\mu }^{\prime }$, $m_{\nu }^{\prime }$ are integers for $1\le \mu \le r,1\le \nu \le s$. Therefore, to obtain any prime size of quantum code, we first construct generator matrices with size $2^m$ and $3^m$. In view of the recursive relation, the jacket matrix $J_n$ of large-scale order and its transpose matrix $J_n^T$ satisfy

$$J_n{J}_n^T=\left(J_2^{\otimes n_1^{\prime }}{J}_2^{\otimes n_1^{\prime }T}\right)\oplus \cdots \left(J_2^{\otimes n_r^{\prime }}{J}_2^{\otimes n_1^{\prime }T}\right)\oplus \left(J_3^{\otimes m_1^{\prime }}{J}_3^{\otimes m_1^{\prime }T}\right)\oplus \cdots \left(J_3^{\otimes m_s^{\prime }}{J}_3^{\otimes m_s^{\prime }T}\right).$$

(28)

It is obvious that the weight of the gained jacket matrix $J_{n_2}$ is equal to 1 when it involves $J_2$ as one of the Pauli matrices. For clarity, some decomposition methods of the jacket matrix are presented based on 2-order and 3-order fundamental jacket matrices $J_2$ (Pauli matrices or the Hadamard matrix) and $J_3$ in

Table 1. The construction of jacket matrices.

Jacket Matrix	Decompositions of Prime Number
$J_5$	$J_2\oplus J_3$
$J_7$	$J_2^{\otimes 2}\oplus J_3$
$J_{29}$	$J_3^{\otimes 3}\oplus J_2$ = $J_2^{\otimes 4}\oplus J_{13}$
$J_{31}$	$J_3^{\otimes 3}\oplus J_2^{\otimes 2}$ = $J_2^{\otimes 3}\oplus J_{23}$
$J_{37}$	$J_2^{\otimes 5}\oplus J_5$ = $J_2^{\otimes 4}\oplus J_3\otimes J_7$

.

As can be seen from the above table, any large-scale jacket matrix of prime order can be decomposed by these two kinds of matrices.

Example 1. 

Take parameter $n=59$ that is decomposed with a Kronecker product and the direct sum of the fundamental Jacket matrices, then the concatenated matrix may be expressed as different methods

$$\begin{array}{cc}\hfill J_{59}& =J_2^{\otimes 5}\oplus J_3^{\otimes 3}=J_{32}\oplus J_{27}=\left(\begin{array}{cc}{J}_{32}& O\\ O& J_{27}\end{array}\right)\hfill \\ & =J_7^{\otimes 2}\oplus J_{10}=J_{49}\oplus J_{10}=\left(\begin{array}{cc}{J}_{49}& O\\ O& J_{10}\end{array}\right)\hfill \end{array}$$

(29)

Therefore, the same jacket matrix may be described with different forms in the light of its decomposition methods. Apparently, both a jacket matrix J and a $K^i$ matrix have row weight 1 with any positive integer $1\le i\le l$, so that the row weight of G is exactly $n-1$, for a given prime $n>2$, where the block length of the constructed code is $N=n(n-1)$.

4.2. The Construction Method of the Exponent Matrix

Next, based on the obtained basic matrix K, to generate the stabilizer with two circulant permutation matrices, we consider further the construction algorithm of the exponent matrix $G_e$ in Equation (18) as follows:

Assume an Abelian group $Z_n=\{0,1,\dots ,n-1\}$ for a prime number $n>2$, and its subset $Z_n^{*}$ obtained by non-zero elements, i.e., $Z_n^{*}=Z_n/\left\{0\right\}$. As n is a prime number, the size of $Z_n^{*}$ is even. Hence, the set $Z_n^{*}$ can be divided on average into two subsets

$Z_{l_1}^{*}=\{2k+1,0\le k\le l-1\}$ and $Z_{l_2}^{*}=\{2k,1\le k\le l\}$ of no common element. As can be seen from the group, it is clear that any $a\in Z_{l_1}^{*},b\in Z_{l_2}^{*},a\ne b$ and the orders of both the subsets are half of $n-1$, i.e., $|Z_{l_1}^{*}|=|Z_{l_2}^{*}|=(n-1)/2=l$. Denote all the elements in $Z_{n_i}^{*}$ to be arranged as the first row vector ${\overrightarrow{e}}_{ij}$ of an obtained matrix $E_i$, where $i=1,2$ is the ith subset and $j=1,2,\dots ,\mathrm{and}l$ is the jth permutation, so the number of the maximum sort order is l.

To the first vector ${\overrightarrow{e}}_{11}=(e_{11},e_{12},\dots ,e_{1l})$, we take the described anticlockwise (or clockwise) cyclic shift K in (13), i.e., ${\overrightarrow{e}}_{11}K=(e_{1l},e_{11},\dots ,e_{1,l-1})$. After $l-1$ times of operation K to vector ${\overrightarrow{e}}_{11}$, l vectors may be generated as the matrix $E_1$. With a similar rule, we take the sequential arrangement ${\overrightarrow{e}}_{21}=(e_{21},e_{22},\dots ,e_{2l})$ as the first vector of another matrix $E_2$. It is required that ${\overrightarrow{e}}_{21}$ is a different sequence from ${\overrightarrow{e}}_{11}$. Subsequently, the elements in the two subsets can be constructed as two exponent block matrices $E_1$ and $E_2$. The exponent matrix is generated by combining them. Namely, define an operator ‘⊙’ for combining the two sub-matrices as

$$\begin{array}{c}\hfill G_e=E_1\odot E_2=\left(E_1\right|E_2)=\left(\begin{array}{cc}{\overrightarrow{e}}_{11}& {\overrightarrow{e}}_{21}\\ {\overrightarrow{e}}_{12}& {\overrightarrow{e}}_{22}\\ ⋮& ⋮\\ {\overrightarrow{e}}_{1l}& {\overrightarrow{e}}_{2l}\end{array}\right).\end{array}$$

(30)

Here, $E_i$ is an exponent sub-matrix for obtaining the exponent matrix $G_e$, and ${\overrightarrow{e}}_i$ is the row vector of the exponent sub-matrix $E_i$, $i=1,2$. On the basis of the same rule, two exponent matrices $G_{e_1}$ and $G_{e_2}$ may be gained from the elements in $Z_{l_1}^{*}$ and $Z_{l_2}^{*}$, respectively. After constructing the exponent matrix $G_e$ and the basic matrix K, the circulant permutation Q may be obtained. By combining it with the n-order jacket matrix, the $nl\times n(n-1)$ generator matrix G is finally obtained.

Furthermore, if a greater code rate is required, we also apply the described method again to add the rows. This purpose will be achieved to make the first vector begin with a different cyclic-shifting permutation vector with opposite direction, i.e., clockwise (or anticlockwise). As a result, it will obtain a $n(n-1)\times n(n-1)$ generator matrix G as

$$\begin{array}{c}\hfill G_e=\left(\begin{array}{cc}{E}_1& E_2\\ E_1^{\prime }& E_2^{\prime }\end{array}\right),\end{array}$$

(31)

where $E_1^{\prime }$ and $E_2^{\prime }$ are newly obtained matrices with the similar method. It is obvious that the row weight of the obtained matrix is equal to $n-1$. In fact, if we wish to further reduce the weight of the row matrix, a zero block matrix can be used during the design process. If we denote “${\tau }_0$” as the exponent of the $n\times n$ zero matrix, just taking “${\tau }_0$” instead of $1\le t\le l-1$ elements in $Z_{l_1}^{*}$ and $Z_{l_2}^{*}$, the row weight will reduce $2t$ in the obtained matrix.

The whole physical circuit of the construction process can be described as in Figure 2. In the process, a prime number n will be divided into two branches. According to the designed approach, two matrices $G_{e_1}$ and $G_{e_2}$ that generated similarly to $G_e$ will be obtained by operating a cycle-shift operation $\gamma$ on two groups of vectors ${\overrightarrow{e}}_{a_i}$ and ${\overrightarrow{e}}_{b_j}$ ($i,j=1,2$). Finally, we take the obtained matrix $G_i$ (similar matrix G in Equation (18)) as the parity-check matrix $H_i$ of a classical QC code by resort to the algorithm.

However, two conditions of coding construction should be satisfied for the generated matrix G. On the one hand, any two rows in G should be orthogonal, i.e., it is self-orthogonal. In fact, according to the proposed construction algorithm, take a cyclic-shift operator $\sigma$ in the no-unit operator group $\mathcal{K}/\left\{I\right\}$, where the group $\mathcal{K}$ is formed by K introduced before. Without losing generality, denote ${\overrightarrow{v}}_{\sigma }=({\sigma }^{i_1},{\sigma }^{i_2},\dots ,{\sigma }^{i_l})$ and ${\overrightarrow{v^{\prime }}}_{\sigma }=({\sigma }^{i_1^{\prime }},{\sigma }^{i_2^{\prime }},\dots ,{\sigma }^{i_l^{\prime }})$ two row operator vectors in the circulant permutation matrix Q, $1\le i,i^{\prime }\le l=(n-1)/2$. Namely, exponent vectors ${\overrightarrow{e}}_i=(i_1,i_2,\dots ,i_l)$ and ${\overrightarrow{e^{\prime }}}_i=(i_1^{\prime },i_2^{\prime },\dots ,i_l^{\prime })$ are both in the same matrix $E_1$ or $E_2$. It is obvious that, if any binary row vector $\overrightarrow{c}$ in the jacket matrix J is both operated by ${\overrightarrow{v}}_{\sigma }$ and ${\overrightarrow{v^{\prime }}}_{\sigma }$ with operation $\widehat{\otimes }$, their inner product is equal to 0 or 1, i.e., $(\overrightarrow{c}\widehat{\otimes }{\overrightarrow{v}}_{\sigma })·{(\overrightarrow{c}\widehat{\otimes }{\overrightarrow{v^{\prime }}}_{\sigma })}^T=0$ or 1. Therefore, if any two row vectors $\overrightarrow{x}$ and $\overrightarrow{y}$ in matrix J are operated by the concatenated vector $\overrightarrow{v}=({\overrightarrow{v}}_{\sigma }|{\overrightarrow{v^{\prime }}}_{\sigma })$ with size $2l$ and another vector $\gamma \overrightarrow{v}$, their inner product will always be 0 for mode 2 with one-to-one mapping, i.e., $(\overrightarrow{x}\widehat{\otimes }\overrightarrow{v})·{(\overrightarrow{x}\widehat{\otimes }\gamma \overrightarrow{v})}^T=0$; here, $\gamma$ is a cyclic-shift operator. This means that G is a self-orthogonal matrix.

On the other hand, it should also be proved that any codewords $c_1$ from $C_2^{\perp }$ are orthogonal to all codewords $c_2$ from $C_1^{\perp }$, i.e., $G_1·G_2^{\perp }=\mathbf{0}$. In fact, for the basic matrix K, assume its cyclic-shift time of operating $\gamma$ on it in $Z_{l_1}^{*}$ and $Z_{l_2}^{*}$, respectively. According to the described algorithm, the cyclic-shift steps in the two sets are both 2, i.e., with the same operation ${\gamma }^2$. Therefore, any two matrices $K_1$ and $K_2$ of which exponents from $Z_{l_1}^{*}$ and $Z_{l_2}^{*}$, can be described as forms like Equation (12), i.e.,

$$\begin{array}{c}\hfill K_1=a_{1}K+a_3{K}^3+\dots +a_{n-1}{K}^{n-1},\\ \hfill K_2=a_2{K}^2+a_4{K}^4+\dots +a_n{K}^n.\end{array}$$

(32)

It is obvious that $K_1$ and $K_2$ are linearly independent, i.e., the two generated Abelian spaces are orthogonal.

As a result, if we take $G_{e_1}$ and $G_{e_2}$ as the exponent matrices constructed by Equation (18), we can obtain two N-length matrices $G_1$ and $G_2$. Then, the $N-k_i$ rows of the two matrices are randomly chosen as the parity-check matrix $H_i$ of classical code $C_i[N,k_i,d_i]$, $(i=1,2)$, so a generator matrix ${\mathcal{G}}_c$ of a QC quantum code $\mathcal{C}\left[[N,k_1+k_2-N,min\{d_1,d_2\}]\right]$ of the form of Equation (5) is obtained.

Example 2. 

Let prime number $n=11,Z_1^{*}=\{1,2,\cdots ,10\},$ so $l=(n-1)/2=5$, and sets $Z_{l_1}^{*}=\{1,3,5,7,9\}$, $Z_{l_2}^{*}=\{2,4,6,8,10\}$. Take ${\overrightarrow{e}}_{11}=(1,3,5,7,9)$ and ${\overrightarrow{e}}_{21}=(3,5,7,9,1)$ as the first vectors to construct the sub-matrices $E_{A1}$ and $E_{A2}$, respectively, so that $G_{e1}$ is obtained by combining the two sub-matrices. Similarly, also take ${\overrightarrow{e}}_{22}=(2,4,6,8,10)$ and ${\overrightarrow{e}}_{22}=(4,6,8,10,2)$ as the first vectors, then $G_{e2}$ will be constructed by coupling $E_{B1}$ and $E_{B2}$. Correspondingly, in terms of the basic matrix K with parameter $h=1$ in Equation (13), the exponent matrices $G_{e_1}$ and $G_{e_2}$ may be generated as

$$\begin{array}{cc}\hfill G_{e_1}& =\left(E_{A1}\odot E_{A2}\right)=\left(E_{A1}\right|E_{A2})\hfill \\ & =\left(\begin{array}{cccccccccc}1& 3& 5& 7& 9& 3& 5& 7& 9& 1\\ 9& 1& 3& 5& 7& 1& 3& 5& 7& 9\\ 7& 9& 1& 3& 5& 9& 1& 3& 5& 7\\ 5& 7& 9& 1& 3& 7& 9& 1& 3& 5\\ 3& 5& 7& 9& 1& 5& 7& 9& 1& 3\end{array}\right).\hfill \end{array}$$

(33)

Similarly, by making use of a similar method, matrix $G_{e_2}$ may be obtained as follows:

$$\begin{array}{cc}\hfill G_{e_2}& =E_{B1}\odot E_{B2}=\left(E_{B1}\right|E_{B2})\hfill \\ & =\left(\begin{array}{cccccccccc}2& 4& 6& 8& 10& 4& 6& 8& 10& 2\\ 10& 2& 4& 6& 8& 2& 4& 6& 8& 10\\ 8& 10& 2& 4& 6& 10& 2& 4& 6& 8\\ 6& 8& 10& 2& 4& 8& 10& 2& 4& 6\\ 4& 6& 8& 10& 2& 6& 8& 10& 2& 4\end{array}\right).\hfill \end{array}$$

(34)

We also take the 11 by 11 basic-matrix $J_{11}=J_6\oplus J_5$. Then, the matrices $G_1$ and $G_2$ with size $55\times 110$ are obtained by combining the two exponent matrices and the basic-matrix. It is obvious that the obtained matrix can encode 55 information bits at most. To increase the coding rate $k/N$, we can also add the rows $E_{A1}^{\prime }$ and $E_{A2}^{\prime }$ ($E_{B1}^{\prime }$ and $E_{B2}^{\prime }$) of the exponent matrix in terms of the algorithm described before, such as

$$\begin{array}{c}\hfill \left(E_{A1}^{\prime }\right|E_{A2}^{\prime })=\left(\begin{array}{cccccccccc}5& 7& 9& 1& 3& 3& 5& 7& 9& 1\\ 7& 9& 1& 3& 5& 5& 7& 9& 1& 3\\ 9& 1& 3& 5& 7& 7& 9& 1& 3& 5\\ 1& 3& 5& 7& 9& 9& 1& 3& 5& 7\\ 3& 5& 7& 9& 1& 1& 3& 5& 7& 9\end{array}\right)\end{array}$$

(35)

and

$$\left(E_{B1}^{\prime }\right|E_{B2}^{\prime })=\left(\begin{array}{cccccccccc}6& 8& 10& 2& 4& 4& 6& 8& 10& 2\\ 8& 10& 2& 4& 6& 6& 8& 10& 2& 4\\ 10& 2& 4& 6& 8& 8& 10& 2& 4& 6\\ 2& 4& 6& 8& 10& 10& 2& 4& 6& 8\\ 4& 6& 8& 10& 2& 2& 4& 6& 8& 10\end{array}\right).$$

(36)

As the result, the exponent matrices $G_{e_1}$ and $G_{e_2}$ can also be shown as the following $110\times 110$ matrix

$$\begin{array}{c}\hfill G_{e_1}=\left(\begin{array}{cc}{E}_{A1}& E_{A2}\\ E_{A1}^{\prime }& E_{A2}^{\prime }\end{array}\right) \mathrm{and} G_{e_2}=\left(\begin{array}{cc}{E}_{B1}& E_{B2}\\ E_{B1}^{\prime }& E_{B2}^{\prime }\end{array}\right).\end{array}$$

(37)

Therefore, the two matrices $G_1$ and $G_2$ are used to form the generator matrix ${\mathcal{G}}_c$ in Equation (5).

For example, if we wish to obtain a quantum code with a coding rate of 0.4, by applying the proposed approach, the two classical codes $C_1[110,80,12]$ and $C_2[110,74,14]$ can be constructed, respectively. Therefore, according to the construction method of CSS-type, a quantum code $\mathcal{C}[110,44,12]$ is obtained. With greatly increasing code length of QC codes, some methods of computing the minimum distance are required [37,38].

In the following, we use different parameters to analysis the bit error ratio (BER) of the presented QC codes with a jacket matrix of 0.5 code rate. We first consider the coding performance of one of the pair of classical codes $C_1$ and $C_2$ in Figure 3. Here, if different prime numbers are taken $n=29,23,19$ in the construction method, their corresponding code lengths are $N=n(n-1)=812,506,342$, respectively. With a 0.5 coding rate, we compare their corresponding QC codes. In the signal-to-noise ratio (SNR) range, it is shown that the two shorter lengths of the taken QC quantum codes show better performance from 0.2 to 0.4 dB than the longer one. However, owing to the close cycles and their bit-flip error correction capability, a greater length of code shows its superiority with increasing length.

Furthermore, we consider the probability of three classes of Pauli errors in the communication channel. Assuming the channel is viewed as a possibly more realistic depolarizing channel, it can independently generate a list of X bit-flip errors, Z phase-flip errors and Y errors which are a combination of bit and phase flip with equal probability $f/3$ for a total probability f. Hence, the marginal flip probability distributed identically is $f_m=2f/3$. Owing to the construction methods of all CSS-type quantum codes obtained by the two classical codes $C_1$ and $C_2$, the X-and-Z errors may be separately decoded and corrected with a standard classical correction algorithm [39]. In Figure 4, we compare the proposed QC quantum codes with the conventional quantum error-correction codes proposed in [22]. Here, we take, respectively, the quantum coding rate of these codes as 0.50 and 0.48. The proposed codes of lengths $N=7832$ and $N=5256$ are generated by jacket matrices with parameters $n=89$ and $n=73$, respectively. According to the construction method in [22], two codes with similar lengths $N=6806$ and $N=4970$ are compared. Because the pair of classical codes $C_1$ and $C_2$ are isomorphic, the average decoding performances are similar in simulation. Therefore, we just focus on analysis of the single classical code in Figure 4. According to the presented coding method, the obtained generator matrix has sparse properties in terms of the character of the jacket block matrix; hence, a larger minimum distance for the generator matrix can be obtained. As a result, the bit error rate of our gained codes is higher than for the conventional codes, although the floor of no error for both codes is down to about ${10}^{-6}$. However, with increasing $f_m$, their BERs tend to the same level. Therefore, the proposed QC quantum codes show better performance for the coding of large-scale data.

Assume $J_{\iota }$ is a $\iota \times \iota$ jacket in Equation (23) constructed with Pauli matrices ${\sigma }_0$ and ${\sigma }_1$ (not including the Hadamard matrix) in the described algorithm. To analysis the computation complexity, we first consider the 0 and 1 densities in the binary matrix denoted by

$$\begin{array}{c}\hfill d_0=\frac{{\iota }_1}{{\iota }_0+{\iota }_1},\end{array}$$

(38)

where ${\iota }_0$ and ${\iota }_1$ are the 0 and 1 numbers respectively. Therefore, the density $d_0$ of the jacket matrix equals $1/\iota$ and becomes lower with increasing length $\iota$. According to the described algorithm, there are two operators, i.e., the Kronecker-product operator ‘⊗’ and the direct-sum operator ‘⊕’, involved. It is obvious that the calculation complexity of the direct sum is $O\left(1\right)$ that is less than the Kronecker-product operator’s $O\left(\iota \right)$.

Therefore, the low complexity of the coding method should obey the following rules:

(1)

the length of the taken matrices between the Kronecker-product operator should be larger;

(2)

to obtain the long QC quantum code, the number in the decomposition method should include more direct-sum operators than Kronecker-product operators. As a result, the constructed quantum codes show good performance for low density code.

In addition, we consider the low-density properties of the constructed matrix. After first being proposed by Gallager, LDPC codes were rediscovered several decades later [31,32]. Classical LDPC codes have good performance, which approach the channel capacity in the limit of large block size. There has been considerable interest in finding quantum versions of these codes [33,34,35]. However, quantum LDPC codes are far less studied than their classical counterparts. In spite of its good performance, one main obstacle is how to obtain a highly efficient algorithm for iterative coding. In our paper, we have tentatively presented a method of constructing quantum LDPC codes and the results further enrich the theoretical achievements in this field. To ensure that the Tanner graph of the LDPC codes is free of 4-cycles, the girth may be at least 6 because the cycle of short length will reduce the performance of the LDPC codes. To meet the requirement, we just take the parameter n of the basic jacket matrix to be no less than 7, i.e., $l\ge 3$, in our construction algorithm.

In classical codes, a bipartite Tanner graph consists of check nodes and variable nodes [40]. The variable and check node degrees are denoted as $\eta$ and $\rho$, respectively, which correspond to the row and column minimum distances of the sparse parity-check matrix H. Assume the length of the shortest cycle on the graph, and that the number of independent iterations are referred to as the girth g and T, respectively [41,42]. Correspondingly, a useful iteration gain is generally bounded by

$$\begin{array}{c}\hfill T<g/4\le T+1.\end{array}$$

(39)

Obviously, the gained block length should be sufficient while the girth is given, so that the bound satisfies [42]

$$\begin{array}{c}\hfill N\ge 1+\sum _{i=2}^{x+1}\eta {(\eta -1)}^{i-2}{(\rho -1)}^{i-1}\end{array}$$

(40)

for a specific girth $g=4x+2$, where x is an integer. According to the bound (40), the relation of the code length N and the weights $\eta$ and $\rho$ is shown in Figure 5. Here, as x is taken as 2, 3 and 4 with hypothesis $\eta =\rho$, then the cycle-10, cycle-14 and cycle-18 are gained, respectively.

In this figure, it is shown that the length increases exponentially with the cycle length and its minimum weight $\eta$. Provided that the required cycle is determined, i.e., the cycle is bigger than a 4-cycle, for balancing the weights $\eta ,\rho$ and the code length N, it is necessary to consider the fundamental construction of the jacket matrix. In terms of the characters of the proposed method, the minimum distance of the obtained codes will grow linearly with increase in the parameter n. Thereby, we can apply the taken prime number to generate jacket matrices to adjust the relation between $\eta$ and N. The main rule for reducing the density and increasing the cycle of the parity check matrix H is that n in the decomposition method should be larger. For example, if we decompose the length $n=156$ of the QC code as $J_{156}=J_{13}\otimes J_3\otimes J_2^{\otimes 2}$ with the most basic method, the cycles will be smaller. However, if we take another decomposition method $J_{156}=J_7\otimes J_{11}\oplus J_{43}\oplus J_{23}\oplus J_{13}$, the cycle length is obviously increased, and, hence, the obtained quantum codes have the advantage of simple implementation of an iterative decoder and low-complexity encoding.

According to information coding theory, the sparse parity-check matrix H of code $[N,k]$ for decoding can be gained from the generator matrix. Based on the character of our constructed matrix with prime number n, it is easy to check that the variable and check node degrees in H or the corresponding bipartite Tanner graph at most are $\eta =n-1$ and $\rho =[k/n]+1$, where $[·]$ is an integral function. For Example 2, the row and column weights of the parity-check matrix for constructed codes $[110,80]$ are $\eta =9$ and $\rho =8$, respectively. It is obvious that the bound can be met with its 6-cycle for $x=1$.

Furthermore, according to the family of proposed codes from the circulant permutation matrix in Equation (14), the obtained quantum QC code of dimension $O\left(N\right)$ contains its upper bound on the minimum distance $O(N/logN)$ as the code length $N\to \infty$. This means that, the adopted parameter n in the proposed coding method should correspondingly approach

$$\begin{array}{c}\hfill n\approx \sqrt{\sum _{i=2}^{x+1}\eta {(\eta -1)}^{2(i-2)}},1<x\in \mathbb{Z}\end{array}$$

(41)

with the long-code length, where $\mathbb{Z}$ is an integer set.

In practical applications, quantum codes with long length may potentially be used in some future quantum information fields involved in large-scale data, such as quantum machine learning, which uses quantum computers and aims to enhance the power of machine learning. However, some major obstacles still limit the use of quantum hardware for practical applications of machine learning. One of the bottlenecks is that the data has to be encoded into the quantum computer in an efficient manner to generate its useful quantum kernel. Although some encoding methods have been investigated [43,44,45], the features are limited by the number of qubits [46]. Additionally, the inherent noise of quantum computers also influences the quality of the experimental results. Generally, rapid processing of the large datasets is vital because the operation timescale relies linearly on the size of the dataset. Therefore, to provide a useful kernel for machine learning, a good coding manner with long code length can efficiently load a high-dimensional feature vector into a quantum computer. As a consequence, the proposed coding method in this paper provides a tentative coding scheme for ML based on large-scale data.

5. Conclusions

The coding method for massive data has important applications in the field of information transmission and big-data processing. With the rapid development of quantum computing, this class of coding construction has become one of the research fields in quantum information. In this paper, based on a class of circulant permutation matrices, we presented quantum quasi-cyclic CSS codes in terms of two long-length classical codes based on block matrices. Motivated by the advantages of convenient and low-complexity implementation of an iterative decoder for proposed code, a family of jacket block matrices were applied to quantum coding construction. The presented method can efficiently construct long-length quantum QC codes based on the proposed method of an iterative coding process. If the parameter is selected appropriately, the obtained quantum codes are number 4-cycles in their generators and have good performance for LDPC codes.

Furthermore, we also analysed the marginal flip probability $f_m$ with respect to our proposed codes; that a good performance was obtained for the bit error rate is shown in Section 4. Therefore, the obtained QC quantum codes that benefit from their semi-parallel architectures can potentially be applied to the future quantum information field in relation to massive data.