Branch-and-Bound Tensor Networks for Exact Ground-State Characterization

TL;DR

The Branch-and-Bound Tensor Network (BBTN) method is introduced, which seamlessly integrates the adaptive search framework of branch-and-bound with the efficient contraction of tropical tensor networks, significantly extending the reach of exact algorithms.

Abstract

Characterizing the ground-state properties of disordered systems, such as spin glasses and combinatorial optimization problems, is fundamental to science and engineering. However, computing exact ground states and counting their degeneracies are generally NP-hard and #P-hard problems, respectively, posing a formidable challenge for exact algorithms. Recently, Tensor Networks methods, which utilize high-dimensional linear algebra and achieve massive hardware parallelization, have emerged as a rapidly developing paradigm for efficiently solving these tasks. Despite their success, these methods are fundamentally constrained by the exponential growth of space complexity, which severely limits their scalability. To address this bottleneck, we introduce the Branch-and-Bound Tensor Network (BBTN) method, which seamlessly integrates the adaptive search framework of branch-and-bound with the efficient contraction of tropical tensor networks, significantly extending the reach of exact algorithms. We show that BBTN significantly surpasses existing state-of-the-art solvers, setting new benchmarks for exact computation. It pushes the boundaries of tractability to previously unreachable scales, enabling exact ground-state counting for $\pm J$ spin glasses up to $64 \times 64$ and solving Maximum Independent Set problems on King's subgraphs up to $100 \times 100$. For hard instances, BBTN dramatically reduces the computational cost of standard Tropical Tensor Networks, compressing years of runtime into minutes. Furthermore, it outperforms leading integer-programming solvers by over 30$\times$, establishing a versatile and scalable framework for solving hard problems in statistical physics and combinatorial optimization.

Figures (3)

• Figure 1: Schematic comparison of slicing and branch-and-bound tensor network (BBTN) methods. (a) Tensor network decomposition process. Slicing (left) exhaustively fixes a precomputed set of $n_f$ variables, generating $2^{n_f}$ leaf sub-TNs satisfying memory constraints (green nodes). BBTN (right) employs a branch-and-bound framework with pruning and online branching, producing an unbalanced tree with substantially fewer leaf sub-TNs. Dashed arrows show sub-TNs pruned before branching and thus never generated. (b) Single-step comparison. Slicing (left) fixes one variable per step, generating two sub-TNs. BBTN (right) examines multiple variables, prunes infeasible or suboptimal configurations, and generates an adaptive number of branches with different subsets of fixed variables.
• Figure 2: (Top) Performance comparison of BBTN, tropical-TN with and without slicing, and vanilla branch-and-bound methods (shown in the inset) on ground-state counting for spin glasses on $N\times N$ 2D lattices ($J=\pm1,h=0.5$). Averages for the solid dots are computed over all 10 instances. Tensor network runtimes are calibrated from theoretical time complexity and peak FLOPS of NVIDIA A100 GPU. The time reference line in the inset indicates that both methods have actual runtimes on the order of seconds. (Bottom) Performance of BBTN and slicing for ground-state counting on four problem classes: spin glasses ($J=\pm1,h=0.5$) on random regular graphs ($n=600,d=3$) and on an $8 \times 8 \times 8$ 3D lattice, MIS on RKSG ($n=60$, filling$=0.8$), and MWIS on RKSG ($n=60$, filling$=0.8$, with weights uniformly sampled from integers 1 to 10). Bars denote mean runtimes over 10 instances per class, with error bars spanning the min--max across instances.
• Figure 3: (Top) Performance comparison of BBTN, tropical-TN with and without slicing on optimal solution computation for MIS problems on $N\times N$ RKSG (filling 0.8). Averages for the solid dots are computed over all 10 instances. For BBTN, hollow dots show averages over only the instances solvable in time (4/10 for $N=90$ and 2/10 for $N=100$), where the scaling curves are fits to the solid dots. (Bottom) Runtime comparison of BBTN, slicing, and SCIP. We benchmark on two problem classes: MIS on RKSG and MWIS on MKSG. Specifically, for slicing, we contract a single slice to estimate total runtime, as all slices are identical.