A high-performance decoding method for quantum low-density parity-check codes

Abstract

The application discloses a high-performance decoding method for quantum low-density parity-check codes and belongs to the technical field of quantum computation, and comprises the following steps: obtaining a transformation matrix and a permutation matrix through an offline satisfiability module theory optimized matrix decoupling strategy, and then equivalently transforming an original check matrix into a diagonal block matrix and an arbitrary sparse matrix; decomposing an error pattern into left errors corresponding to the diagonal block matrix and right errors corresponding to the arbitrary sparse matrix through an online hierarchical greedy decoding algorithm, first guessing error bits of the right errors, then calculating error syndromes corresponding to the left errors based on the arbitrary sparse matrix, then dividing the error syndromes according to the diagonal block matrix to perform parallel decoding, and finally combining decoding results of all block matrices to obtain the left errors, and finally splicing the left errors and the right errors to obtain a complete error pattern. The application can realize accurate and real-time decoding of qLDPC codes and is applied to frontier fields such as quantum communication and quantum computation.

Description

TECHNICAL FIELD

[0001] The application belongs to the technical field of quantum computing, and particularly relates to a high-performance decoding method for quantum low-density parity-check codes. BACKGROUND

[0002] Quantum error correction (QEC) is crucial for realizing large-scale fault-tolerant quantum computing. The implementation of QEC relies on error-correcting codes, which encode multiple physical qubits into one logical qubit, protecting the information of the logical qubit through redundant encoding. Among various error-correcting codes, the surface code is widely studied and experimentally implemented due to its high noise threshold and local-friendly structure. However, the surface code has the problem of poor scalability: due to its special planar lattice structure, the surface code requires hundreds or even thousands of physical qubits to encode a single logical qubit, resulting in a large amount of physical resource overhead, limiting the feasibility of building large-scale fault-tolerant quantum systems.

[0003] Quantum low-density parity-check codes (qLDPC) provide a promising alternative. qLDPC codes are defined by a binary sparse parity-check matrix (containing only 0 and 1), where each row of the parity-check matrix corresponds to a stabilizer, and each column corresponds to a data qubit. The 1 in the parity-check matrix indicates that the associated stabilizer acts on that data qubit. This sparse parity-check matrix enables asymptotic constant coding rate, making qLDPC codes more resource-efficient in physical qubits than surface codes. Notably, IBM introduced the binary-binary (BB) code in 2024, a series of qLDPC codes, which achieved a high error threshold of 0.7% and was able to save 10 times the physical qubit overhead compared to the surface code. This indicates that qLDPC codes have great potential as a scalable architecture solution for superconducting quantum computing platforms.

[0004] In addition to choosing a suitable error-correcting code, an accurate and real-time decoder also plays a key role in QEC. On the quantum computer side, parity-check qubits interact with nearby data qubits and periodically extract error syndromes. On the classical decoder side, the decoder uses these error syndromes to infer and correct errors on data qubits, and then enters the next QEC cycle. The decoder must be accurate because any incorrect correction can lead to logical errors, which will propagate through the quantum circuit and eventually cause the computation to fail. At the same time, the decoder must run in real time because if the decoding lags behind the generation of error syndromes, the system will continuously accumulate error syndromes, and the unprocessed data will delay subsequent quantum operations, and this delay overhead grows exponentially with circuit depth.

[0005] The simple, regular two-dimensional lattice structure of surface codes makes it easier for real-time decoders, such as the graph matching-based minimum-weight perfect matching (MWPM) algorithm. However, due to the structural difference of error-correcting codes, the MWPM decoding algorithm cannot be directly and efficiently applied to qLDPC codes. This is because, in qLDPC codes, each data qubit is connected to more than two parity qubits, forming a hypergraph structure rather than a simple graph. The resulting computational complexity makes the MWPM algorithm ineffective, as matching in a hypergraph is an NP-hard problem. Therefore, the decoding algorithm of qLDPC codes is significantly different from that of surface codes.

