BlockBP: Block Belief Propagation

• BlockBP is a tensor network contraction method that groups tensors into blocks to capture short-loop correlations more accurately.
• It employs message passing using MPS on block boundaries, enabling parallel updates and reducing approximation errors in loopy networks.
• BlockBP is applied in quantum error correction and many-body simulations, often outperforming traditional BP with improved accuracy.

Searching arXiv for papers on BlockBP and closely related generalized/block belief propagation methods. BlockBP, short for block belief propagation, is an approximate contraction algorithm for two-dimensional tensor networks that replaces site-level message passing by message passing between blocks of tensors, thereby capturing short loops and short-range correlations more accurately than ordinary belief propagation while retaining a parallel message-passing structure (Guo et al., 2023). In the tensor-network-decoding setting, BlockBP is used as an approximate contraction engine for the tensor networks whose contractions equal surface-code logical-coset probabilities, so it functions inside a degenerate quantum maximum-likelihood decoding pipeline rather than as a Tanner-graph decoder in the usual sense (Kaufmann et al., 2024). Closely related work places BlockBP within a broader generalized belief propagation or tree-equivalent framework for loopy graphical models and tensor networks, clarifying its relationship to region-based approximations and Bethe-style overlap corrections (Hack et al., 2024).

1. Origins and problem setting

BlockBP was introduced in the context of the longstanding difficulty of contracting 2D tensor networks, especially PEPS and iPEPS, for computing norms, local environments, local observables, and imaginary-time-evolution updates (Guo et al., 2023). The underlying computational problem is hard: the contraction of a general 2D tensor network is intractable in the worst case, and exact contraction becomes exponentially expensive because loops are ubiquitous and intermediate tensors grow rapidly (Gutman, 2 Mar 2026). Standard approximate contraction methods such as boundary MPS, CTMRG, and related truncation-based schemes remain effective but can be costly and less naturally parallelizable (Guo et al., 2023).

The algorithmic motivation for BlockBP comes from the connection between tensor networks and probabilistic graphical models. Ordinary belief propagation can be adapted from graphical models to tensor-network contraction, where local messages summarize the influence of the rest of the network on a site or region (Guo et al., 2023). However, ordinary BP is exact only on trees and degrades on loopy, highly correlated, or frustrated 2D systems because it treats the environment as separable across incoming edges and therefore fails to represent strong local loop correlations adequately (Gutman, 2 Mar 2026).

This limitation is especially relevant in two applications discussed in the literature. In many-body simulation, ordinary tensor-network BP is closely related to simple update, and inherits its mean-field-like approximation of the environment (Gutman, 2 Mar 2026). In quantum error correction, surface-code decoding via tensor networks requires comparing logical-coset partition functions, and a purely local BP approximation is often too crude on the highly loopy networks that arise there (Kaufmann et al., 2024).

2. Core construction and message-passing rule

The defining idea of BlockBP is to coarse-grain the tensor network into blocks and run BP between those blocks instead of between individual tensors (Guo et al., 2023). In ordinary BP, a node corresponds to one tensor in the double-layer network and a message lives on a single virtual bond. In BlockBP, a node is a block containing many tensors, and the message from one block to another is an MPS living on the whole block boundary shared by the two blocks (Gutman, 2 Mar 2026).

For a tensor network $T$ defined on a graph, ordinary tensor-network BP uses messages $m_{u\to v}(x_e)$ on directed edges, with update rule

$m^{(t+1)}_{v\to u} = \Tr(T_v\!\!\!\!\!\!\!\! \prod_{u'\in N_v\setminus\{u\}\!\!\!\!\! m^{(t)}_{u'\to v}),$

where $N_v$ is the set of neighbors of $v$ (Kaufmann et al., 2024). BlockBP keeps the same cavity logic but lifts it to the block level. In the formulation of the 2023 tensor-network paper, the central BlockBP update is

$$m_{A\rightarrow B}^{(\ell+1)} = \mathrm{Tr} \left( T_A \prod_{A'\in N_A \setminus \{B\} } m_{A'\rightarrow A}^{(\ell)} \right),$$

where $T_A$ is the open double-layer tensor network corresponding to block $A$, $N_A$ is the set of neighboring blocks, and the result is compressed as an MPS on the $A$-$m_{u\to v}(x_e)$0 boundary (Guo et al., 2023). In the infinite-lattice thesis version, the same idea is written as

