Higher-order Binary Optimization Problems

• HOBO is a generalization of QUBO that permits arbitrary degree monomials to directly encode higher-order, k-local interactions in binary optimization.
• The framework enables direct modeling of complex combinatorial structures and resource constraints without the overhead of auxiliary variables.
• Innovative use of tensor-network contractions and quantum circuit techniques enhances solver efficiency and scalability for HOBO instances.

Higher-order Binary Optimization (HOBO) problems are a fundamental generalization of the ubiquitous Quadratic Unconstrained Binary Optimization (QUBO) formalism. Unlike QUBO, which restricts interaction terms to at most quadratic (pairwise) products of binary variables, HOBO allows cost functions to include monomials of arbitrary degree. This native support for cubic, quartic, and higher-order k-local terms enables direct modeling of combinatorial structures, resource conflicts, and nonlinear penalties that would require significant overhead if forced into quadratic form. HOBO arises naturally in quantum computing, nonlinear integer programming, and applications such as scheduling, constraint satisfaction, portfolio optimization, resource allocation, and data compression.

1. Mathematical Formalism and Problem Structure

HOBO formalizes the task of minimizing a binary polynomial objective of degree $d$: $$f(x) = \sum_{i} a_i x_i + \sum_{i<j} a_{ij} x_i x_j + \sum_{i<j<k} a_{ijk} x_i x_j x_k + ... + \sum_{i_1<\cdots<i_d} a_{i_1 \ldots i_d}x_{i_1}\cdots x_{i_d}$$ where $x = (x_1, ..., x_n)$ with $x_i \in \{0,1\}$ and the $a_{i_1...i_p}$ specify coefficients for $p$-body interactions up to some order $d$ (Minato, 2024). The compact tensor notation is standard: $$f(x) = \sum_{p=1}^{d} \sum_{1 \leq i_1 < \cdots < i_p \leq n} a_{i_1...i_p} x_{i_1} \cdots x_{i_p}$$ This generality allows encoding of constraints (both equality and inequality) as higher-order penalty monomials, and admits integer variable encodings with domain constraints enforced by high-degree terms (Minato, 16 Jan 2025, Zaborniak et al., 22 Apr 2026). In the Ising gauge, $x_i$ is mapped to $s_i \in \{-1, +1\}$, and the HOBO Hamiltonian becomes a sum of multilinear spin couplings. The unconstrained variant, HUBO, is often used in quantum algorithm literature.

2. Motivation and Limitations of QUBO Locality Reduction

Quadratic solvers (QUBO and 2-local Ising machines) are limited to pairwise terms. When a problem requires cubic or higher-order interactions (e.g., resource-blocking constraints, k-SAT, or multi-way matchings), standard practice is to introduce auxiliary variables to reduce degree:

• Each $$f(x) = \sum_{i} a_i x_i + \sum_{i<j} a_{ij} x_i x_j + \sum_{i<j<k} a_{ijk} x_i x_j x_k + ... + \sum_{i_1<\cdots<i_d} a_{i_1 \ldots i_d}x_{i_1}\cdots x_{i_d}$$0-body term ($$f(x) = \sum_{i} a_i x_i + \sum_{i<j} a_{ij} x_i x_j + \sum_{i<j<k} a_{ijk} x_i x_j x_k + ... + \sum_{i_1<\cdots<i_d} a_{i_1 \ldots i_d}x_{i_1}\cdots x_{i_d}$$1) is replaced with $$f(x) = \sum_{i} a_i x_i + \sum_{i<j} a_{ij} x_i x_j + \sum_{i<j<k} a_{ijk} x_i x_j x_k + ... + \sum_{i_1<\cdots<i_d} a_{i_1 \ldots i_d}x_{i_1}\cdots x_{i_d}$$2 ancilla variables, implementing substitutions such as $$f(x) = \sum_{i} a_i x_i + \sum_{i<j} a_{ij} x_i x_j + \sum_{i<j<k} a_{ijk} x_i x_j x_k + ... + \sum_{i_1<\cdots<i_d} a_{i_1 \ldots i_d}x_{i_1}\cdots x_{i_d}$$3, $$f(x) = \sum_{i} a_i x_i + \sum_{i<j} a_{ij} x_i x_j + \sum_{i<j<k} a_{ijk} x_i x_j x_k + ... + \sum_{i_1<\cdots<i_d} a_{i_1 \ldots i_d}x_{i_1}\cdots x_{i_d}$$4, together with constraint-penalty polynomials (Rosenberg gadgets).
• For Ising variables, enforcing $$f(x) = \sum_{i} a_i x_i + \sum_{i<j} a_{ij} x_i x_j + \sum_{i<j<k} a_{ijk} x_i x_j x_k + ... + \sum_{i_1<\cdots<i_d} a_{i_1 \ldots i_d}x_{i_1}\cdots x_{i_d}$$5 requires at least two penalty ancillae (Mandal et al., 2020).