[0006] The most representative decoding algorithm of qLDPC codes is belief propagation (BP) and belief propagation with ordered statistical decoding (BP+OSD). BP is a message passing algorithm that obtains the approximate error probability of data qubits through iterative updates and improves these approximate probability values in each iteration, ideally converging to the most likely error pattern. If BP fails to converge, BP+OSD invokes OSD to post-process the decoding result. OSD first sorts the data qubits according to the error probability of BP. Then, it selects a subset of qubits, assumes a possible error pattern, and solves a restricted linear system to test whether the pattern matches the observed error syndrome. This process is repeated among many candidate error patterns to find the most likely error pattern.

[0007] However, BP and BP+OSD cannot simultaneously achieve high decoding accuracy and low decoding delay. BP, due to its low complexity and high parallelism, is expected to achieve real-time decoding and is suitable for deployment on hardware platforms such as FPGAs and ASICs. However, BP suffers from low accuracy due to the "quantum degeneracy" phenomenon, i.e., different error patterns can produce the same error syndrome. This problem arises because the number of columns in the check matrix far exceeds the number of rows. BP does not take this degeneracy into account, leading BP to often converge to incorrect results. Although BP+OSD improves accuracy by using OSD, the decoding latency of BP+OSD is very high due to high-complexity operations such as sorting and linear system solving. These computationally intensive operations make BP+OSD unsuitable for implementing real-time decoding. The trade-off between accuracy and delay highlights the urgent need for a high-performance qLDPC decoding algorithm theory to fill this research gap. SUMMARY

[0008] In view of the above, the purpose of this invention is to provide a high-performance decoding method for quantum low-density parity-check codes. This method decouples the parity-check matrix through an offline satisfiability modulus (SMT) optimized matrix decoupling strategy, and solves for error modes based on the decoupled parity-check matrix using an online hierarchical greedy decoding algorithm. This addresses the limitation of existing qLDPC decoding algorithms in the trade-off between accuracy and latency, thereby achieving accurate and real-time decoding of qLDPC codes. This method can be applied to cutting-edge fields such as quantum communication and quantum computing, which have extremely high requirements for data reliability and real-time performance.

[0009] To achieve the above-mentioned objectives, the present invention provides the following technical solution:

[0010] This invention provides a high-performance decoding method for quantum low-density parity-check codes, comprising the following steps:

[0011] By using a matrix decoupling strategy optimized by offline satisfiability modulo theory, the transformation matrix and permutation matrix are solved, and the original parity matrix is ​​equivalently transformed into a diagonal block matrix and an arbitrary sparse matrix.

[0012] The error pattern is decomposed into a left error corresponding to a diagonal block matrix and a right error corresponding to an arbitrary sparse matrix by using an online hierarchical greedy decoding algorithm. First, the error bits of the right error are guessed, and then the error symptoms corresponding to the left error are calculated based on the arbitrary sparse matrix. The error symptoms are then divided according to the diagonal block matrix for parallel decoding, and the decoding results of all the block matrices are merged to obtain the left error. Finally, the left error and the right error are concatenated to obtain the complete error pattern.

[0013] Preferably, the matrix decoupling strategy optimized by offline satisfiability modulo theory, after solving for the transformation matrix and permutation matrix, transforms the original parity-check matrix into a diagonal block matrix and an arbitrary sparse matrix, including:

[0014] The matrix decoupling strategy for offline satisfiability modular theory optimization firstly solves for the specific transformation matrix under constraints using a satisfiability modular theory solver. and permutation matrix And maximize the sparsity of the decoupling parity check matrix, then use the original quantum low-density parity check code's parity check matrix. By left multiplying the transformation matrix And right multiplication of the permutation matrix Performing an equivalent transformation yields a matrix including diagonal blocks. and arbitrary sparse matrices Decoupling verification matrix ,in Indicates the first A block matrix, This represents the total number of block matrices.

[0015] Preferably, the solving of the specific transformation matrix and permutation matrix by using the satisfiability modulo theories solver under the constraints comprises:

