A tensor compression method for quantum low-density parity-check code maximum likelihood decoding based on tensor network

Abstract

The application discloses a tensor compression method for quantum low-density parity-check code maximum likelihood decoding based on a tensor network and belongs to the technical field of quantum computation. The application aims at the computation and memory consumption problem in the tensor network representation of quantum low-density parity-check code maximum likelihood decoding. The maximum likelihood decoding problem is tensorized into a tensor network under a spin glass model. The tensor network is decomposed into a matrix product state. A high-order tensor is approximately decomposed into a matrix product of a low-order tensor. Offline contraction compression is performed. The memory occupation and computation amount of the tensor network are compressed from an exponential level to a linear level or even a constant level without losing accuracy, so that a one-dimensional chain matrix product state containing only logical indicators and accompanying formula indicators is obtained, thereby providing a basis for subsequent polynomial time online decoding.

Description

Technical Field

[0001] This invention relates to the field of quantum computing technology, specifically to a tensor compression method for maximum likelihood decoding of quantum low-density parity-check codes based on tensor networks. Background Technology

[0002] Quantum error correction (QEC) protects quantum information by encoding a logical qubit into multiple physical qubits. Quantum low-density parity-check (qLDPC) codes have a constant coding rate. Unlike surface codes, which typically require a quadratic number of physical bits, the number of physical bits required for qLDPC codes increases linearly with the code length, thus helping to reduce the physical bit overhead of fault-tolerant quantum computing.

[0003] Quantum error correction requires the decoder to infer the underlying error configuration from the error synod (binary string) obtained from the stabilizer measurement and to provide a correction operator. The decoding quality directly affects whether the system can maintain fault-tolerant operation. The stabilizers of qLDPC codes contain nonlocal interactions, and the parity check structure usually forms an irregular hypergraph, which is the main reason why this type of decoding problem is difficult.

[0004] Existing decoders can be divided into two categories based on their objectives: Minimum Weight Decoding (MWD) and Maximum Likelihood Decoding (MLD). MWD selects the single physical error with the smallest weight consistent with the syndrome, and is computationally easier, but its accuracy is affected by quantum degeneracy. MLD sums the probabilities of all physical errors under the same logic error, and selects the most likely logic error globally, usually providing a higher fault tolerance threshold. Since a true logic error corresponds to a set of physical errors rather than a single error, MWD is often only an approximation method. Experiments show that even the most advanced BP-OSD (Belief Propagation-Order Statistical Decoder) only has an 18.4% probability of correctly compensating for true logic errors on 72-bit bivariate bicycle (BB) codes.

[0005] However, MLD requires summing the probabilities of all physical errors belonging to the same logical error and matching their accompaniments, resulting in an exponential increase in computational and memory usage with code length. The computational cost (FLOPS) of accurate MLD expands dramatically with code length, and on large codebases, its memory requirements even exceed the capacity of an 80 GB GPU, making it impractical. More importantly, the computational process of MLD is completely different from MWD: directly transplanting MWD acceleration techniques (such as early termination and hardware pruning) to MLD will severely compromise fidelity due to inaccurate truncation of key probability summations. Existing Singular Value Decomposition (SVD)-based tensor compression methods, which only retain the largest singular values ​​and discard the rest, also cause significant accuracy loss. Therefore, a tensor compression method for the probability summation structure of MLD is needed to maintain accuracy as much as possible while reducing computational and memory overhead.

[0006] Theoretically, the MLD problem can be described using the spin glass model and tensor networks, but existing research mostly focuses on algebraic or statistical bounds for planar codes (repeating codes, surface codes), and directly applying them to qLDPC codes still presents 2 n The complexity is high, resulting in significant computational overhead and memory bottlenecks. Summary of the Invention

[0007] To address the computational and memory overhead issues in the MLD tensor network representation of qLDPC codes, this invention provides a tensor compression method for maximum likelihood decoding of quantum low-density parity-check codes based on tensor networks. By tensorizing the MLD problem into a tensor network under a spin glass model, the tensor network is precisely decomposed and offline shrinkage compression is performed. This reduces the memory footprint and computational cost of the tensor network from exponential to linear or even constant levels with almost no loss of accuracy, resulting in a one-dimensional chain matrix product state containing only logical and adjoint indices, providing a foundation for subsequent polynomial-time online decoding.