$m_{u\to v}(x_e)$1

with block tensors $m_{u\to v}(x_e)$2 and MPS messages $m_{u\to v}(x_e)$3 (Gutman, 2 Mar 2026).

The essential approximation is structural. The exact environment of a block is generally a correlated object surrounding the entire block, but BlockBP approximates that environment by a product of edge MPSs, one for each boundary side (Guo et al., 2023). This preserves all correlations inside a block while breaking entanglement between different block edges. The literature identifies this as the main residual error of the method (Gutman, 2 Mar 2026).

3. Tensor-network implementation details

BlockBP is implemented on the double-layer tensor network obtained by contracting ket and bra tensors along the physical legs, so that the contraction represents quantities such as $m_{u\to v}(x_e)$4 or local expectation values (Guo et al., 2023). A block is then a connected subnetwork of these double-layer tensors with open legs on its boundary (Gutman, 2 Mar 2026).

A crucial practical point is that one does not simply fuse a block into one exact tensor and pass exact boundary tensors between blocks, because those block tensors and messages would grow exponentially with boundary size (Kaufmann et al., 2024). Instead, BlockBP uses compressed one-dimensional tensor representations. Messages are represented as MPS of bond dimension $m_{u\to v}(x_e)$5, and block contractions needed for message updates are themselves carried out approximately using a boundary MPS or bubblecon-type contraction engine (Kaufmann et al., 2024, Gutman, 2 Mar 2026).

In the surface-code decoder based on BlockBP, the tensor network is partitioned into disjoint spatial blocks, typically $m_{u\to v}(x_e)$6 blocks, with a tunable local block size $m_{u\to v}(x_e)$7 (Kaufmann et al., 2024). To send a message from block $m_{u\to v}(x_e)$8 to neighboring block $m_{u\to v}(x_e)$9, the algorithm attaches all incoming neighboring messages except from $m^{(t+1)}_{v\to u} = \Tr(T_v\!\!\!\!\!\!\!\! \prod_{u'\in N_v\setminus\{u\}\!\!\!\!\! m^{(t)}_{u'\to v}),$0, contracts the resulting small 2D tensor network approximately using the boundary MPS method with maximal truncation bond $m^{(t+1)}_{v\to u} = \Tr(T_v\!\!\!\!\!\!\!\! \prod_{u'\in N_v\setminus\{u\}\!\!\!\!\! m^{(t)}_{u'\to v}),$1, and outputs the resulting boundary object as an MPS message (Kaufmann et al., 2024). This produces two approximation layers: a Bethe / BP approximation across blocks and an MPS truncation inside message and block contractions (Kaufmann et al., 2024).

The infinite-lattice formulation imposes additional geometric constraints on the block. The block must tile the infinite lattice, and all edges exiting a given face must enter together through the opposite face, since one block face is represented by a single MPS message (Gutman, 2 Mar 2026). For the Kagome lattice, the thesis discusses both hexagonal and parallelogram blocks and chooses a hexagonal block because preserving rotational symmetry is useful for that problem (Gutman, 2 Mar 2026).

4. Bethe approximation, beliefs, and partition functions

After message convergence, BlockBP estimates the full tensor-network contraction using a Bethe free-energy expression (Kaufmann et al., 2024). If $m^{(t+1)}_{v\to u} = \Tr(T_v\!\!\!\!\!\!\!\! \prod_{u'\in N_v\setminus\{u\}\!\!\!\!\! m^{(t)}_{u'\to v}),$2 are converged BP messages and $m^{(t+1)}_{v\to u} = \Tr(T_v\!\!\!\!\!\!\!\! \prod_{u'\in N_v\setminus\{u\}\!\!\!\!\! m^{(t)}_{u'\to v}),$3 are rescaled messages normalized so that

$m^{(t+1)}_{v\to u} = \Tr(T_v\!\!\!\!\!\!\!\! \prod_{u'\in N_v\setminus\{u\}\!\!\!\!\! m^{(t)}_{u'\to v}),$4

then

$m^{(t+1)}_{v\to u} = \Tr(T_v\!\!\!\!\!\!\!\! \prod_{u'\in N_v\setminus\{u\}\!\!\!\!\! m^{(t)}_{u'\to v}),$5

and the contraction is approximated by

$m^{(t+1)}_{v\to u} = \Tr(T_v\!\!\!\!\!\!\!\! \prod_{u'\in N_v\setminus\{u\}\!\!\!\!\! m^{(t)}_{u'\to v}),$6