[0016] setting the transformation matrix and the permutation matrix into Boolean variables and used to represent the decoupling check matrix elements, the constraints in the decoupling process are set as:

[0017] (1) the transformation matrix is a full rank matrix, that is, there is no subset of any row that can be XORed to a zero vector;

[0018] (2) the permutation matrix satisfies that each row and each column contains only one non-zero element;

[0019] (3) the decoupling check matrix satisfies the defined specific shape, and the constraints on are as follows:

[0020] i. each block in the decoupling check matrix must have the same shape;

[0021] ii. except for the sparse matrix , all elements outside the block must be zero;

[0022] iii. each block in the decoupling check matrix must contain a unit matrix;

[0023] setting the objective function as seeking to minimize the total number of non-zero elements in the decoupling check matrix , thereby solving the specific transformation matrix and the permutation matrix based on the constraints and the objective function by using the satisfiability modulo theories solver.

[0024] Preferably, the decomposition of the error pattern into left errors corresponding to a diagonal block matrix and right errors corresponding to an arbitrary sparse matrix comprises:

[0025] decomposing the error pattern into left errors and right errors two-part vectors, corresponding to a diagonal block matrix , corresponding to a sparse matrix , and represented as:

[0026] ,

[0027] ,

[0028] in, This is the replaced error mode. It is the original error mode. These are the symptoms of an error after the transformation. These are the original, incorrect symptoms. It is an XOR operation.

[0029] Preferably, the step of first guessing the error bit of the right error and then calculating the error symptoms corresponding to the left error based on an arbitrary sparse matrix includes:

[0030] Based on the division of left-hand error and right-hand error, Defined as right error symptoms And move it to the right side of the equation to get the left-hand error symptoms. ,Right now:

[0031] ,

[0032] First, enter the original error symptoms. By transforming the matrix The transformed error symptoms are obtained. By guessing the right error in sequence Error bits and multiply by a sparse matrix Symptoms of right-hand error ,pass The left error symptoms were calculated separately for each instance. .

[0033] Preferably, the step of further dividing the error symptom into diagonal block matrices for parallel decoding and merging the decoding results of all block matrices to obtain the left error includes:

[0034] Based on the left error symptoms obtained in each calculation Decompose the block matrix into smaller components. This transforms into a smaller set of independent decoding problems. Parallel decoding is then performed, and the decoding results corresponding to all block matrices are obtained through an iterative greedy guessing function and then merged into the current calculation. Left error.

[0035] Preferably, the final concatenation of the left and right errors to obtain the complete error pattern includes:

[0036] The obtained left and right errors are concatenated to obtain the permuted error pattern. ,pass The substitution yields the complete error mode. .

[0037] Preferably, decoding is performed by a greedy guess function, including:

[0038] Decoupling the structure of the check matrix wherein, denotes the identity matrix, denotes an arbitrary matrix, and the left error is re-partitioned into and two parts, corresponding to the identity matrix , corresponding to the arbitrary matrix , the decoding constraint is re-set according to :

[0039] ,

[0040] The objective of decoding is to minimize the objective function as the likelihood , i.e., to minimize the number of non-zero values in , by using a guess strategy for the number of non-zero values in , starting from the minimum number and gradually increasing until the current objective is less than the existing minimum , then stopping iteration.

[0041] Compared with the prior art, the present application has at least the following beneficial effects:

[0042] (1) The present application designs an offline SMT optimization matrix decoupling strategy, which converts the original check matrix into a combination of a diagonal block matrix and an arbitrary sparse matrix, and the number of columns and rows of each block matrix is very close, thereby effectively alleviating the problem of low decoding accuracy caused by quantum degeneracy.

[0043] (2) The present application designs an online hierarchical greedy decoding algorithm, which can maximize the decoding parallelism and fully utilize the sparsity of the decoupled block matrix, and through iteration and greedy guessing, the occurrence probability of each possible error mode is calculated to constantly approach the most likely error mode, thereby significantly reducing the decoding delay. BRIEF DESCRIPTION OF DRAWINGS