[0008] To achieve the above-mentioned objectives, an embodiment provides a tensor compression method for maximum likelihood decoding of quantum low-density parity-check codes based on tensor networks, comprising: The maximum likelihood decoding problem of quantum low-density parity-check codes is transformed into a tensor network of a spin glass model, and the calculation of the logic error probability is transformed into tensor network contraction. Perform matrix product state decomposition on tensors in tensor networks to decompose higher-order tensors into matrix products of lower-order tensors without approximation; Offline shrinkage and compression are performed on the decomposed tensor network. Through shrinkage, exchange, and merging operations, the tensor network is compressed into a one-dimensional chain matrix product state containing only logical and adjoint indices, thus completing the tensor compression.

[0009] In one embodiment, the maximum likelihood decoding problem of quantum low-density parity-check codes is transformed into a tensor network of a spin glass model, including: By using the destabilizing submatrix and the logic operator matrix, the physical error vector is decomposed into stabilizers, adjoints, and logic error parts, thereby transforming the constrained summation of physical errors into an unconstrained summation over all stabilizer configurations. The binary bits of the stabilizer, the synergy, and the logic error part are mapped to positive and negative spin variables respectively, and the physical error probability is substituted into the spin glass model according to this spin mapping, so that the summation of the logic error probability is transformed into the summation of the Boltzmann weights over all spin configurations. Define an energy tensor that carries the contribution of each physics error to the energy. Define the energy tensor and the Kronecker tensor. Rewrite the Boltzmann summation as the ratio of the contraction of the two tensor networks, where the numerator retains the logic and adjoint indices, and the denominator retains only the adjoint indices.

[0010] In one embodiment, the energy tensor The element is defined as: ; Or, expressed as physical error rate Explicit expression: When the index parity check Time value ,when Time value ,in, For each tensor index, for , This represents the remainder when the result is divided by two.

[0011] In one embodiment, the Kronecker tensor is defined as having a value of 1 when all indices are equal, and 0 otherwise.

[0012] In one embodiment, the matrix product state decomposition of tensors in a tensor network includes: The energy tensor is rewritten as a combination of hyperbolic functions, namely the sum of constant coefficient terms and variable coefficient terms, where the variable coefficient terms are the weight coefficients multiplied by the product of all relevant spin variables. Thus, the energy tensor is decomposed without approximation into a matrix product of multiple low-order tensors, each of which is related to only one spin variable. The Kronecker tensor is precisely decomposed into a chain structure of multiple low-order constraint tensors, where each low-order constraint tensor is used to constrain the equality relationship between two adjacent variables.

[0013] Through the precise decomposition described above, the storage complexity is reduced from exponential to linear.

[0014] In one embodiment, performing offline shrinkage and compression on the decomposed tensor network includes: representing the decomposed tensor network as a graph structure composed of nodes and edges, wherein nodes represent tensors and edges represent connections between tensors, and setting a set of nodes to be retained to store nodes with outer logic indicators or adjoint indicators. The following operations are performed repeatedly until all nodes enter the set of nodes to be retained: Select the edge with the minimum shrinkage cost, move the two nodes connected by this edge to the two ends of the matrix product state, and then shrink this edge to merge the two nodes into one node; update the neighbor relationships of the deleted nodes, and perform swapping and merging processing on duplicate connections to increase the key dimension; decide whether to retain or delete nodes in the merged node set based on whether the merged node belongs to the set of nodes to be retained. The final output is a one-dimensional chain matrix product state containing only logical and adjoint indices.

[0015] In one embodiment, the shrinking operation is to shrink the connection edge between two adjacent tensors and merge them into a new tensor; The exchange operation involves swapping the positions of two adjacent indices in the matrix product state. The exchange under certain combinations does not require approximate calculation, while the exchange under other combinations is achieved through a shrinkage and a matrix decomposition. The merge operation combines the edges between two adjacent matrix product states into a single edge of a higher dimension through two contraction operations.

[0016] In one embodiment, the selection of the edge with the minimum shrinkage cost follows a greedy strategy, prioritizing the shrinkage order that reduces the number of swap operations, thereby reducing the accuracy loss caused by matrix factorization approximation.