This reduction induces significant overhead: the variable count grows linearly (or worse) with the number and degree of high-order terms, and the complex penalty energy landscape slows convergence and increases embedding complexity for quantum hardware (Valiante et al., 2020, Domino et al., 2021). Empirical studies show that “locality reduction” to QUBO form renders previously tractable native HOBO instances dramatically more difficult, as measured by solver time, solution quality, and entropic hardness metrics.

Direct HOBO modeling avoids these complications, supporting more efficient mappings, especially on hardware or algorithmic platforms that natively handle k-local cost terms (Bybee et al., 2022, Minato, 2024).

3. Tensor-Network and Numerical Methods for HOBO

A key advancement is the mapping of HOBO cost functions to tensor networks, enabling efficient contraction-based energy evaluations and optimization. Each $$f(x) = \sum_{i} a_i x_i + \sum_{i<j} a_{ij} x_i x_j + \sum_{i<j<k} a_{ijk} x_i x_j x_k + ... + \sum_{i_1<\cdots<i_d} a_{i_1 \ldots i_d}x_{i_1}\cdots x_{i_d}$$6-body term defines a tensor $$f(x) = \sum_{i} a_i x_i + \sum_{i<j} a_{ij} x_i x_j + \sum_{i<j<k} a_{ijk} x_i x_j x_k + ... + \sum_{i_1<\cdots<i_d} a_{i_1 \ldots i_d}x_{i_1}\cdots x_{i_d}$$7:

• $$f(x) = \sum_{i} a_i x_i + \sum_{i<j} a_{ij} x_i x_j + \sum_{i<j<k} a_{ijk} x_i x_j x_k + ... + \sum_{i_1<\cdots<i_d} a_{i_1 \ldots i_d}x_{i_1}\cdots x_{i_d}$$8 (vector for linear terms)
• $$f(x) = \sum_{i} a_i x_i + \sum_{i<j} a_{ij} x_i x_j + \sum_{i<j<k} a_{ijk} x_i x_j x_k + ... + \sum_{i_1<\cdots<i_d} a_{i_1 \ldots i_d}x_{i_1}\cdots x_{i_d}$$9 (matrix for quadratic terms)
• $x = (x_1, ..., x_n)$0 for $x = (x_1, ..., x_n)$1

The full cost is the contraction of this tensor network with the binary variable vector $x = (x_1, ..., x_n)$2: $x = (x_1, ..., x_n)$3 Efficient evaluation leverages PyTorch einsum for batched contraction, while tensor-train (TT) or Tucker decompositions provide SVD-based compression, reducing the computational cost from $x = (x_1, ..., x_n)$4 to $x = (x_1, ..., x_n)$5 for rank-$x = (x_1, ..., x_n)$6 truncations (Minato, 2024, Yasuda et al., 2024).

Simulated annealing is applied natively on the tensor representation; only local effective cost changes ($x = (x_1, ..., x_n)$7) are recomputed upon variable flips, and SVD compression enables scaling to substantially larger, higher-order HOBO instances. GPU and multi-GPU strategies offer further acceleration.

Empirical demonstrations confirm the approach's accuracy and efficiency for small cubic and higher-order test cases. For higher-order problems such as searching Pythagorean triples or solving low-bit TSPs, the HOBO tensor methods consistently require fewer variables and computational resources compared to equivalent QUBO mappings (Yasuda et al., 2024, Yasuda et al., 2024).

4. Quantum Computational Approaches and Circuit Models

Native HOBO instances are significant in quantum optimization, where many-body (k-local) Hamiltonians map directly to variational, adiabatic, or annealing algorithms. The cost Hamiltonian takes the form: $x = (x_1, ..., x_n)$8 with $x = (x_1, ..., x_n)$9 the Pauli-Z on qubit $x_i \in \{0,1\}$0 (Sachdeva et al., 2024, Romero et al., 2024, Verchère et al., 2023, Zaborniak et al., 22 Apr 2026).

Key algorithmic themes include:

• Counterdiabatic digitized quantum optimization (BF-DCQO), with warm-start bias fields updated via measurement, and efficient decomposition of k-body Pauli terms for gate-based devices (Romero et al., 2024).
• QAOA for HOBO, where each k-body term is implemented as a sequence of CNOTs and a single multi-qubit RZ rotation or via minimal ancilla decompositions; circuit compilation focuses on reducing depth and the number of two-qubit gates, often employing combinatorial “routing” to optimize monomial placement (Verchère et al., 2023).
• Generative model-based circuit synthesis (QAOA-GPT), where a transformer learns to output optimized adaptive Quantum Approximate Optimization Algorithm (QAOA) circuits for HOBO instances, bypassing classical parameter searches and achieving $x_i \in \{0,1\}$1 approximation ratios (Sunny et al., 10 Nov 2025).
• Specialized quantum annealing architectures for k-local problems, such as 2D layouts encoding all quartic couplings through gauge-invariant subspaces with polynomial overhead (Tang et al., 2016).