[0044] In order to more clearly illustrate the technical solutions in the embodiments of the present application or the prior art, the following will briefly introduce the drawings needed to be used in the embodiments or prior art description. Obviously, the drawings in the following description are only some embodiments of the present application, and for those skilled in the art, other drawings can also be obtained without creative labor on the basis of these drawings.

[0045] Figure 1is a framework schematic diagram of a high-performance decoding method for quantum low-density parity-check codes provided by the embodiment of the application.

[0046] Figure 2 is a principle schematic diagram of a matrix decoupling strategy for offline SMT optimization provided by the embodiment of the application.

[0047] Figure 3 is a pseudo-code schematic diagram of an online hierarchical greedy decoding algorithm provided by the embodiment of the application.

[0048] Figure 4 is a process example diagram of a greedy guess (GreedyGuess) in the online hierarchical greedy decoding algorithm provided by the embodiment of the application. DETAILED DESCRIPTION

[0049] In order to make the object, technical scheme and advantages of the application clearer, the application is further described in detail below with reference to the drawings and embodiments. It should be understood that the specific embodiments described herein are only used to explain the application and do not limit the protection scope of the application.

[0050] The inventive concept of the application is that: previous decoding algorithms for qLDPC codes cannot simultaneously achieve high decoding accuracy and low decoding latency, resulting in the inability to be actually deployed in current fault-tolerant quantum systems. Specifically, the decoding accuracy of the BP algorithm decreases with the increase of the error correction code distance, while the accuracy of an excellent decoding algorithm should increase with the increase of the error correction code distance. This is because the increase of the code distance means the increase of the error correction capability, and the BP algorithm cannot fully utilize this error correction capability. In addition, in terms of decoding latency, the superconducting quantum platform requires that the decoding time of the decoder must be less than 1 mu s (microsecond), otherwise it will cause error accumulation, thereby making the quantum error correction ineffective. However, the high computational complexity of BP+OSD makes it impossible to be deployed on a hardware acceleration platform, and the decoding time is in the order of ms (millisecond) ~ s (second), which is completely unacceptable. Therefore, in order to solve this problem, the embodiment of the application provides a high-performance decoding method for quantum low-density parity-check codes, which proposes an offline SMT-optimized matrix decoupling strategy and an online hierarchical greedy decoding algorithm to solve the technical challenges of low accuracy and high latency faced by current qLDPC decoding algorithms, thereby realizing accurate and real-time decoding of qLDPC codes.

[0051] As shown in Figure 1 The embodiment provides a high-performance decoding method for quantum low-density parity-check codes, which comprises the following steps:

[0052] S1, through the matrix decoupling strategy optimized by the offline satisfiability module theory, the transformation matrix and the permutation matrix are solved to equivalently transform the original check matrix into a diagonal block matrix and an arbitrary sparse matrix.

[0053] The essential idea of offline decoupling is to divide the original large sparse parity check matrix into a series of independent, smaller sub-matrices. However, this idealized division is not achievable in most cases. Therefore, the present invention chooses to perform an equivalent row-column transformation on the original parity check matrix to make it into a combination of a diagonal block matrix and an arbitrary sparse matrix, as shown in the detailed process Figure 2 To do this, it is necessary to left-multiply the original parity check matrix by a transformation matrix and right-multiply it by a permutation matrix . Solving the optimal matrices and is a major challenge, as it involves a huge search space and requires a large amount of computation. The present invention solves this by reformulating the decoupling problem of the parity check matrix as an SMT problem, which allows the use of an SMT solver to find the optimal transformation. The present invention defines a set of solving constraints to ensure that the decoupled matrix meets the required structure, with the goal of maximizing sparsity. The transformation matrix and the permutation matrix are represented as Boolean variables, and the number of columns of the decoupled sub-matrices is closer to the number of rows, effectively alleviating the low precision problem caused by quantum degeneracy. The decoupled matrix is then stored for subsequent use by the online hierarchical greedy decoding algorithm.