[0017] In one embodiment, the one-dimensional chain matrix product state retains only the outer logic index and the adjoint index. In the online decoding stage, the posterior probability of each logic error mode is calculated by shrinking the one-dimensional chain matrix product state to achieve maximum likelihood decoding.

[0018] Furthermore, both the matrix product state decomposition of the energy tensor and the low-rank decomposition of the Kronecker tensor are decompositions without precision loss. In offline shrinking compression, the matrix factorization operation only introduces truncation error in the exchange operation.

[0019] The present invention also provides a tensor compression device for maximum likelihood decoding of quantum low-density parity-check codes based on tensor networks, comprising a memory and a processor. The memory is used to store a computer program, and the processor is used to implement the tensor compression method for maximum likelihood decoding of quantum low-density parity-check codes based on tensor networks when the computer program is executed.

[0020] The present invention also provides a computer-readable storage medium having a program stored thereon, which, when executed by a processor, performs the tensor compression method for maximum likelihood decoding of quantum low-density parity-check codes based on tensor networks.

[0021] Compared with the prior art, the beneficial effects of the present invention include at least the following: (1) This invention uses matrix product state decomposition and takes advantage of the characteristic that the elements of the energy tensor only take two values ​​to decompose the high-order tensor into a matrix product of multiple low-order tensors without approximation. The element size is significantly reduced after decomposition, and the accurate low-rank decomposition of the Kronecker tensor also avoids the high-order storage overhead.

[0022] (2) By offline shrinking and compression, tensor networks with arbitrary topologies are transformed into one-dimensional chain matrix product states. The amount of shrinking computation in the online decoding stage is greatly reduced, and the overall decoding time complexity is reduced from exponential to polynomial, making practical deployment possible.

[0023] (3) Both the matrix product state decomposition of the energy tensor and the low-rank decomposition of the Kronecker tensor are approximation-free exact decompositions, which introduce precision loss. The offline compression stage is only implemented by using singular value decomposition in specific exchange operations, and the number of exchanges is minimized by a greedy strategy, which controls the truncation error to the local of the exchange operation and ensures the overall computational accuracy.

[0024] (4) This invention realizes the maximum likelihood decoding of quantum low-density parity-check codes. Under given syntactic conditions, it solves the optimal logical error mode that maximizes the probability of logical error. Compared with existing suboptimal decoding algorithms such as belief propagation, it can approach the theoretical optimal decoding performance limit. Attached Figure Description

[0025] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the accompanying drawings used in the description of the embodiments or the prior art will be briefly introduced below.

[0026] Figure 1 This is a flowchart illustrating the tensor compression method for maximum likelihood decoding of quantum low-density parity-check codes based on tensor networks provided by the present invention.

[0027] Figure 2 This is a schematic diagram of the structure of a tensor network decomposed into a matrix product state.

[0028] Figure 3 This is a schematic diagram of the offline shrinking and compression process. Detailed Implementation

[0029] To make the objectives, technical solutions, and advantages of this invention clearer, the following description is provided in conjunction with the accompanying drawings and... The embodiments further illustrate the present invention in detail. It should be understood that the specific embodiments described herein are merely illustrative of the invention and do not limit the scope of protection of the invention.

[0030] This invention addresses the computational and memory overhead issues in the MLD tensor network representation of qLDPC codes by proposing a tensor compression method. This method utilizes the structure of the tensor network itself to compress the original exponential high-order tensor representation into a one-dimensional chain matrix product state (MPS), while controlling the compression error. The resulting MPS can be used as input for subsequent polynomial-time online decoding.

[0031] like Figure 1 As shown in the figure, the embodiment provides a tensor compression method for maximum likelihood decoding of quantum low-density parity-check codes based on tensor networks, which mainly includes the following: Tensor quantization modeling: It transforms the constrained maximum likelihood probability calculation into tensor network contraction under the spin glass model, so that subsequent parallelization and decomposition processing have a clear structural basis.

[0032] Exponential memory compression: Utilizing precise tensor decomposition, the original O(2^3) memory can be compressed to a much smaller size. n Higher-order tensors are equivalently represented with linear complexity O(8). n The matrix product state (MPS) reduces memory bottlenecks.