Benchmarking on 127-qubit gate-model IBM hardware has shown that direct HOBO circuit ansätze, combined with classical post-processing and error mitigation, outperform annealer-based QUBO reductions and local heuristics, both in success probability and solution fidelity (Sachdeva et al., 2024).

5. Applications, Constraint Modeling, and Encodings

HOBO is especially natural in domains where constraints or cost terms are inherently higher-order:

• Scheduling and rescheduling with intricate precedence, blocking, or headway constraints (e.g., railway systems with cubic penalties for forbidden orderings) (Domino et al., 2021).
• Integer programming with direct binary encoding and inequality constraints expressed as high-order bitmask polynomials, avoiding slack variable explosion (Minato, 16 Jan 2025).
• Graph partitioning and coloring: modern HUBO encodings combine binary logarithmic variable mappings with lexicographic penalty hierarchies and Rosenberg quadratization, drastically reducing qubit and gate counts compared to one-hot encodings for large $x_i \in \{0,1\}$2 (Zaborniak et al., 22 Apr 2026).
• Portfolio optimization incorporating higher moments (skewness, kurtosis), yielding cubic and quartic objective terms and testing quantum advantage over classical baselines (Uotila et al., 1 Sep 2025).
• Resource allocation and wireless phase optimization, where HOBO frameworks with inequality constraints outperform penalty-based QUBO formulations (Zheng et al., 24 Sep 2025).

Penalty-free HOBO designs exploit problem structures and interpretation of output strings (e.g., traveling salesman problem or sequencing problems), achieving resource savings by ensuring that all samples correspond to valid solutions and entirely eliminating penalty terms (Goldsmith et al., 2024).

6. Empirical Hardness, Scalability, and Solver Design

Direct HOBO formulations maintain native problem sparsity and interaction locality, which empirically results in more tractable optimization landscapes compared to QUBO reductions. Work comparing parallel tempering and simulated annealing on HOBO vs. reduced QUBO shows that the 2-local reduction can increase resource requirements and computational hardness by orders of magnitude—both in variable count and the complexity of energy landscapes as measured by entropic family size and time-to-solution (Valiante et al., 2020).

Modern solver approaches for HOBO combine:

• Tensor contraction and SVD-based compression for polynomial evaluation and batch optimization (classic and quantum-inspired) (Minato, 2024, Yasuda et al., 2024).
• Digitized counterdiabatic quantum driving, offering substantial hardware efficiency for sparse high-order Hamiltonians, and integrating with branch-and-bound algorithms for effective global search (Simen et al., 21 Apr 2025, Romero et al., 2024).
• Advanced constraint modeling: replacing slack-variable penalty quadratization with high-order bitwise inequalities directly, resulting in more compact and efficient encodings (Minato, 16 Jan 2025).

In practice, the maximum tractable problem size is currently determined by the order of interactions, tensor path optimization, SVD rank truncation, and the capabilities of underlying hardware (hardware-native k-local support or classical memory bandwidth).

7. Current Challenges and Ongoing Directions

Challenges for HOBO research involve:

• Design of efficient quantum circuits for k-local terms that minimize ancillary qubits and gate overhead, while maintaining noise resilience in NISQ and noisy devices (Verchère et al., 2023, Tang et al., 2016).
• Adaptive handling of constraints in dense higher-order polynomials, including efficient branch-and-bound relaxations for nonconvex objectives (Simen et al., 21 Apr 2025).
• Integration of tensor-network contractions and hybrid classical–quantum solver loops for high-dimensional problems (Minato, 2024).
• Generalization of penalty-free and feasibility-preserving encodings to a broader class of combinatorial problems, aiming for more efficient quantum resource utilization (Goldsmith et al., 2024).

A plausible implication is that future quantum and quantum-inspired hardware with native support for k-local interactions, paired with scalable tensor optimization and generative parameter prediction, will further extend the practical reach of HOBO optimization far beyond that of traditional QUBO-based approaches.

---

Key references: (Minato, 2024, Yasuda et al., 2024, Valiante et al., 2020, Domino et al., 2021, Bybee et al., 2022, Romero et al., 2024, Zheng et al., 24 Sep 2025, Minato, 16 Jan 2025, Verchère et al., 2023, Zaborniak et al., 22 Apr 2026, Sachdeva et al., 2024, Tang et al., 2016, Simen et al., 21 Apr 2025, Sunny et al., 10 Nov 2025, Uotila et al., 1 Sep 2025, Goldsmith et al., 2024, Yasuda et al., 2024).