[0054] S1.1, mathematical form: The present invention aims to apply the following transformation to the original parity check matrix :

[0055] (1),

[0056] where is the full-rank transformation matrix of , is the permutation matrix of , and is the decoupled parity check matrix after row-column transformation. Under this transformation, the maximum likelihood decoding of equation (1) becomes:

[0057] (2),

[0058] where is the error pattern after permutation, is the original error pattern, is the error syndrome after transformation, is the original error syndrome, is the weight corresponding to each error bit, The subscript error is represented. In order to recover the optimal original error pattern, the present application obtains the optimal permutation error pattern by decoding equation (2) , and recovers the optimal original error pattern by . For the decoupled check matrix , the present application aims to convert it into the following form:

[0059] (3),

[0060] wherein, is a diagonal block matrix, represents the th block matrix, represents the total number of block matrices, is an arbitrary sparse matrix. In order to simplify the subsequent online decoding algorithm, the present application further requires that each contains a unit matrix on the left. Specifically:

[0061] (4),

[0062] wherein, is a unit matrix, is an arbitrary matrix.

[0063] S1.2, variable definition: the present application sets the transformation matrix and the permutation matrix to Boolean variables. According to equation (1), the elements of can be represented by variables and

[0064] (5),

[0065] wherein, represents the element of the th row and the th column of , and and also represent the index of the row or column.

[0066] S1.3, constraint condition: the following conditions must be met during decoupling:

[0067] (1) transformation matrix: the transformation matrix must be a full rank matrix, which means that its rows are linearly independent. Specifically, no subset of any row can be XORed to a zero vector:

[0068] (6),

[0069] wherein, is the non-empty row index subset.

[0070] (2) Permutation matrix: The permutation matrix must satisfy that each row and each column contains only one non-zero element:

[0071] (7).

[0072] (3) Decoupling check matrix: The decoupling check matrix must satisfy the specific shape defined by the present invention, the constraints on are as follows:

[0073] i. Each block in the decoupling check matrix must have the same shape, denoted as . The total number of rows and the total number of columns of each sub-block matrix in must satisfy the following relationship:

[0074] (8),

[0075] wherein is the number of sub-blocks, and are the number of rows and columns of the original check matrix.

[0076] ii. All elements outside the block must be zero, except for the sparse matrix on the right side, that is:

[0077] (9).

[0078] iii. Each block in the decoupling check matrix must have a unit matrix on the left side, according to equation (4), that is:

[0079] (10).

[0080] S1.4, Objective function: The present invention aims to make the new check matrix sparse, to facilitate subsequent hardware acceleration, which means that the present invention seeks to minimize the total number of non-zero elements in :

[0081] (11).

[0082] The constraints in equations (5)-(10) and the objective in equation (11) are subsequently passed to an SMT solver to find the specific transformation matrix and the permutation matrix .

[0083] S2, by online hierarchical greedy decoding algorithm, the error pattern is decomposed into left error corresponding to diagonal block matrix and right error corresponding to arbitrary sparse matrix, the error bits of right error are first guessed, then the error syndrome corresponding to left error is calculated based on arbitrary sparse matrix, then the error syndrome is divided according to diagonal block matrix to parallel decoding, and the decoding results of all block matrices are combined to obtain left error, finally left error and right error are spliced to obtain complete error pattern.

[0084] The object of the present application is to decompose the original decoding problem into a set of smaller decoding problems that can be solved in parallel, and decode the most likely error pattern by online decoding algorithm. In order to solve the challenge of high latency, the online decoding algorithm maximizes parallelism and fully utilizes the sparsity in the decoupled sub-calibration matrix to speed up the decoding process. When the transformed matrix is a diagonal block matrix, it is direct. However, in the case of the present application, the decoupled check matrix contains a sparse matrix on the right side, which requires additional processing. In order to solve this problem, the present application divides the error pattern into left error and right error two-part vectors, corresponding to diagonal block matrix , corresponding to sparse matrix . This converts the constraint into the following form:

[0085] (12).

[0086] Then, the present application defines as the right error syndrome , and moves it to the right side of the equation to get the left error syndrome , that is:

[0087] (13).

[0088] This re-stated decoding constraint involves diagonal block matrix, left error, and error syndrome corresponding to left error. The present application further divides the left error syndrome into smaller components according to block matrix, so as to convert into a set of smaller independent decoding problems, where each constraint corresponds to a smaller check matrix:

[0089] (14).

[0090] Further, based on the new problem statement, the present application proposes a two-step online hierarchical greedy decoding algorithm, as Figure 1(b) and Figure 3 The algorithm first inputs the original error syndrome based on the transformation matrix The transformed error syndrome is initialized. The initial guess of the right error is set to the all-zero vector, and the initial likelihood of the error pattern is set to infinity. Next, the decoding process increases the number of iterations by one until it reaches the maximum iteration limit M. In each iteration , the present invention adopts a two-step decoding strategy: first guess the right error , then decode the left error . Finally, the best left error and the best right error are spliced and multiplied by the permutation matrix , thus obtaining the final output error pattern .

[0091] Specifically, the present invention explores the possible right error by flipping one bit at a time, and then calculates the left error syndrome . Then, the left error syndrome is split into based on the block matrix The present invention decodes the left error in parallel based on , after which the right error is updated and the next round of guessing + decoding process is performed, and then the weighted sum of the left error and the right error is calculated. At this time, the present invention checks whether the current target is less than the best solution found so far. If so, update the best solution for the next iteration. If not, terminate the process and return the best solution found so far.

[0092] GreedyGuess is used to decode the left error Figure 4 under the constraints specified in equation (14). As shown, by exploiting the structure of the decoupled check matrix , the present invention re-divides the left error into two parts: and corresponding to the identity matrix , corresponding to the arbitrary matrix . Therefore, the decoding constraints can be rewritten as:

[0093] (15).

[0094] The objective of the present invention is to minimize the objective function For the convenience of explanation, we assume that the weight of each data qubit is equal, so the above minimization objective function is equivalent to minimizing the number of 1s in To achieve this, the present application adopts a guessing strategy for the number of 1s in , starting from the minimum number and gradually increasing, and this search process follows a similar method to the algorithm in Figure 3 , until the current objective is less than the existing minimum , then stop iteration, and save the current minimum value of the possibility and the corresponding left error and right error.

[0095] In summary, the high-performance decoding method for quantum low-density parity-check codes provided by the embodiment of the present application can achieve decoding accuracy matching the BP+OSD algorithm on the benchmark test of 12 kinds of qLDPC codes, and the accuracy on the BB code [[144, 12, 12]] is even completely higher than the BP+OSD algorithm. In addition, compared with the BP algorithm, the decoding speed of the present application is improved by an average of 8.48 times.

[0096] The specific embodiments described above have described the technical solutions and beneficial effects of the present application in detail. It should be understood that the above description is only the most preferred embodiment of the present application and is not intended to limit the present application. Any modification, supplement and equivalent replacement within the principle range of the present application should be included in the protection scope of the present application.

Claims

1. A high-performance decoding method for quantum low-density parity-check codes, characterized by, The method comprises the following steps: The original check matrix is equivalently transformed into a diagonal block matrix and an arbitrary sparse matrix through a matrix decoupling strategy optimized by an offline satisfiability modulo theory, and a transformation matrix and a permutation matrix are solved out; The error pattern is decomposed into left errors corresponding to the diagonal block matrix and right errors corresponding to the arbitrary sparse matrix through an online hierarchical greedy decoding algorithm, the error bits of the right errors are first guessed, then the error syndromes corresponding to the left errors are calculated based on the arbitrary sparse matrix, the error syndromes are divided according to the diagonal block matrix to perform parallel decoding, and the decoding results of all the block matrices are combined to obtain the left errors, finally, the left errors and the right errors are spliced to obtain a complete error pattern.