These formulas are used explicitly in the surface-code decoder to assemble a global contraction estimate from local block computations (Kaufmann et al., 2024).

The same paper gives the associated Bethe marginals. For an edge $m^{(t+1)}_{v\to u} = \Tr(T_v\!\!\!\!\!\!\!\! \prod_{u'\in N_v\setminus\{u\}\!\!\!\!\! m^{(t)}_{u'\to v}),$7,

$m^{(t+1)}_{v\to u} = \Tr(T_v\!\!\!\!\!\!\!\! \prod_{u'\in N_v\setminus\{u\}\!\!\!\!\! m^{(t)}_{u'\to v}),$8

and for a vertex $m^{(t+1)}_{v\to u} = \Tr(T_v\!\!\!\!\!\!\!\! \prod_{u'\in N_v\setminus\{u\}\!\!\!\!\! m^{(t)}_{u'\to v}),$9,

$N_v$0

With normalized messages,

$N_v$1

and the Bethe free energy is

$N_v$2

This makes explicit that BlockBP is not only a heuristic contraction routine but a blockwise realization of a Bethe-style variational approximation (Kaufmann et al., 2024).

Related generalized-BP work presents a broader inclusion–exclusion view of these formulas. For tensor networks, one writes a partition function

$N_v$3

defines neighborhoods or regions $N_v$4, and derives overlap-corrected partition-function expressions in which region contributions appear in the numerator and overlap regions remove overcounting in the denominator (Hack et al., 2024). In that formulation, the partition-function expression used in BlockBP,

$N_v$5

with

$N_v$6

is interpreted as a simplification valid when the only redundant information between blocks lies in the shared boundary variables (Hack et al., 2024).

5. Surface-code decoding and degenerate maximum-likelihood decoding

A major use of BlockBP is in a surface-code decoder that works in the degenerate quantum maximum-likelihood decoding framework (Kaufmann et al., 2024). The physical noise is assumed to be a stochastic Pauli channel

$N_v$7

and because stabilizer codes are degenerate, decoding should compare coset probabilities

$N_v$8

Given a syndrome $N_v$9, one chooses a reference Pauli $v$0 consistent with that syndrome and compares the four logical cosets

$v$1

to perform DQMLD (Kaufmann et al., 2024).

For the surface code, prior tensor-network decoders showed that each coset probability can be written as the contraction of a $v$2 square tensor network of bond dimension $v$3: $v$4 BlockBP is then used as a drop-in replacement for the expensive contraction step (Kaufmann et al., 2024).

The decoding workflow is explicit. For a syndrome $v$5, one constructs the four tensor networks

$v$6

partitions each into $v$7 blocks, initializes the block-to-block MPS messages to represent a uniform probability distribution, and iterates message updates up to max-iter rounds (Kaufmann et al., 2024). The paper defines a convergence metric $v$8 as an average message-change norm between consecutive rounds, uses an early-stop threshold $v$9, and accepts the Bethe contraction estimate only if the final convergence error also satisfies a looser threshold $$m_{A\rightarrow B}^{(\ell+1)} = \mathrm{Tr} \left( T_A \prod_{A'\in N_A \setminus \{B\} } m_{A'\rightarrow A}^{(\ell)} \right),$$0 (Kaufmann et al., 2024).

Once the estimated coset contractions are available, the decoder returns the $$m_{A\rightarrow B}^{(\ell+1)} = \mathrm{Tr} \left( T_A \prod_{A'\in N_A \setminus \{B\} } m_{A'\rightarrow A}^{(\ell)} \right),$$1 with maximal estimated $$m_{A\rightarrow B}^{(\ell+1)} = \mathrm{Tr} \left( T_A \prod_{A'\in N_A \setminus \{B\} } m_{A'\rightarrow A}^{(\ell)} \right),$$2. If no coset reaches $$m_{A\rightarrow B}^{(\ell+1)} = \mathrm{Tr} \left( T_A \prod_{A'\in N_A \setminus \{B\} } m_{A'\rightarrow A}^{(\ell)} \right),$$3, the decoder returns the coset with the smallest $$m_{A\rightarrow B}^{(\ell+1)} = \mathrm{Tr} \left( T_A \prod_{A'\in N_A \setminus \{B\} } m_{A'\rightarrow A}^{(\ell)} \right),$$4 (Kaufmann et al., 2024). The paper treats this fallback rule as an empirical heuristic and reports that the correct coset is almost always the one with the fastest BP convergence (Kaufmann et al., 2024).