[0033] Exponential computational complexity compression: An offline "shrink-swap-merge" method is used to compress high-dimensional connections into one-dimensional chain MPS, reducing online computational complexity from TFLOPS~PFLOPS to KFLOPS. Here, TFLOPS represents trillions of floating-point operations per second, a thousand times that of GFLOPS; PFLOPS represents quadrillion floating-point operations per second, a thousand times that of TFLOPS; and KFLOPS represents thousand floating-point operations per second.

[0034] Precision controllable: accurate decomposition does not introduce decomposition error; the exchange operation in offline shrinkage will produce truncation error, which can be controlled by the bond dimension χ and the shrinkage order.

[0035] The specific implementation steps include: S1. The maximum likelihood decoding problem of quantum low-density parity-check codes is transformed into a tensor network of a spin glass model, and the calculation of the logic error probability is transformed into tensor network contraction.

[0036] In this embodiment, the physical error vector of the quantum low-density parity-check (qLDPC) code is assumed to be... (its first) Bit ∈{0,1} represents the first... Whether an error occurs at any location, the probability of a physical error is... Within the CSS code framework, X-type and Z-type errors can be decoded independently, with Z-type error decoding considered without loss of generality. The X-type check is measured for Z-type errors to obtain the associated expression. Physical error, logical error With the accompanying satisfy: ; in, Represents an X-type parity check matrix. Represents an X-type logical operator. This represents the remainder when the result is divided by 2; The goal of MLD is to, given a syntactic... Next, calculate the logical probability. The biggest and most likely logical error : ; Among them, logical probability By accumulating all logical errors And matching the syntactic The probability of physical error is obtained as follows: , 2 ), , in, for For the first Error rate per physical error This represents the total number of physical errors.

[0037] To avoid physical errors caused by iterating through the two constraints mentioned above one by one, this invention first decomposes the logical error space into destabilizing subspaces. AND logical operators Stable subspace of translation : , , in, This represents the XOR operation. Indicates the number of parity bits; Substituting the values, we obtain the results for all possible stable subunits. Unconstrained summation: ; The summation still has exponential complexity. This invention further incorporates it into the spin glass model: errors have two discrete states, 0 and 1, which correspond precisely to the spin-up (+1) and spin-down (-1) states in a spin glass. Therefore, the stable sub-bits are... Accompanying Logical bits Mapped to stabilizer spin Accompanying spin Logical spin : , , ; The bit-to-spin mapping transforms the probability into a Hamiltonian. Determined spin glass energy: ; The logic error probability under the spin glass model is: .

[0038] The spin glass model can be written in tensor network form. This method maps the energy term and spin variable to energy tensors respectively. With Kronecker tensor The original summation is rewritten as the contraction of the tensor network T; the probability of logical error can be calculated by the following formula: , Among them, the tensor With Kronecker tensor Defined as ( For each tensor index): , ; Energy Tensor It can also be rewritten as physical error rate Explicit expression: When the index parity check Time value ,when Time value After this processing, the algorithm no longer scans all physical errors one by one, but instead shrinks a structured tensor network. Subsequent decomposition and compression are performed on this representation.

[0039] S2. Perform matrix product state decomposition on the tensors in the tensor network, decomposing the higher-order tensors into matrix products of lower-order tensors without approximation.

[0040] In the embodiment, each energy tensor in the original tensor network is an n-order tensor, containing 2^n tensors. n The computational and storage pressure is very high for tensors with only one element. Existing compression techniques mostly use singular value decomposition (SVD) to decompose tensors into low-rank matrix product states (MPS) or tree tensor network states; however, such decompositions usually only retain the largest few singular values ​​and discard the rest, which leads to a loss of accuracy.