2. The method of claim 1, wherein, The matrix decoupling strategy optimized by the offline satisfiability modulo theory, the transformation matrix and the permutation matrix are solved out, and the original check matrix is equivalently transformed into a diagonal block matrix and an arbitrary sparse matrix, and the method comprises the following steps: The matrix decoupling strategy for offline satisfiability modular theory optimization firstly solves for the specific transformation matrix under constraints using a satisfiability modular theory solver. and permutation matrix And maximize the sparsity of the decoupling parity check matrix, then use the original quantum low-density parity check code's parity check matrix. By left multiplying the transformation matrix And right multiplication by the permutation matrix Performing an equivalent transformation yields a matrix including diagonal blocks. and arbitrary sparse matrices Decoupling verification matrix ,in Indicates the first A block matrix, This represents the total number of block matrices.

3. The method of claim 2, wherein, The specific transformation matrix and the permutation matrix are solved out by using a satisfiability modulo theory solver under the constraint condition, and the method comprises the following steps: The transform matrix and the permutation matrix is set to a Boolean variable and used to represent the decoupling check matrix element, the constraint condition is set as follows in the decoupling process: (1) Transformation matrix is a full rank matrix, i.e. no subset of rows can xor to a zero vector; (2) permutation matrix satisfying that each row and each column contains only one non-zero element; (3) Decoupling check matrix satisfies a defined specific shape, against constraints as follows: i. Each block in the decoupled check matrix must have the same shape; ii, all elements outside the sparse matrix except that all elements outside the block must be zero; iii. Each block in the decoupled check matrix must contain a unit matrix; Setting the objective function to seek minimization of the total number of non-zero elements in the decoupled check matrix , thereby solving for the specific transformation matrix and permutation matrix based on the constraints and objective function through a satisfiability modulo theories solver.

4. The method of claim 2 or 3, wherein, The error pattern is decomposed into left errors corresponding to the diagonal block matrix and right errors corresponding to the arbitrary sparse matrix, and the method comprises the following steps: splitting the error pattern into left error and right error two-part vectors, corresponding to a diagonal block matrix , corresponding to a sparse matrix , denoted as: ， ， wherein is the permuted error pattern, is the original error pattern, is the transformed error syndrome, is the original error syndrome, is the exclusive OR operation.

5. The method of claim 4, wherein, The error bits of the right errors are first guessed, and then the error syndromes corresponding to the left errors are calculated based on the arbitrary sparse matrix, and the method comprises the following steps: According to the split left and right errors, we have defined as the right error syndrome and moving it to the right side of the equation, we get the left error syndrome i.e.: ， First, input the original error syndrome , by transformation matrix transformed to get the transformed error syndrome , by guessing the right error error bits and multiply the sparse matrix get the right error syndrome , by calculated by each left error syndrome .

6. The method of claim 5, wherein, The error syndromes are divided according to the diagonal block matrix to perform parallel decoding, and the decoding results of all the block matrices are combined to obtain the left errors, and the method comprises the following steps: left error syndrome based on each computation decomposition into smaller components into a set of smaller independent decoding problems parallel decoding, and the decoding results of all the block matrices are combined into the left error.

7. The method of claim 6, wherein, The left errors and the right errors are spliced to obtain a complete error pattern, and the method comprises the following steps: stitching all the left errors and right errors obtained to get the permuted error pattern , by permutation to get the complete error pattern .

8. The method of claim 6, wherein, Decoding is performed through a greedy guess function, and the method comprises the following steps: Utilizing structure of decoupled parity check matrix wherein, denotes an identity matrix, denotes an arbitrary matrix, and left error is re-partitioned into and two parts, corresponding to identity matrix , corresponding to arbitrary matrix , the decoding constraint is re-set according to ​ ， The goal of the definition decoding is to minimize the objective function as likelihood i.e. to minimize the number of non-zero values in the number of non-zero values in is stopped.

Images