Patent Publication Number: US-2022215284-A1

Title: Quantum belief propagation for low density parity checks

Description:
CROSS REFERENCE TO RELATED APPLICATIONS 
     This patent application claims priority to, and thus the benefit of an earlier filing date from, U.S. Provisional Patent Application No. 62/845,377 (filed May 9, 2019), the contents of which are hereby incorporated by reference. 
    
    
     STATEMENT REGARDING FEDERALLY SPONSORED RESEARCH OR DEVELOPMENT 
     This invention was made with government support under Grant No. CNS-1824357 awarded by the National Science Foundation. The government has certain rights in the invention. 
    
    
     BACKGROUND 
     Data transmission exists in a variety of forms over a variety of channel types. For example, data may be communicated over a Radio Frequency (RF) channel from a transmitter to a receiver, such as that occurring in mobile communications (e.g., cell phones), satellite communications, line of sight communications, and the like. A channel may even include data transfers in storage devices and systems. For example, in a hard disk drive (HDD), the channel may include the transfer of data between the read/write head and a magnetic disk. Or, the channel may include the transfer of data to and from memory cells of a flash memory device. The channel may even include computer buses that transfer data between electronic components, and optical fibers that transfer data between optoelectronic components. 
     In whatever form, these channels are rarely ideal communication links as noise may exist in, or be introduced to, the channels. And, the noise can impart errors on the data being transmitted (e.g., by flipping and/or degrading bits in the data transmission). To correct the errors, error correction codes (ECC) are often configured with the data being transferred such that the intended data may be reconstructed at a receiving end of the transmission. For example, a transmitter may encode a message with an ECC that allows the receiver to detect and correct some number of errors in the message without retransmission of the message. 
     Some forms of error correction include redundant bits of data that provide simple parity checks. Other forms of error correction, such as Low Density Parity Checks (LDPC), are much more complex and are used to encode and decode relatively large blocks of data. Processing requirements, however, generally increase with the complexity and size of the ECC. 
     SUMMARY 
     Systems and methods presented herein provide for error correction via LDPC coding. In one embodiment, a system includes a data buffer operable to receive a block of LDPC encoded data. The system also includes a processor operable to reduce a belief propagation algorithm used to encode the LDPC encoded data into a quadratic polynomial, to embed the quadratic polynomial onto a plurality of quantum bits (qubits), and to decode the block of LDPC encoded data via the qubits. 
     The various embodiments disclosed herein may be implemented in a variety of ways as a matter of design choice. For example, some embodiments herein are implemented in hardware whereas other embodiments may include processes that are operable to implement and/or operate the hardware. Other exemplary embodiments, including software and firmware, are described below. 
    
    
     
       BRIEF DESCRIPTION OF THE FIGURES 
       Some embodiments of the present invention are now described, by way of example only, and with reference to the accompanying drawings. The same reference number represents the same element or the same type of element on all drawings. 
         FIG. 1  is a block diagram of an exemplary system for decoding LDPC encoded data. 
         FIG. 2  is a block diagram of an exemplary Tanner graph. 
         FIG. 3  is an exemplary Chimera graph. 
         FIG. 4  illustrates an exemplary process for embedding logical qubits onto to physical qubits. 
         FIG. 5  illustrates an LDPC satisfier function creating an exemplary energy gap between valid and invalid codewords. 
         FIG. 6  illustrates an objective function of the belief propagation algorithm exemplarily separating energy bands of both valid and invalid LDPC codewords. 
         FIG. 7  illustrates exemplary energy levels via the selection of an objective function parameter. 
         FIG. 8  illustrates four exemplary schemas that a graph embedding model be used to represent a single check constraint on a single Chimera unit cell. 
         FIGS. 9 and 10  illustrate one of the exemplary schemas of  FIG. 8  and an exemplary Level I embedding onto physical qubits 
         FIGS. 11 and 12  illustrate one exemplary Level II embedding onto physical qubits 
         FIGS. 13 and 14  illustrate exemplary bit error rates achieved by the embodiments described herein. 
         FIGS. 15 and 16  illustrate exemplary choices of anneal times and the probability of not finding a ground truth across a distribution of problem instances. 
         FIGS. 17-20  show exemplary probabilities of not finding a minimum energy solution across the cumulative distribution of problem instances in a wireless channel. 
         FIG. 21  is a flowchart of an exemplary process of the system for decoding LDPC encoded data. 
         FIG. 22  is a block diagram of an exemplary computing system in which a computer readable medium provides instructions for performing methods herein. 
     
    
    
     DETAILED DESCRIPTION OF THE FIGURES 
     The figures and the following description illustrate specific exemplary embodiments. It will thus be appreciated that those skilled in the art will be able to devise various arrangements that, although not explicitly described or shown herein, embody certain principles and are included within the scope of the embodiments. Furthermore, any examples described herein are intended to aid in understanding the embodiments and are to be construed as being without limitation to such specifically recited examples and conditions. As a result, the embodiments are not limited to any of the examples described below. 
       FIG. 1  is a block diagram of an exemplary error correction system  10 . In this embodiment, the error correction system  10  includes a data buffer  12  and a processor  14 . The data buffer  12  is operable to receive and at least temporarily store data. The data, in this embodiment, is encoded in “blocks” (e.g., an established number of bits or bytes) with an LDPC ECC. For example, the data may be transmitted over a noisy channel  16  that may introduce errors in the data (e.g., flipped bits, degraded bits, etc.). To counter the errors, the transmitter side of the communication link may encode the data with an LDPC error correction code (ECC) in predetermined block sizes. 
     Using iterative belief propagation techniques of the LDPC ECC, the receiver side of the channel  16  may correct the errors in the data. In this regard, the data buffer  12  may receive the LDPC encoded data such that the processor  14  may decode the data. In doing so, the processor  14  may be operable to reduce the belief propagation algorithm of the LDPC ECC into a quadratic polynomial. The processor  14  may embed the quadratic polynomial onto a plurality of quantum bits (qubits) and then decode the block of LDPC encoded data via the qubits. 
     Based on the foregoing, the processor  14  is any device, system, software, firmware, or combination thereof operable to decode LDPC encoded data using qubits. In some embodiments, the processor  14  includes a quantum annealer that uses a metaheuristic for finding a global minimum of an objective function over a given set of candidate solutions/states via quantum fluctuations (e.g., temporary changes in the amount of energy in a point in space). 
     The data buffer  12  is any device, system, software, firmware, or combination thereof operable to at least temporarily store data. Examples of the data buffer  12  include various types of storage devices such as NAND flash memory devices, magnetoresistive memory devices, magnetic disk drives (e.g., hard disk drives), Random Access memory devices (RAMs, such as DRAMs), various combinations thereof, and the like. 
     The channel  16  includes any device or means for conveying data from a transmitter to a receiver. For example, in one embodiment, the channel  16  may provide over-the-air RF communications (e.g., satellite communications, cellular telephony, line of sight communications, etc.). In other embodiments, the channel  16  may include optical fiber used to convey optical data, various electronics and/or buses that are operable to convey data between electronic devices, storage device components and systems (e.g., magnetic read/write heads in hard disk drives, read/write controllers of NAND flash memory devices, cloud storage systems, etc.), and the like. 
     As mentioned, LDPC ECCs use belief propagation techniques to encode and decode blocks of data. Belief propagation algorithms in LDPC pass messages back and forth between check nodes and bit nodes described by a Tanner graph, eventually propagating information about checks and received bits in an LDPC codeword around the entire graph. While LDPC codes enjoy an inherently parallel structure, LDPC decoders generally require several serial message passing iterations to converge on a final result, thus limiting the communication throughput that silicon-based hardware LDPC decoders can achieve. Additionally, the silicon-based LDPC decoders limit the amount of computation they undertake in order to maintain an exceptional decoding latency and communication throughput. Accordingly, silicon-based LDPC decoders suffer from bit errors arising from computations in addition to those imparted by noise in communication channels. 
     To address these issues, the processor  14  may comprise a quantum annealer. A quantum annealer is a specialized analog computer that can solve non-deterministic polynomial (NP) complete and NP hard optimization problems in their equivalent Ising specifications. Quantum annealers generally include an array of physical devices each representing a single physical qubit that can take on a continuum of values unlike classical information bits, which are binary. A set of desired pairwise constraints between individual qubits (e.g., a preference that two particular qubits should differ and/or that two particular qubits should be identical) are input to the quantum annealer such that preferences regarding each individual qubit can take on a particular binary value in the solution output. The quantum annealer considers the entire set of constraints as a large optimization problem that is typically expressed as a quadratic polynomial of binary variables. A number of quantum annealing trials typically includes a single run with each anneal trial resulting in a potentially different solution to the problem (e.g., a set of classical output bits, one per qubit that fits the constraints of the trial). 
     Quantum annealers may be operable to implement the belief propagation algorithms of LDPC decoders. For example, the quantum annealer (e.g., the processor  14 ) may reduce the construction of an LDPC code directly onto a physical grid of qubits in the quantum annealer, taking into account the practical, real-world physical interconnections between individual qubits. 
     This reduction bypasses quadratic polynomial representation and allows for the quantum annealer to be tailored to a physical layout and connectivity of the qubits. In doing so, the quantum annealer includes an embedding scheme that can leverage much, if not all, of the available quantum annealing hardware qubit resources. In one embodiment, the quantum annealer includes a D-Wave 2000 qubit quantum adiabatic optimizer machine provided by D-Wave Systems Inc. In this embodiment, the embedding scheme may be operable to realize up to 700 problem variables or logical qubits representing up to 420 LDPC bit nodes. However, the embodiments herein are not intended to be limited to any type of quantum computing or any quantum computer size. 
     Before discussing exemplary implementations of LDPC decoding via qubits, a brief discussion on LDPC codes is provided. A binary (N, K) LDPC code is generally a linear block code described functionally by a sparse parity check matrix. The LDPC code is said to be a (d b , d c ) regular code if every bit node participates in d c  checks and every check has d b  bits that together constitute a check constraint. With conventional encoding and decoding schemes of LDPC codes, let H=[hij]M×N be the LDPC parity check matrix. Each row in H represents a check node constraint whereas each column indicates which check constraint a bit node participates in. 
     Now, turning to  FIG. 2 , a Tanner graph  20  illustrates nodes  21  and  22 . The nodes  21  labeled c i  are “check nodes” and the nodes  22  labeled b i  are “bit nodes”. The value of “1” at h mn  ∈ H represents an edge between c m  and b n . Code “girth” (e.g., the length of the shorter cycle in the Tanner graph  20 ) is an important measure as a low girth affects the independence of information exchange between the check and bit nodes and diminishes the LDPC code performance. 
     For encoding, let u be a message of length K. The overall encoding process may be summarized by first converting H into an automated form of [P|I N-K ] by Gauss-Jordan elimination (e.g., where P is obtained in the conversion process and I is the identity matrix). Then, a generator matrix G is constructed as [I K |P T ]. In the encoded message c may be constructed as c=uG. This encoding generally ensures that the modulo two bit sum at every check node is zero. 
     For decoding, the belief propagation based “min-sum” algorithm is used. For example, let y be the received information, let N(c m ) be the set of bit nodes participating in the check restraint c m , and let M(b n ) be the set of check nodes connected to the bit node b n . Then, initialize all of the bit nodes with their respective a priori likelihood ratio (LLR) as: 
     
       
         
           
             
               
                 
                   
                     L 
                     ⁢ 
                     L 
                     ⁢ 
                     
                       
                         R 
                         
                           b 
                           n 
                         
                       
                       ⁡ 
                       
                         ( 
                         
                           x 
                           n 
                         
                         ) 
                       
                     
                   
                   = 
                   
                     
                       log 
                       ⁡ 
                       
                         ( 
                         
                           
                             P 
                             ⁢ 
                             
                               r 
                               ⁡ 
                               
                                 ( 
                                 
                                   
                                     b 
                                     n 
                                   
                                   = 
                                   
                                     0 
                                     ⁢ 
                                     ly 
                                   
                                 
                                 ) 
                               
                             
                           
                           
                             P 
                             ⁢ 
                             
                               r 
                               ⁡ 
                               
                                 ( 
                                 
                                   
                                     b 
                                     n 
                                   
                                   = 
                                   
                                     1 
                                     ⁢ 
                                     ly 
                                   
                                 
                                 ) 
                               
                             
                           
                         
                         ) 
                       
                     
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     
                       ∀ 
                       
                         
                           b 
                           n 
                         
                         ∈ 
                         
                           N 
                           ⁡ 
                           
                             ( 
                             
                               c 
                               m 
                             
                             ) 
                           
                         
                       
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                   ⁢ 
                   1. 
                 
               
             
           
         
       
     
     Then, for every combination of {(m, n)|h mn =1}, initialize messages sent to the check node c m  from the bit node b n  ∈ N(c m ) as: 
         Z   b     n     →c     m   ( x   n )= LLR   b     n   ( x   n )  Eq. 2.
 
     Then, every check node c m  updates the message to be sent back with respect to every b n  ∈ N(c m ) as: 
     
       
         
           
             
               
                 
                   
                     
                       Z 
                       
                         
                           c 
                           m 
                         
                         → 
                         
                           b 
                           n 
                         
                       
                     
                     ⁡ 
                     
                       ( 
                       
                         x 
                         n 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       ∏ 
                       
                         
                           b 
                           
                             n 
                             ′ 
                           
                         
                         ∈ 
                         
                           
                             N 
                             ⁡ 
                             
                               ( 
                               
                                 c 
                                 m 
                               
                               ) 
                             
                           
                           ∖ 
                           
                             b 
                             n 
                           
                         
                       
                     
                     ⁢ 
                     
                       
                         sign 
                         ⁡ 
                         
                           ( 
                           
                             Z 
                             
                               
                                 b 
                                 
                                   n 
                                   ′ 
                                 
                               
                               → 
                               
                                 c 
                                 m 
                               
                             
                           
                           ) 
                         
                       
                       ⁢ 
                       
                         
                           min 
                           
                             
                               b 
                               
                                 n 
                                 ′ 
                               
                             
                             ∈ 
                             
                               
                                 N 
                                 ⁡ 
                                 
                                   ( 
                                   
                                     c 
                                     m 
                                   
                                   ) 
                                 
                               
                               ∖ 
                               
                                 b 
                                 n 
                               
                             
                           
                         
                         ⁢ 
                         
                            
                           
                             Z 
                             
                               
                                 b 
                                 
                                   n 
                                   ′ 
                                 
                               
                               → 
                               
                                 c 
                                 m 
                               
                             
                           
                            
                         
                       
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                   ⁢ 
                   3. 
                 
               
             
           
         
       
     
     Each bit node may now update the message to send back in accordance with the receipt check messages and its own belief by computing: 
     
       
         
           
             
               
                 
                   
                     
                       Z 
                       
                         
                           b 
                           n 
                         
                         → 
                         
                           c 
                           m 
                         
                       
                     
                     ⁡ 
                     
                       ( 
                       
                         x 
                         n 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       L 
                       ⁢ 
                       L 
                       ⁢ 
                       
                         
                           R 
                           
                             b 
                             n 
                           
                         
                         ⁡ 
                         
                           ( 
                           
                             x 
                             n 
                           
                           ) 
                         
                       
                     
                     + 
                     
                       
                         ∑ 
                         
                           
                             c 
                             
                               m 
                               ′ 
                             
                           
                           ∈ 
                           
                             
                               M 
                               ⁡ 
                               
                                 ( 
                                 
                                   b 
                                   n 
                                 
                                 ) 
                               
                             
                             ∖ 
                             
                               c 
                               m 
                             
                           
                         
                       
                       ⁢ 
                       
                         
                           Z 
                           
                             
                               c 
                               
                                 m 
                                 ′ 
                               
                             
                             → 
                             
                               b 
                               n 
                             
                           
                         
                         ⁡ 
                         
                           ( 
                           
                             x 
                             n 
                           
                           ) 
                         
                       
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                   ⁢ 
                   4. 
                 
               
             
           
         
       
     
     Then, to decode the encoded data, each bit node computes: 
     
       
         
           
             
               
                 
                   
                     
                       Z 
                       
                         b 
                         n 
                       
                     
                     ⁡ 
                     
                       ( 
                       
                         x 
                         n 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       L 
                       ⁢ 
                       L 
                       ⁢ 
                       
                         
                           R 
                           
                             b 
                             n 
                           
                         
                         ⁡ 
                         
                           ( 
                           
                             x 
                             n 
                           
                           ) 
                         
                       
                     
                     + 
                     
                       
                         ∑ 
                         
                           
                             c 
                             m 
                           
                           ∈ 
                           
                             M 
                             ⁡ 
                             
                               ( 
                               
                                 b 
                                 n 
                               
                               ) 
                             
                           
                         
                       
                       ⁢ 
                       
                         
                           Z 
                           
                             
                               c 
                               m 
                             
                             → 
                             
                               b 
                               n 
                             
                           
                         
                         ⁡ 
                         
                           ( 
                           
                             x 
                             n 
                           
                           ) 
                         
                       
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                   ⁢ 
                   5 
                 
               
             
           
         
       
     
     After decoding, a decision step includes quantizing {circumflex over (x)}=[{circumflex over (x)} 0 , {circumflex over (x)} 1 , . . . , {circumflex over (x)} N-1 ] such that {circumflex over (x)} n =0 if Z b     n   (x n )≥0, else {circumflex over (x)} n =1, with {circumflex over (x)} being the decoded bits. If {circumflex over (x)} satisfies a condition enforced at encoding {circumflex over (x)}H T =0, then {circumflex over (x)} is declared as the final decoded message. If {circumflex over (x)} does not satisfy this condition, the belief propagation algorithm iterates each of the steps until a satisfactory {circumflex over (x)} is obtained. The decoder may then terminate at a predetermined threshold number of iterations. 
     Before discussing how to implement the decoding on the quantum annealer, a brief introduction to quantum annealing is presented. Quantum annealing is a heuristic approach designed to solve combinatorial optimization problems and can be understood at a high level as solving the same class of problems as simulated annealing techniques. The quantum annealer (e.g., the processor  14 ) takes advantage of a fundamental fact that any process in nature seeks a minimum energy state to attain stability. Given a discrete optimization problem is as an input, a quantum annealer of the processor  14  internally frames the optimization problem as an energy minimization problem and outputs its ground state as the solution. 
     Qubits are generally classified into two types—physical and logical. A physical qubit is one that is directly and physically available on the quantum annealing hardware, whereas a logical qubit is a set of physical qubits. Often, the quantum annealing hardware lacks a coupler between a particular pair of physical qubits that a user would like to correlate. To construct this relationship, intermediate couplers may be used to make several physical qubits behave similarly, which may be referred to herein as “embedding”. 
     The set of similarly behaving embedded physical qubits may then be referred to as a logical qubit. The process of evolution of quantum bits to settle down at a ground state in the quantum annealer (e.g., the processor  14 ) is called an “anneal” whereas the time taken for this evolution is called an “annealing time”. The strength of the preference is given to each single qubit to end up in a particular logical “0” or a particular logical “1” state is referred to as a “bias”, whereas the strength of each coupler is referred to as a “coupler strength”. The strength of the couplers that are used to make physical qubits behave similarly in the embedding process are generally referred to as “JFerros”. 
     The quantum annealer of the processor  14  comprises a network of interlaced radio frequency superconducting quantum interference device flux qubits fabricated as an integrated circuit where the local longitudinal fields (i.e., the biases) of the qubits are adjustable with an external magnetic field. Interactions (i.e., the couplers) between pairs of qubits may be realized with a tunable magnetic coupling using programmable “on-chip” control circuitry. In one embodiment, the interconnection comprises a quasi-planar bi-layer Chimera graph, such as that illustrated in  FIG. 3 . 
       FIG. 3  illustrates a 3×6 portion of a 16×16 an exemplary Chimera graph  30 . The Chimera graph  30  comprises a plurality of Chimera unit cells  31  with each cell  31  comprising a set eight of physical qubits. Each edge in the Chimera graph  30  is a coupler. 
     The quantum annealer of the processor  14  may be operable to simulate systems in a two-dimensional transverse field Ising model described by the time-dependent Hamiltonian equation of: 
     
       
         
           
             
               
                 
                   
                     H 
                     ⁡ 
                     
                       ( 
                       s 
                       ) 
                     
                   
                   = 
                   
                     
                       
                         - 
                         
                           A 
                           ⁡ 
                           
                             ( 
                             s 
                             ) 
                           
                         
                       
                       ⁢ 
                       
                         
                           ∑ 
                           i 
                         
                         ⁢ 
                         
                           σ 
                           i 
                           x 
                         
                       
                     
                     + 
                     
                       
                         B 
                         ⁡ 
                         
                           ( 
                           s 
                           ) 
                         
                       
                       ⁢ 
                       
                         H 
                         P 
                       
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                   ⁢ 
                   6 
                 
               
             
             
               
                 and 
               
               
                 
                     
                 
               
             
             
               
                 
                   
                     H 
                     P 
                   
                   = 
                   
                     
                       
                         ∑ 
                         i 
                       
                       ⁢ 
                       
                         
                           h 
                           i 
                         
                         ⁢ 
                         
                           σ 
                           i 
                           z 
                         
                       
                     
                     + 
                     
                       
                         ∑ 
                         
                           i 
                           &lt; 
                           j 
                         
                       
                       ⁢ 
                       
                         
                           J 
                           
                             i 
                             ⁢ 
                             j 
                           
                         
                         ⁢ 
                         
                           σ 
                           i 
                           z 
                         
                         ⁢ 
                         
                           σ 
                           j 
                           z 
                         
                       
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                   ⁢ 
                   7 
                 
               
             
           
         
       
     
     where σ i   x,z  are the Pauli matrices acting on the i th  qubit, h i  and J ij  are the problem parameters, s=t/t a  (where t is time and t a  is the annealing time). A(s) and B(s) are two monotonic signals such that, at the beginning of the anneal (i.e., t=0), A(0)&gt;&gt;B(0)≈0. And, at the end of the anneal (i.e., t=t a ), B(1)&gt;&gt;A(1)≈1. The processor  14  initializes the qubits in a superposition state 
     
       
         
           
             
               
                 
                   1 
                   
                     2 
                   
                 
                 ⁢ 
                 
                   ( 
                   
                     
                        
                       0 
                       〉 
                     
                     + 
                   
                    
                 
                 ⁢ 
                 1 
               
               〉 
             
             ) 
           
         
       
     
     that has no classical counterpart. The processor  14  may then gradually evolve this Hamiltonian from t=0 until t=t a  by introducing quantum fluctuations in a low temperature environment. The time-dependent evolution of the signals A and B is generally the annealing algorithm. During the annealing process, the processor  14  may ideally stay in a local minima and probabilistically find a global minimum energy configuration of the problem Hamiltonian H p  at a conclusion. 
     The quantum annealer of the processor  14  may be used to solve a class of quadratic unconstrained binary optimization (QUBO) problems in an equivalent Ising specification, which may be defined as a generalized Ising/QUBO as: 
     
       
         
           
             
               
                 
                   E 
                   = 
                   
                     
                       
                         ∑ 
                         i 
                       
                       ⁢ 
                       
                         
                           h 
                           i 
                         
                         ⁢ 
                         
                           q 
                           i 
                         
                       
                     
                     + 
                     
                       
                         ∑ 
                         
                           i 
                           &lt; 
                           j 
                         
                       
                       ⁢ 
                       
                         
                           J 
                           
                             i 
                             ⁢ 
                             j 
                           
                         
                         ⁢ 
                         
                           q 
                           i 
                         
                         ⁢ 
                         
                           q 
                           j 
                         
                       
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                   ⁢ 
                   8. 
                 
               
             
           
         
       
     
     Ising form solution variables {q i } may take values in {−1, 1}, whereas in the QUBO form they may take values in {0,1}. The linear coefficient h i  is the bias of q i  and the quadratic coefficient J ij  is the strength of the coupler between q i  and q j . Coupler strength may be used to make the qubits agree or disagree. For example, consider the exemplary Ising problem: 
         E=J   12   q   1   q   2 ,( q   1   q   2 ∈{−1,+1})  Eq. 9.
 
     In a first scenario, J 12 =+1. The energies for qubit states (q 1 , q 2 )=(−1,−1), (−1,+1), (+1,−1), and (+1,+1) are +1, −1, −1, and +1, respectively. Accordingly, a strong positive coupler strength implies that a minimum energy of −1 is obtained when two qubits are opposites of each other. 
     In another scenario, J 12 =−1. The energies for qubit states (q 1 , q 2 )=(−1,−1), (−1,+1), (+1,−1), and (+1,+1) are −1, +1, +1, and −1, respectively. Accordingly, a strong negative coupler strength implies that a minimum energy of −1 is obtained when two qubits agree with each other. 
     Now, visualizing the relationship between logical and physical qubits, another exemplary problem may be considered as follows: 
         E=J   12   q   1   q   2   +J   23   q   2   q   3   +J   13   q   1   q   3   Eq. 10.
 
       FIG. 4  illustrates the embedding process of Eq. 10. The logical qubit q 1  before embedding is mapped onto two physical qubits q 1A  and q 1B  after embedding with a JFerro of −1. Here, q 1A  and q 1B  agree with each other. 
     It should be noted that a three node fully connected graph structure does not exist in a Chimera graph (e.g., Chimera graph  30  of  FIG. 3 ). Accordingly, one solution may include embedding one of the logical qubits into a physical realization consisting of two physical qubits as illustrated after embedding. This may allow for the construction of each edge (e.g., J 12 , J 23 , and J 13 ), e.g., as illustrated before embedding. In this embodiment, the logical qubit q 1  is mapped to physical qubits q 1A  and q 1B  with a JFerro of −1 to make q 1A  and q 1B  agree with each other. 
     With this in mind, the belief propagation algorithm of the LDPC code may be implemented as an LDPC decoding problem embedded on the quantum annealer (e.g., processor  14 ). First, the LDPC decoding problem may be reduced to a QUBO form. In this embodiment, the QUBO reduction of the LDPC decoding problem is a linear combination of two functions—an LDPC satisfier function and an LDPC distance function. 
     During an anneal, the LDPC satisfier function leaves valid LDPC codewords in a zero energy level while raising the energy of invalid codewords by a magnitude proportional to the LDPC code girth. The distance function distinguishes a true solution of the LDPC decoding problem among valid LDPC codewords by separating them by a magnitude depending on a distance between the individual codeword and the received information (e.g., including channel noise). 
     To generate a system model, let y=[y 0 , y 1 , . . . , y N-1 ] be the received information corresponding to an LDPC encoded transmitted message of x=[x 0 , x 1 , . . . , x N-1 ]. Then, let V be the set of check constraints c i  of the LDPC encoding. Additionally, let the final decoded message be the final states of the qubits [g 0 , g 1 , . . . , g N-1 ], respectively, and let any q e     i   ∀i&gt;0 be an ancillary qubit used for calculation purposes. Any given binary string may then be said to have a valid codeword when the binary string checks against a given parity check matrix. Otherwise, the codeword is invalid. 
     As mentioned, the QUBO objective function of the belief propagation algorithm may include two terms—the LDPC satisfier function and the LDPC distance function. The LDPC satisfier function may be represented as 
     
       
         
           
             
               
                 
                   
                     ∑ 
                     
                       
                         ∀ 
                         
                           c 
                           i 
                         
                       
                       ⁢ 
                       
                         ∈ 
                         V 
                       
                     
                   
                   ⁢ 
                   
                     
                       
                         L 
                         sat 
                       
                       ⁡ 
                       
                         ( 
                         
                           c 
                           i 
                         
                         ) 
                       
                     
                     . 
                   
                 
               
               
                 
                     
                 
               
             
           
         
       
     
     This function may be used to prioritize solutions that satisfy the LDPC check constraints (e.g., L sat (c i )=0). The LDPC&#39;s distance function may be represented as Σ j=0   N-1 Δ j  and may be used to calculate a candidate solution&#39;s proximity to received information. The entire QUBO function may thus be represented as a weighted linear combination of the two terms (i.e., the satisfier function and the distance function) as follows: 
     
       
         
           
             
               
                 
                   
                     min 
                     
                       q 
                       i 
                     
                   
                   ⁢ 
                   
                     { 
                     
                       
                         
                           W 
                           1 
                         
                         ⁢ 
                         
                           
                             ∑ 
                             
                               
                                 ∀ 
                                 
                                   c 
                                   i 
                                 
                               
                               ⁢ 
                               
                                 ∈ 
                                 V 
                               
                             
                           
                           ⁢ 
                           
                             
                               L 
                               
                                 s 
                                 ⁢ 
                                 a 
                                 ⁢ 
                                 t 
                               
                             
                             ⁡ 
                             
                               ( 
                               
                                 c 
                                 i 
                               
                               ) 
                             
                           
                         
                       
                       + 
                       
                         
                           W 
                           2 
                         
                         ⁢ 
                         
                           
                             ∑ 
                             
                               j 
                               = 
                               0 
                             
                             
                               N 
                               - 
                               1 
                             
                           
                           ⁢ 
                           
                             Δ 
                             j 
                           
                         
                       
                     
                     } 
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                   ⁢ 
                   11. 
                 
               
             
           
         
       
     
     In Eq. 11, W 1  is a positive weight used to enforce LDPC satisfying constraints while the positive weight W 2  may increase the success probability of finding a ground truth. 
     Exemplary energies of the LDPC satisfier function and the objective function of the belief propagation are illustrated in  FIGS. 5 and 6 . For example,  FIG. 5  illustrates the LDPC satisfier function creating an energy gap between valid and invalid codewords.  FIG. 6  illustrates the objective function of the belief propagation algorithm separating energy bands of both the valid and invalid LDPC codewords to correctly decode. In this example, actual data was used to compute the energy values of 20 valid codewords and 20 invalid codewords drawn at random. The LDPC satisfier function creates an energy gap of magnitude E g   IV  between valid and invalid codewords. This energy gap E g   IV  may be directly proportional to the girth of the LDPC code. For example, if the girth of the code is low, there exists an invalid codeword with a low Hamming distance to a valid codeword, thus implying a relatively low energy gap E g   IV . 
     By increasing W 1 , the energy gap increases and eliminates invalid codewords as potential solutions. The LDPC distance function distinguishes a transmitted codeword from other valid (but not transmitted) codewords that would otherwise reside in the ground energy state. The distance function separates the energy levels of both valid (e. g., E g   V ) and invalid (e.g., E g   1 ) codewords by a factor proportional to the design parameter W 2 . W 1  and W 2  may be experimentally determined based on the impact of a channel&#39;s signal-to-noise ratio (SNR) and the dynamic range of the quantum annealer of the processor  14 . For example,  FIG. 7  illustrates exemplary energy levels via the selection of the objective function parameter W 2 . Valid and invalid codeword bands are separated but the full dynamic range of the quantum annealer may not be fully utilized. By selecting W 2 &gt;1, the quantum annealer achieves the desired separation and full dynamic range, while W 2 &gt;&gt;1 fails to achieve separation. 
     The constraint on LDPC encoding is that a modulo two bit sum at every check node is zero (i.e., the sum is even). For each check node the LDPC satisfier function may be represented as: 
         L   sat ( c   i )=((Σ ∀j:h     ij     =1   q   j )−2 L   e ( c   i )) 2   ∀c   i   ∈V   Eq. 12
 
     The LDPC constraint is satisfied at the check node c i  when L sat (c i )=0. L e (c i ) is a function of ancillary qubits {q e     i   }. L e  may be formulated to use a minimal number of ancillary qubits via the following minimization: 
     
       
         
           
             
               
                 
                   
                     
                       L 
                       e 
                     
                     ⁡ 
                     
                       ( 
                       
                         c 
                         i 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       ∑ 
                       
                         s 
                         = 
                         1 
                       
                       t 
                     
                     ⁢ 
                     
                       ( 
                       
                         
                           2 
                           
                             s 
                             - 
                             1 
                           
                         
                         · 
                         
                           q 
                           
                             e 
                             
                               s 
                               + 
                               k 
                             
                           
                         
                       
                       ) 
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                   ⁢ 
                   13. 
                 
               
             
             
               
                 
                   
                     t 
                     = 
                     
                       
                         min 
                         
                           n 
                           ∈ 
                           ℤ 
                         
                       
                       ⁢ 
                       
                         { 
                         
                           
                             
                               2 
                               
                                 n 
                                 + 
                                 1 
                               
                             
                             - 
                             2 
                           
                           ≥ 
                           
                             
                               d 
                               ⁡ 
                               
                                 ( 
                                 
                                   c 
                                   i 
                                 
                                 ) 
                               
                             
                             - 
                             
                               ( 
                               
                                 
                                   d 
                                   ⁡ 
                                   
                                     ( 
                                     
                                       c 
                                       i 
                                     
                                     ) 
                                   
                                 
                                 ⁢ 
                                 mod 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 2 
                               
                               ) 
                             
                           
                         
                         } 
                       
                     
                   
                   , 
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                   ⁢ 
                   14. 
                 
               
             
           
         
       
     
     where d(c i ) is the degree of c i  (i.e., the number bits in the check constraint c i ). The value of k in L e (c i ) is generally the largest index of the ancillary qubit used while computing L e (c i-1 ), thus ensuring each ancillary qubit is only used once. The formulation of L e  can generally take all possible integral values in the range of [0, 2 t −1] (i.e., each energy for a distinct combination of ancillary qubits in that L e ). Since each configuration of ancillary variables takes a distinct integer, the formulation of L e  may be optimal in terms of using less ancillary qubits. Substitution of L e (c i ) in Eq. 12 may lead to an L sat (c i ) being zero when the most possible even sum of bits in c i  (i.e., d(c i )−(d(c i )mod 2)) does not exceed 2(2′−1), leading to the generalized minimization condition of Eq. 14. The number of ancillary qubits needed per check node is as follows: 
                                                            Check node degree   3   4-7   8-15   16-31           d(c i )                           Ancillary qubits   1   2   3    4           needed                        
Upon expansion of Eq. 12, L sat (c i ) introduces both biases and couplers to the objective QUBO and is therefore embedded onto the Chimera graph (e.g., Chimera graph  30  of  FIG. 3 ).
 
     For the distance function, a distance Δ i  is defined that computes the proximity of the i th  qubit q i  to its respective received information y i  as: 
       Δ i =( q   i   −Pr ( q   i =1| y   i )) 2   Eq. 15.
 
     The probability that q i  should take a “1” value given the received soft information y i  can be computed using the likelihood information obtained from the soft de-mapping of received symbols for various modulations and channels. For example, in a bi-phase shift keyed (BPSK) signal (0→−1, 1→+1), information transmitted over an Additive White Gaussian Noise (AWGN) with a noise variance of σ 2 , the probability may be given as 1/(1+e −2y     y     /σ     2   ). Accordingly, Δ i  is less for q 1  ∈ {0, 1} and has a greater probability of being the transmitted bit. And, the distance function may only introduce biases to the QUBO problem and does not require embedding due to the absence of coupler terms. 
     The QUBO reduction of the belief propagation algorithm of the LDPC code may be embedded onto the Chimera graph (i.e., the Chimera graph  30  illustrated in  FIG. 3 ). In one embodiment, the Chimera graph is operable with a D-Wave 2000 qubit quantum adiabatic optimizer machine and the embedding onto the D-Wave 2000 allows for the use of arbitrarily large hardware qubit connectivity that supports LDPC code block links up to 420 bits. 
     To embed the belief propagation algorithm for the LDPC code onto the quantum annealer, two-dimensional coordinate values U(x,y) are assigned to each unit cell  31  in the Chimera graph  30  of  FIG. 3 , with the unit cell  31 - 1  being deemed the origin U(0,0). From there, a unit cell  31  in the Chimera graph  30  takes on the coordinate value U(a,b) and is said to be a neighbor of the unit cell  31  having a coordinate value of U(x,y) when |x−a|+|y−b|=1. And, A(x,y) denotes the set of all neighbors of U(x,y). Intra-cell embedding occurs when both participating qubits lie in the same Chimera unit cell  31 . And, inter-cell embedding occurs where one of the qubits belongs to U(x,y) and the other participating qubit belongs to a unit cell  31  in A(x,y). 
     Generally, there are two levels for embedding, Level I and Level II. A graph embedding model first maps the check constraints L sat (c i ) of the LDPC satisfier function by constructing the Level I embedding for the available Chimera unit cell  31  and then accommodates more check constraints via the Level II embedding using the idle qubits that were left out during the Level I embedding. The graph embedding model may make use of the entire qubit computational resources available. For example, in the D-Wave 2000 qubit quantum adiabatic optimizer machine, the graph embedding model may leave no qubit idle in the machine. 
     In the Level I embedding, the graph embedding model represents a single check constraint of degree three on a single Chimera unit cell  31  using one of the four schemas  80 - 1 - 80 - 4  illustrated in  FIG. 8 . Each of these schemas  80  uses six qubits for a degree three check constraint, leaving two qubits in the Chimera unit cell  31  idle (e.g., illustrated by qubits  81 ). Intra-cell embeddings are illustrated in  FIG. 8  via the qubit connections  83  with all other qubit connections  84  being QUBO problem couplers. Based on the coordinate location U(x,y) of the Chimera unit cell  31 , the graph embedding model may choose a single schema  80  for a single Chimera unit cell  31  in a manner that creates a specific pattern of I/O qubits in the Chimera graph  30 . The graph embedding module may then leverage this pattern to accommodate more check constraints. 
     The graph embedding model may then place the check constraints that share a common bit closest to each other and embed the qubits representing the shared bit to make them agree. More specifically, if a check constraint c i  is placed in the coordinate value U(x 0 ,y 0 ), the graph embedding model may place the check constraints that share common bits with c i  in the neighboring unit cells  31  and embed the qubits representing such commonly shared bits via an inter-cell embedding Λ(x 0 ,y 0 ). 
     In the Level II embedding, the graph embedding model represents a single check constraint in an ensemble of nine Chimera unit cells  31  using a pattern of Vital qubits  81  left by the Level I embedding. The placement of each of these ensembles in the Chimera graph  30  may be similar to the Level I embedding in that it places the ensembles whose Level II embedding check constraints share bits that are close to each other. 
     Now, consider a (2,3) LDPC code where the degree of each check node three. Assume that [x a , x b , x c ] are the three bits participating in one of the check constraints c i . Then, let [q a , q b , q c ] be the bit node representing qubits used at the decoder to extract [x a , x b , x c ], respectively. Thus, from Eqs. 12 and 13, the LDPC satisfying constraint of the check node is 
         L   sat ( C   i )=( q   a   +q   b   +q   c −2 q   e     1   ) 2   Eq. 16.
 
     Upon expansion of Eq. 16 and with reference to  FIGS. 9 and 10 , it can be observed that the quadratic terms (i.e., the qubit pairs) requiring coupler connectivity are {(q a , q b ), (q a , q c ), (q a , q e     1   ), (q b , q c ), (q b , q e     1   ), (q c , q e     1   )}. The Level I embedding for the example in Eq. 16 can be visualized by interpreting (q a , q b , q c , q e     1   ) as being equivalent to (q 0 , q 4 , q 7 , q 3 ) of  FIG. 10 . Quantum belief propagation realizes the above coupler connectivity and the four schemas  80 - 1 - 80 - 4  of  FIG. 8 . 
     Now, one exemplary construction of the schema  80 - 1  can be demonstrated. For example, the required available coupler connectivity can be constructed using the quantum annealer&#39;s direct physical couplers of the processor  14  (e.g., q 0 -q 4  in schema  80 - 1 ). Then, the required but available coupler connectivity {(q 0 , q 3 ), (q 4 , q 7 )} can be realized using inter-cell embeddings (e.g., q 2 -q 4  in schema  80 - 1 ). 
     Now assume that the graph embedding model chooses the schema  80 - 1  for one of the Chimera unit cells  31  (see e.g.,  FIG. 9 ). Again, the exemplary LDPC code is (2, 3) regular, so every bit node participates in two check constraints. This implies that each “bit-node-representing” qubit, excluding ancillary qubits, is present in two Chimera unit cell  31  because a check constraint c i  in a single Chimera unit cell  31  is represented in the Level I embedding. The graph embedding model thus represents the other check constraint of each of the bit-node-representing qubits {q 0 , q 4 , q 7 } in a neighbor unit cell  31  connected via an inter-cell embedding  91  (see e.g.,  FIG. 9 ), and makes the physical qubits involved in the embedding agree. The graph embedding model may repeat this construction over the entire Chimera graph  30 , mapping each check constraint c i  to an appropriate physical location in the quantum annealer of the processor  14 . 
     Continuing with the example of Eq. 16, an overview of the level II embedding can be seen in  FIGS. 11 and 12 . Here, the mapping of bits in the check constraint c i  to physical qubits may be represented as (q a , q b , q c , q e     i   ) And mapped to (q A , q B , q C , q E ) of  FIG. 12 . For example, in  FIG. 12 , the qubits q A     i    ∈ [0,3] represent q 4 , the qubits g B     i    ∈ [0,2] represent q B , the qubits q C     i    ∈ [0,2] represent q C , and the qubits q E     i   ∈ [0,3] represent q E . These qubits are embedded together as illustrated in  FIG. 12 . Similar to the Level I embedding, the graph embedding model repeats the construction over the entire Chimera graph  30 , mapping each Level II check constraint c i  to an appropriate physical location in the quantum annealer of the processor  14 . 
     As mentioned, in one embodiment, the quantum belief propagation algorithm of the LDPC code is embedded on a D-Wave 2000 quantum annealer with the decoder targeting a (2, 3) regular maximum girth LDPC code having a block length of 420 bits. In this embodiment, the LDPC decoding by the processor  14  is evaluated in terms of bit error rate (BER) and frame error rate (FER). In doing so, an instance I may be defined as an LDPC codeword. One exemplary data set comprises 150 instances with an overall 2×10 4  message bits. The processor  14  conducts 10 4  anneals for each instance and notes the distribution of the solutions returned along with their occurring frequency. If N S   I  is a number of different solutions returned for an instance I, the solutions are ranked in increasing order of their energies as R 1 , . . . , R N     S       I   , with R 1  being the rank of the minimum energy solution. The N S   I  solutions can then be treated as identically independent random variables as each anneal is identical and independent. 
     For the BER evaluation, let R min  be the rank of the minimum energy solution in a particular population sample of the entire solution distribution of size N a  (&lt;10 4 ) anneals. The expected number of bit errors N B   I  of an instance I over N a  anneals can then be computed as: 
     
       
         
           
             
               
                 
                   
                     
                       E 
                       ⁡ 
                       
                         [ 
                         
                           
                             N 
                             B 
                             I 
                           
                           | 
                           
                             N 
                             a 
                           
                         
                         ] 
                       
                     
                     = 
                     
                       
                         ∑ 
                         
                           i 
                           = 
                           1 
                         
                         
                           N 
                           s 
                           I 
                         
                       
                       ⁢ 
                       
                         P 
                         ⁢ 
                         
                           
                             r 
                             ⁡ 
                             
                               ( 
                               
                                 
                                   
                                     R 
                                     min 
                                   
                                   = 
                                   
                                     
                                       R 
                                       i 
                                     
                                     | 
                                     I 
                                   
                                 
                                 , 
                                 
                                   N 
                                   a 
                                 
                               
                               ) 
                             
                           
                           · 
                           
                             
                               N 
                               B 
                               I 
                             
                             ⁡ 
                             
                               ( 
                               
                                 
                                   
                                     R 
                                     i 
                                   
                                   | 
                                   I 
                                 
                                 , 
                                 
                                   N 
                                   a 
                                 
                               
                               ) 
                             
                           
                         
                       
                     
                   
                   , 
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                   ⁢ 
                   17. 
                 
               
             
           
         
       
     
     where the probability of R min  being R i  ∀ i ∈ [1, N S   I ] for an instance I over performing N a  anneals may be computed using the cumulative distribution function F(⋅) of observed solutions in 10 4  anneals as: 
         Pr ( R   min   =R   i   |I,N   a )=(1− F ( R   i-1 )) N     a   −(1− F ( R   i )) N     a   .  Eq. 18.
 
     Accordingly, the BER of an instance I with K information bits upon performing N a  anneals can be computed as: 
       BER= E [ N   B   I   |N   a ]/ K.   Eq. 19.
 
     For the FER, a frame of length N B  is constructed using data blocks of length N B . The processor  14  uses N F /N B  such blocks, where each block is an instance. If N ins  is the number of available instances, the processor  14  can construct a single frame by combining any N F /N B  instances among the available N ins  instances. Thus, the total number of distinct frames that the processor  14  constructs for the FER evaluation is ( N     F     /N     B     N     ins   ). Generally, a frame is considered error-free if all of the code blocks in the frame have zero errors (e.g., just as if it has a cyclic redundancy check appended). The probability of a particular kth frame being error-free (i.e., Pr(F ef   k )) is: 
     
       
         
           
             
               
                 
                   
                     P 
                     ⁢ 
                     
                       r 
                       ⁡ 
                       
                         ( 
                         
                           F 
                           
                             e 
                             ⁢ 
                             f 
                           
                           k 
                         
                         ) 
                       
                     
                   
                   = 
                   
                     
                       ∏ 
                       
                         I 
                         = 
                         1 
                       
                       
                         
                           N 
                           F 
                         
                         / 
                         
                           N 
                           B 
                         
                       
                     
                     ⁢ 
                     
                       
                         { 
                         
                           
                             ∑ 
                             
                               ∀ 
                               i 
                             
                           
                           ⁢ 
                           
                             P 
                             ⁢ 
                             
                               r 
                               ⁡ 
                               
                                 ( 
                                 
                                   
                                     
                                       R 
                                       min 
                                     
                                     = 
                                     
                                       
                                         R 
                                         i 
                                       
                                       | 
                                       I 
                                     
                                   
                                   , 
                                   
                                     N 
                                     a 
                                   
                                   , 
                                   
                                     
                                       
                                         N 
                                         B 
                                         I 
                                       
                                       ⁡ 
                                       
                                         ( 
                                         
                                           R 
                                           i 
                                         
                                         ) 
                                       
                                     
                                     = 
                                     0 
                                   
                                 
                                 ) 
                               
                             
                           
                         
                         } 
                       
                       . 
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                   ⁢ 
                   20. 
                 
               
             
           
         
       
     
     Accordingly, the overall frame error rate may be computed as: 
     
       
         
           
             
               
                 
                   
                     F 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     E 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     R 
                   
                   = 
                   
                     
                       [ 
                       
                         
                           ∑ 
                           
                             k 
                             = 
                             1 
                           
                           
                             ( 
                             
                               
                                 
                                   
                                     N 
                                     ins 
                                   
                                 
                               
                               
                                 
                                   
                                     
                                       N 
                                       F 
                                     
                                     / 
                                     
                                       N 
                                       B 
                                     
                                   
                                 
                               
                             
                             ) 
                           
                         
                         ⁢ 
                         
                           { 
                           
                             1 
                             - 
                             
                               P 
                               ⁢ 
                               
                                 r 
                                 ⁡ 
                                 
                                   ( 
                                   
                                     F 
                                     
                                       e 
                                       ⁢ 
                                       f 
                                     
                                     k 
                                   
                                   ) 
                                 
                               
                             
                           
                           } 
                         
                       
                       ] 
                     
                     / 
                     
                       
                         ( 
                         
                           
                             
                               
                                 N 
                                 
                                   i 
                                   ⁢ 
                                   n 
                                   ⁢ 
                                   s 
                                 
                               
                             
                           
                           
                             
                               
                                 
                                   N 
                                   F 
                                 
                                 / 
                                 
                                   N 
                                   B 
                                 
                               
                             
                           
                         
                         ) 
                       
                       . 
                     
                   
                 
               
               
                 
                   Eq 
                   . 
                   
                       
                   
                   ⁢ 
                   21. 
                 
               
             
           
         
       
     
     Again, in one embodiment, the processor  14  comprises a D-Wave 2000 quantum annealer. It may be advantageous to determine the quantum annealer&#39;s system parameters including the coupler strength of an embedding JFerro (|J F |), annealing time T a , number of anneals N a , and the design parameter W 2  for evaluating the quantum belief propagation&#39;s overall system performance within the quantum annealer. For example, one purpose of embedding is to make qubits agree. Accordingly, a large negative JFerro may be required in order to ensure the embedding is effective. However, the supported range of coupler strengths in the D-Wave 2000 quantum annealer is [−1,1]. Accordingly, the QUBO of coefficients with respect to the JFerro (|J F |) may need to be normalized to bring the coupler strengths into the supported range. 
     For example, consider a QUBO problem with coupler strengths in the range [A, B]. Then the JFerro (|J F |) should be greater than the max (|A|,|B|) to prioritize embeddings over problem couplers and moderate enough to distinguish the new normalized coupler strengths 
     
       
         
           
             [ 
             
               
                 A 
                 
                   J 
                   F 
                 
               
               , 
               
                 B 
                 
                   J 
                   F 
                 
               
             
             ] 
           
         
       
     
     as the range lessens. The JFerro sensitivity analysis may be performed at a moderate SNR of 8 dB. Using a relatively high anneal time (e.g., T a =299 μs to ensure minimal disturbance from the time limit) and QUBO design parameters of W 1 =1.0 and W 2 =6.0, it can be shown that all other values of W 1  and W 2  may result in similar trends for the JFerro sensitivity. 
       FIG. 13  illustrates the bit error rate of the belief propagation algorithm embedded with the quantum annealer of the processor  14  with various JFerro (|J F |) strengths. For example, when one anneal (i.e., BER curve  102 ) is, or even 10 anneals (i.e., BER curve  103 ) are, performed by the quantum annealer, the BER is barely minimized at |J F |=8.0 because the effect of |J F | with fewer anneals is slight. However, with 50 anneals (i.e., BER curve  100 ) or even 100 anneals (i.e., BER curve  101 ) being performed by the quantum annealer, the JFerro (|J F |) minimizes the BER. 
     The choice of the design parameter W 2  can also influence the BER. For example, the LDPC satisfier function of the belief propagation algorithm of Eq. 12 may introduce coupler strengths (i.e., quadratic coefficients) greater than one. These are normalized to bring the problem coupler strengths into the supported [−1, 1] range. By setting W 1 =1.0 and considering the choice of W 2  (i.e., the parameter that determines sensitivity to the received bits used to identify a correct codeword), the optimal value of may be dynamically determined based on a channel&#39;s SNR (e.g., the channel  16  of  FIG. 1 ) so as to strike a balance between received soft information and the LDPC code constraints. 
     In one embodiment, the W 2  sensitivity analysis at |J F |=8.0 uses a relatively high anneal time (e.g., 299 μs) to ensure minimal disturbance from the time limit. An example of such as illustrated in  FIG. 14 . For example,  FIG. 14  illustrates various BER performances at various SNR&#39;s while varying the W 2  parameter. More specifically, the magnitude of the W 2  parameter that minimizes the BER increases with an increase in channel SNR. In this regard, the processor  14  may choose the W 2  parameter when LDPC data is being received. As an incoming frame of data arrives, the receiver (e.g., the data buffer  12  and the processor  14 ) may use the packet preamble to estimate SNR and then look up and optimal W 2  parameter for decoding in a lookup table. 
     The anneal time T a  may also be sensitive to |J F |. For example, in one actual reduction to practice, the annealing time T a  sensitivity was analyzed with |J F |=8.0 and W 1  equal to 1.0. The parameter was selected as before with 10 anneals being performed, although the number of anneals produce similar trends. For example,  FIGS. 15 and 16  illustrate the choice of an anneal time T a  and the probability of not finding a ground truth across a distribution of problem instances. An anneal time T a =1 of appears to be sufficient to achieve a relatively high probability of finding the ground truth. 
     Accordingly, the performance of the belief propagation algorithm in the quantum annealer can be quantified over a total compute time T c  where T c =N a ·T a . FIGS.  17 - 20  show the probability of not finding the minimum energy solution across the cumulative distribution of problem instances in a wireless channel with a 6 dB SNR over various choices of W 2  and computing times T c . These figures illustrate that the optimal choice of W 2  results in a relatively low possibility of not finding a ground truth as well as the benefits of increasing the compute time T c  up to 100 μs. 
     The performance of the quantum annealer embedded with the belief propagation algorithm of the LDPC code can also be experimentally evaluated. For example, in one actual reduction of practice, the performance of the quantum annealer of the processor  14  is evaluated over a Gaussian wireless channel at SNRs in the range of 1 to 11 dB. These evaluations were compared against soft belief propagation decoders operating within various iteration count limits. At SNRs of greater than 6 dB, the quantum annealer of the processor  14  outperformed conventional soft belief propagation decoders operating at 20 to 100 iterations. For example, the quantum annealer of the processor  14  is operable to obtain a BER of 10 −8  at an SNR between about 7.5 dB and 8.5 dB, whereas the conventional soft belief propagation decoders were only able to achieve a comparable BER at an SNR of 10.5 dB to 11 dB. This is generally due to the fact that the optimal choice of W 2  at relatively high SNRs is high, separating the ground truth with a relatively high energy gap to make the transmitted message easier to distinguish. 
     FER performance was also evaluated. For example, with frame sizes N F  of 420 and 12,000 bits, the quantum annealer of the processor  14  is able to obtain an FER of 10 −6  for signals between about 8 dB and 9 dB. 
       FIG. 21  is a flowchart of an exemplary process  200  of the system  10  of  FIG. 1  for decoding LDPC encoded data. In this embodiment, the data buffer  12  first receives a block of LDPC encoded data, in the process element  202 . For example, the data buffer  12  may be part of a processing system which receives LDPC encoded data through a channel  16 . The channel may be representative of a variety of communication links that may be influenced by noise that creates errors in the LDPC encoded data. Examples of such again include electronic communication links between electronic components (e.g., computer buses, system buses, etc.), RF communication links between transmitters and receivers (e.g., satellite communications systems, line of sight communications systems, cellular and mobile telephony systems, etc.), optical communication links, magnetic communication links (e.g., read/write heads interfacing with a magnetic disk and a hard disk drive), reads from memory cells and flash memory devices, and the like. 
     The processor  14  may decode the LDPC encoded data using a quantum annealer. For example, the LDPC encoded data is generally encoded via a belief propagation algorithm. The processor  14  may be operable to reduce the belief propagation algorithm into a quadratic polynomial, in the process element  204 , e.g., comprising an LDPC satisfier function and an LDPC distance function, such as those described in Eqs. 11-15. The processor  14 , and more specifically the quantum annealer, may embed the quadratic polynomial onto a plurality of qubits, in the process element  206 . And, based on this embedding, the processor  14  may decode the block of LDPC encoded data via the qubits, in the process element  208 , as described hereinabove. 
     Any of the above embodiments herein may be rearranged and/or combined with other embodiments. Accordingly, the concepts herein are not to be limited to any particular embodiment disclosed herein. Additionally, the embodiments can take the form of entirely hardware or comprising both hardware and software elements. Portions of the embodiments may be implemented in software, which includes but is not limited to firmware, resident software, microcode, etc.  FIG. 22  illustrates a computing system  300  in which a computer readable medium  306  may provide instructions for performing any of the methods disclosed herein. 
     Furthermore, the embodiments can take the form of a computer program product accessible from the computer readable medium  306  providing program code for use by or in connection with a computer or any instruction execution system. For the purposes of this description, the computer readable medium  306  can be any apparatus that can tangibly store the program for use by or in connection with the instruction execution system, apparatus, or device, including the computer system  300 . 
     The medium  306  can be any tangible electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system (or apparatus or device). Examples of a computer readable medium  306  include a semiconductor or solid state memory, magnetic tape, a removable computer diskette, a random access memory (RAM), NAND flash memory, a read-only memory (ROM), a rigid magnetic disk and an optical disk. Some examples of optical disks include compact disk-read only memory (CD-ROM), compact disk-read/write (CD-R/W) and digital versatile disc (DVD). 
     The computing system  300 , suitable for storing and/or executing program code, can include one or more processors  302  coupled directly or indirectly to memory  308  through a system bus  310 . The memory  308  can include local memory employed during actual execution of the program code, bulk storage, and cache memories which provide temporary storage of at least some program code in order to reduce the number of times code is retrieved from bulk storage during execution. Input/output or I/O devices  304  (including but not limited to keyboards, displays, pointing devices, etc.) can be coupled to the system either directly or through intervening I/O controllers. Network adapters may also be coupled to the system to enable the computing system  300  to become coupled to other data processing systems, such as through host systems interfaces  312 , or remote printers or storage devices through intervening private or public networks. Modems, cable modem and Ethernet cards are just a few of the currently available types of network adapters.