[0041] The tensor obtained from the spin glass model has two distinct characteristics: each element takes only two values; and identical values ​​typically appear diagonally or alternately. Utilizing this, the tensor can be equivalently decomposed into a series of small matrices without introducing decomposition errors. Since the spin product can only be -1 or 1, the energy tensor... Take only or It can be written in the following hyperbolic function form: ; It can be verified that this energy tensor can be composed of several third-order or second-order small tensors. The exact representation of matrix multiplication, Total number of tensor indices: ; For example, a sixth-order energy tensor (64 elements) can be decomposed into six third-order tensors (40 elements in total). For the Kronecker tensor... Sharing the same indicator Since the elements have the same value, they can also be precisely decomposed into low-rank tensors: ; After the exact matrix product state decomposition described above, the original higher-order tensors are transformed into second- or third-order tensors, with each tensor connected to at most three neighbors. The memory complexity is reduced from O(2^3) to O(2^3). n ) decreased to O(8) n For example, for a 254-scale three-variable bicycle (TB) code, the memory footprint was reduced from 3.9 GB to 8.7 KB. The corresponding exact decomposition structure is as follows: Figure 2 As shown, the energy tensor The equivalent of being written as by , ... , Composed of chain MPS, and with Correspondingly, the element size changes from 64 elements to 40 elements. Under this decomposition structure, for a given... Figure 2 The inclusion in ~ , The original tensor network of a tensor can be decomposed into a tensor network containing only matrix product states while still retaining the original tensor network. , , , Extraordinary indicators.

[0042] S3. Perform offline shrinkage and compression on the decomposed tensor network. Through shrinkage, exchange, and merging operations, compress the tensor network into a one-dimensional chain matrix product state containing only logical indices and adjoint indices, thus completing the tensor compression.

[0043] In the embodiments, after precise decomposition, the storage pressure of individual tensors decreases, but high-dimensional connections still exist between matrices, making online shrinkage still heavy. This method processes these high-dimensional connections offline, using only one-dimensional chain MPS with low-dimensional topology for online decoding. High-dimensional connections mainly originate from edges within the ring structure (…). Figure 3 Therefore, the offline phase performs shrink-swap-merge operations around these internal edges. Figure 3 In the diagram, (1)~(9) represent the offline shrinking and compression process, and 1~12 on the circumference represent the tensors or index nodes to be processed: Step (1) performs shrinking, first shrinking an internal edge according to the gray arrow in the diagram; Step (2) performs swapping according to the gray arrow in the diagram; Step (3) performs merging, and marks the connections to be merged with χ; Step (4) in D= Continue exchanging according to the gray arrow in the diagram; step (5) performs the merge; step (6) at D= The connection point is swapped according to the gray arrow in the diagram; step (7) merges again; step (8) at D= The contraction is performed according to the direction of the gray arrow in the figure; step (9) outputs the one-dimensional chain matrix product state, and the example retains the index order as 9, 7, 5, 2. The legend on the right corresponds to the three types of operations: contraction, exchange, and merging. The definitions of the above three basic operations are as follows: Contract: A fundamental operation in tensor networks, contracting the edge indices between two adjacent tensors and merging them into a new tensor. The contraction cost for two tensors with dimensions d1 and d3 (with a key dimension of d2) is O(d1d2d3).

[0044] Swap: Exchanges the positions of two adjacent indices in MPS. Swaps are costless in the combinations (T,T), (T,δ), and (δ,δ); other combinations require one contraction and one SVD, with a cost of O(d). 6 Furthermore, due to the SVD approximation, a loss of accuracy is introduced.

[0045] Merge: Use two shrink operations to merge the edges between two adjacent MPS into a single higher-dimensional edge. The cost comes from the shrink operations.

[0046] Swap operations require SVD approximation, which introduces truncation errors. Therefore, Algorithm 1 employs a greedy order to minimize the number of swaps. The algorithm represents the tensor network as a graph. :node Represents tensors, edges Tensor Connection metrics and key dimensions (Initially 2); set Save the tensors that contain outer logic or adjoint indicators and are ultimately required to be retained. The process is as follows: (1) Decompose all tensors into MPS representations using exact decomposition; (2) Loop until all nodes are included in the hold set. (i.e., the remaining one-dimensional chain): Select the edge with the minimum contraction cost. ,Bundle The tensor in the middle is moved to the end of MPS. The tensor in the middle is moved to the beginning of MPS by shrinking the edge. Merge into a new MPS; (3) for Each neighbor :from Deleting edges ;like and If they are connected, then swapping them will result in repeated edges. Adjacent and merged, increasing the bond dimension ;like Not with If connected, then the edges are... join in (4) If Then put join in Otherwise from Delete The final result is a one-dimensional chain MPS containing only logical and adjoint indicators.

[0047] After offline shrinking, the tensor network becomes a one-dimensional chain MPS containing only logical indices and adjoint outer indices, facilitating storage and online shrinking. Taking a 72-scale BB code as an example, the online computation time decreased from 6.1 TFLOPS to 49 KFLOPS. This one-dimensional chain MPS was then used for polynomial-time online decoding.