This decoder is conceptually distinct from Tanner-graph BP decoders. BP is not run on the surface-code Tanner graph to infer a most likely error directly; it is run on tensor networks representing coset probabilities, so the decoder remains a degenerate maximum-likelihood decoder rather than a QMLD-style decoder that ignores stabilizer degeneracy (Kaufmann et al., 2024). This distinction is central to why BlockBP is compared to tensor-network decoders rather than to ordinary quantum-code BP.

6. Relation to ordinary BP, generalized BP, and surface-code region methods

BlockBP is best understood as one member of a broader family of region-based or generalized BP methods. The 2024 paper "Belief propagation for general graphical models with loops" makes this connection explicit: BlockBP is described as a tensor-network BP method in which a PEPS tensor network is partitioned into square blocks and messages are exchanged between blocks “in the spirit of the tree-equivalent method” (Hack et al., 2024). That paper argues that BlockBP is not an isolated heuristic but a concrete instance of a more general neighborhood-based message-passing construction related to the proposal of Kirkley, Cantwell, and Newman (Hack et al., 2024).

In that generalized view, one chooses neighborhoods $$m_{A\rightarrow B}^{(\ell+1)} = \mathrm{Tr} \left( T_A \prod_{A'\in N_A \setminus \{B\} } m_{A'\rightarrow A}^{(\ell)} \right),$$5, defines region differences $$m_{A\rightarrow B}^{(\ell+1)} = \mathrm{Tr} \left( T_A \prod_{A'\in N_A \setminus \{B\} } m_{A'\rightarrow A}^{(\ell)} \right),$$6 and overlaps $$m_{A\rightarrow B}^{(\ell+1)} = \mathrm{Tr} \left( T_A \prod_{A'\in N_A \setminus \{B\} } m_{A'\rightarrow A}^{(\ell)} \right),$$7, and updates messages by contracting region differences against incoming messages (Hack et al., 2024). When the chosen neighborhood size is large enough to contain all loops of the original graph, the region construction becomes tree-equivalent and the corresponding generalized-BP equations are exact (Hack et al., 2024). This suggests that BlockBP can be interpreted as exact on a tree of blocks and approximate otherwise.

The same paper further states that BlockBP and the Kirkley-style method rely on essentially the same approximation principle: compute correlations exactly inside chosen neighborhoods or blocks, and approximate the full loopy model by exchanging messages between those larger regions while correcting for overlap only approximately in a Bethe-like way when the induced region graph is not a tree (Hack et al., 2024). A plausible implication is that BlockBP should be viewed less as a sui generis tensor trick and more as a specialized tensor-network realization of generalized BP.

This broader perspective is useful when comparing BlockBP to other surface-code BP-family decoders. The 2022 paper "Generalized Belief Propagation Algorithms for Decoding of Surface Codes" studies a different decoder: generalized belief propagation on a region graph, with regions built from local Tanner-graph substructures plus a crucial outer re-initialization loop (Old et al., 2022). That decoder diagnoses the failure of naive BP on surface codes in terms of surface-code symmetry and degeneracy, including “split belief,” and shows that a region-based BP-family method can recover a sub-threshold regime where naive BP fails (Old et al., 2022). However, its surface-code region choice is conceptually adjacent to BlockBP rather than identical, because it is a GBP interpretation of the Bethe approximation rather than a multi-tensor block contraction scheme (Old et al., 2022).

The conceptual bridge is nevertheless strong. Both BlockBP and region-graph surface-code GBP are motivated by the inadequacy of qubit- or tensor-local BP on highly symmetric, loopy structures, and both improve the local approximation by grouping variables or tensors into larger regions (Old et al., 2022, Hack et al., 2024). This suggests that “BlockBP” may designate either a specific tensor-network block algorithm or, more loosely, a broader family of block- or region-based BP corrections to ordinary loopy BP. The exact terminology is paper-dependent.

7. Computational scaling, empirical behavior, and limitations