[0048] To verify the effectiveness of the tensor compression method for maximum likelihood decoding of quantum low-density parity-check codes based on tensor networks proposed in this invention, experimental verification was conducted. This tensor compression method consists of three parts: tensor quantization, exact tensor decomposition, and offline tensor contraction. On the test code type, this method simultaneously reduces computational load and memory consumption, while keeping the compression error within an acceptable range. The experimental results are as follows: (1) The computational load is compressed exponentially. Compared to Exact MLD, this method requires less online computation; the gap widens further as the code size increases.

[0049] Table 1 As shown in Table 1, the computational cost of the BB code [[72,12,6]] decreased from 6.1 TFLOPS to 49 KFLOPS; the computational cost of the TB code [[48,4,8]] decreased from 10 7 PFLOPS dropped to 131 KFLOPS, with a compression ratio as high as 10. 17 ×.

[0050] (2) Memory usage is compressed from exponential to constant level. Memory usage also decreased accordingly. As shown in Table 2, the total number of tensors decreased by 3.6×~4.2×; the main memory bottleneck, "maximum tensor size," decreased from a scale that increased with code length (e.g., 1.0M in TB codes [[48,4,8]]) to a constant of 512, a reduction of 8.0×~2048.0× compared to the original MLD tensor network. On 254-scale TB codes, the overall memory usage decreased from 3.9 GB to 8.7 KB, a compression of 450176×, where TB codes are trivariate bicycle codes. Table 2 lists the results for each code type.

[0051] Table 2 (3) Precision is controllable and near-destructive. SVD-type compression typically reduces size by discarding singular values. This method's exact tensor decomposition does not discard information and introduces no decomposition error. The error arises only from the swap operations during offline shrinking and decreases as the key dimension χ increases; the greedy ordering in Algorithm 1 is used to reduce the number of swaps. Taking the BB code [[72,12,6]] as an example, after approximately 159 swaps, the cumulative truncation error decreases from 1.9 × 10⁻⁶ when χ=4. 1 When the value decreased to χ=128, it was 1.9×10⁻⁶. -9 When χ=64, the cumulative error of both representative codes is less than 10. -1 This error level is sufficient to support subsequent online decoding.

[0052] (4) Experimental verification The experiments were conducted on an AMD EPYC 9554 64-core CPU and an NVIDIA A100 80 GB GPU. Memory evaluation, computational cost evaluation, and offline tensor shrinking of the tensor network were all implemented using Quimb 1.11.1 (Python 3.12.1). The tests included 6 types of BB codes and 3 types of TB codes, for a total of 9 qLDPC codes; even on larger instances such as 254-size TB codes and 144-size BB codes, the computational cost and maximum tensor size could still be compressed to the aforementioned order of magnitude.

[0053] The specific embodiments described above illustrate the technical solution and beneficial effects of the present invention in detail. It should be understood that the above description is only the most preferred embodiment of the present invention and is not intended to limit the present invention. Any modifications, additions, and equivalent substitutions made within the scope of the principles of the present invention should be included within the protection scope of the present invention.

Claims

1. A tensor compression method for maximum likelihood decoding of quantum low-density parity-check codes based on tensor networks, characterized in that, include: The maximum likelihood decoding problem of quantum low-density parity-check codes is transformed into a tensor network of a spin glass model, and the calculation of the logic error probability is transformed into tensor network contraction. Perform matrix product state decomposition on tensors in tensor networks to decompose higher-order tensors into matrix products of lower-order tensors without approximation; Offline shrinkage and compression are performed on the decomposed tensor network. Through shrinkage, exchange, and merging operations, the tensor network is compressed into a one-dimensional chain matrix product state containing only logical and adjoint indices, thus completing the tensor compression.