The literature emphasizes that BlockBP is not chiefly an improvement in serial asymptotic runtime; its main advantage is the tradeoff between local accuracy and parallelizability (Kaufmann et al., 2024). In the surface-code decoder, if $$m_{A\rightarrow B}^{(\ell+1)} = \mathrm{Tr} \left( T_A \prod_{A'\in N_A \setminus \{B\} } m_{A'\rightarrow A}^{(\ell)} \right),$$8 is the number of blocks, $$m_{A\rightarrow B}^{(\ell+1)} = \mathrm{Tr} \left( T_A \prod_{A'\in N_A \setminus \{B\} } m_{A'\rightarrow A}^{(\ell)} \right),$$9 the linear block size, $T_A$0 the maximal MPS bond dimension, and max-iter the number of BP rounds, then the serial runtime is

$T_A$1

with

$T_A$2

which the paper describes as “identical or higher than the regular TN decoder” (Kaufmann et al., 2024). The claimed benefit is instead the parallel runtime

$T_A$3

neglecting message overhead, with a further factor-of-$T_A$4 reduction if the outgoing messages of each block are computed in parallel (Kaufmann et al., 2024).

The more general infinite-lattice thesis gives a per-sweep BlockBP complexity of

$T_A$5

for a block with $T_A$6 tensors and $T_A$7 boundary messages, and with multithreading reduces the effective per-iteration time to

$T_A$8

with memory

$T_A$9

and typical convergence in $A$0–$A$1 iterations (Gutman, 2 Mar 2026). These formulas again underscore that the method is heavier than ordinary BP but still structured as a message-passing algorithm with natural parallel decomposition.

Empirically, the 2024 surface-code paper reports simulations for perfect-measurement surface codes with depolarizing noise

$A$2

for $A$3, distances $A$4, and simulation parameters $A$5, $A$6, max-iter $A$7, $A$8, $A$9, and $N_A$0 (Kaufmann et al., 2024). It reports that for $N_A$1 all BlockBP variants are nearly indistinguishable from the bMPS decoder, and that the practical “usable distance” depends strongly on $N_A$2: $N_A$3 are good up to about $N_A$4, $N_A$5 up to about $N_A$6, and $N_A$7 up to about $N_A$8 (Kaufmann et al., 2024). The paper’s central empirical claim is that over a substantial range of $N_A$9 and $A$0, BlockBP achieves a logical error probability lower than MWPM, sometimes by more than an order of magnitude (Kaufmann et al., 2024).

The many-body literature reports a similar middle-ground profile. The 2023 paper states that BlockBP significantly outperforms plain BP or simple update because it captures intra-block loops exactly, and reaches energies and observables comparable to bMPS or CTM away from criticality (Guo et al., 2023). For finite transverse Ising and Heisenberg models, BlockBP energies closely match bMPS full-update energies, while two-site reduced density matrices agree extremely well away from criticality and degrade only near the critical region (Guo et al., 2023). For infinite systems, the method works for both finite and infinite lattices, accommodates different unit cells, and shows accuracy on par with state-of-the-art results in the cited benchmarks (Guo et al., 2023).

The main limitations are consistent across papers. First, the environment is represented by several separate MPS messages, so entanglement between different block faces is broken (Gutman, 2 Mar 2026). Second, accuracy degrades as correlation length grows, especially near critical points or strongly entangled ground states, where larger blocks and larger bond dimensions are required (Guo et al., 2023, Gutman, 2 Mar 2026). Third, although BlockBP is more accurate than ordinary BP, it is more expensive because messages are MPSs rather than matrices and every message update requires a nontrivial block contraction (Gutman, 2 Mar 2026).

A common misconception is that BlockBP is merely ordinary BP with a larger local tensor. The cited papers reject that simplification. The algorithm’s distinctive content lies not only in grouping tensors into blocks but also in representing block-boundary messages as compressed MPS objects and using approximate internal block contractions to make those messages tractable (Kaufmann et al., 2024, Gutman, 2 Mar 2026). Another misconception is that BlockBP is simply a surface-code BP decoder. In the surface-code setting, it is instead a tensor-network contraction algorithm inserted into a degeneracy-aware decoder that compares logical-coset probabilities (Kaufmann et al., 2024).

Overall, BlockBP occupies an intermediate position between ordinary BP and full tensor-network contraction. It is more accurate than BP because short loops inside blocks are treated more accurately, cheaper and more parallel-friendly than full global contraction, and flexible enough to be used both as a many-body contraction method and as the core inference engine in approximate degenerate quantum maximum-likelihood decoding (Guo et al., 2023, Kaufmann et al., 2024, Hack et al., 2024).