2. The tensor compression method for maximum likelihood decoding of quantum low-density parity-check codes based on tensor networks according to claim 1, characterized in that, The maximum likelihood decoding problem of quantum low-density parity-check codes is transformed into a tensor network of a spin glass model, including: By using the destabilizing submatrix and the logic operator matrix, the physical error vector is decomposed into stabilizers, adjoints, and logic error parts, thereby transforming the constrained summation of physical errors into an unconstrained summation over all stabilizer configurations. The binary bits of the stabilizer, the synergy, and the logic error part are mapped to positive and negative spin variables respectively, and the physical error probability is substituted into the spin glass model according to this spin mapping, so that the summation of the logic error probability is transformed into the summation of the Boltzmann weights over all spin configurations. Define an energy tensor that carries the contribution of each physics error to the energy. Define the energy tensor and the Kronecker tensor. Rewrite the Boltzmann summation as the ratio of the contraction of the two tensor networks, where the numerator retains the logic and adjoint indices, and the denominator retains only the adjoint indices.

3. The tensor compression method for maximum likelihood decoding of quantum low-density parity-check codes based on tensor networks according to claim 2, characterized in that, The energy tensor The element is defined as: ； Or, expressed as physical error rate Explicit expression: When the index parity check Time value ,when Time value ,in, For each tensor index, for , This represents the remainder when the result is divided by two.

4. The tensor compression method for maximum likelihood decoding of quantum low-density parity-check codes based on tensor networks according to claim 2, characterized in that, The Kronecker tensor is defined as follows: it takes the value 1 when all indices are equal, and 0 otherwise.

5. The tensor compression method for maximum likelihood decoding of quantum low-density parity-check codes based on tensor networks according to claim 2, characterized in that, The matrix product state decomposition of tensors in a tensor network includes: The energy tensor is rewritten as a combination of hyperbolic functions, namely the sum of constant coefficient terms and variable coefficient terms, where the variable coefficient terms are the weight coefficients multiplied by the product of all relevant spin variables. Thus, the energy tensor is decomposed without approximation into a matrix product of multiple low-order tensors, each of which is related to only one spin variable. The Kronecker tensor is precisely decomposed into a chain structure of multiple low-order constraint tensors, where each low-order constraint tensor is used to constrain the equality relationship between two adjacent variables.

6. The tensor compression method for maximum likelihood decoding of quantum low-density parity-check codes based on tensor networks according to claim 5, characterized in that, The offline shrinking and compression of the decomposed tensor network includes: representing the decomposed tensor network as a graph structure composed of nodes and edges, where nodes represent tensors and edges represent connections between tensors, and setting a set of nodes to be retained to store nodes with outer logic indicators or adjoint indicators. The following operations are performed repeatedly until all nodes enter the set of nodes to be retained: Select the edge with the minimum shrinkage cost, move the two nodes connected by this edge to the two ends of the matrix product state, and then shrink this edge to merge the two nodes into one node; update the neighbor relationships of the deleted nodes, and perform swapping and merging processing on duplicate connections to increase the key dimension; decide whether to retain or delete nodes in the merged node set based on whether the merged node belongs to the set of nodes to be retained. The final output is a one-dimensional chain matrix product state containing only logical and adjoint indices.

7. The tensor compression method for maximum likelihood decoding of quantum low-density parity-check codes based on tensor networks according to claim 6, characterized in that, The shrinking operation shrinks the connection edge between two adjacent tensors and merges them into a new tensor. The exchange operation involves swapping the positions of two adjacent indices in the matrix product state. The exchange under certain combinations does not require approximate calculation, while the exchange under other combinations is achieved through a shrinkage and a matrix decomposition. The merge operation combines the edges between two adjacent matrix product states into a single edge of a higher dimension through two contraction operations.

8. The tensor compression method for maximum likelihood decoding of quantum low-density parity-check codes based on tensor networks according to claim 7, characterized in that, The one-dimensional chain matrix product state retains only the outer logic index and the adjoint index. In the online decoding stage, the posterior probability of each logic error mode is calculated by shrinking the one-dimensional chain matrix product state to achieve maximum likelihood decoding.

9. A tensor compression device for maximum likelihood decoding of quantum low-density parity-check codes based on tensor networks, comprising a memory and a processor, characterized in that, The memory is used to store a computer program, and the processor is used to implement the tensor compression method for maximum likelihood decoding of quantum low-density parity-check codes based on tensor networks as described in any one of claims 1-8 when the computer program is executed.

10. A computer-readable storage medium having a program stored thereon, characterized in that, When the program is executed by the processor, it performs the tensor compression method for maximum likelihood decoding of quantum low-density parity-check codes based on tensor networks as described in any one of claims 1-8.

Images