Decision Diagram Global Optimization

• Decision diagram-based global optimization is a framework that encodes feasible sets as layered directed acyclic graphs to represent assignments and partial solutions.
• It leverages exact, relaxed, and restricted diagrams to deliver both primal and dual bounds in branch-and-bound search while managing computational trade-offs.
• Recent innovations such as peel-and-bound, caching, and learning-based variable ordering substantially reduce computation and strengthen bound quality in complex problems.

Decision diagram-based global optimization denotes a family of methods in which feasible sets, relaxations, or subproblem state spaces are represented by decision diagrams (DDs): layered directed acyclic graphs whose root-to-terminal paths encode assignments or partial solutions. In discrete optimization, DDs serve simultaneously as compact state-space models, shortest- or longest-path optimization objects, and extended formulations that can yield primal and dual bounds inside branch-and-bound. More recent work extends the same graphical logic to constrained shortest-path reformulations for two-stage optimization and to general mixed-integer nonlinear programming (MINLP) through DD-induced convexification, cutting planes, and spatial branch-and-bound (Castro et al., 2022, Davarnia et al., 2024).

1. Representational basis

A DD is organized in layers, typically with one layer per variable in a fixed ordering. Nodes correspond to states or partial solutions, and arcs correspond to variable-value assignments or state transitions. This construction is closely aligned with dynamic programming: a recursive model can be “unwrapped” into a layered graph in which each root-to-terminal path represents one candidate solution, and arc costs accumulate the objective value. In multivalued decision diagrams (MDDs), arc labels may take values from nonbinary domains; this is the dominant representation in recent discrete global optimization work (Castro et al., 2022, Rudich et al., 2022).

Three representational regimes are standard.

Diagram type	Relation to feasible set	Optimization role
Exact DD	Encodes the solution set exactly	Exact optimization, feasibility checking, post-optimal analysis
Relaxed DD	Over-approximates the feasible set	Dual bound
Restricted DD	Under-approximates the feasible set	Primal bound

The exact/approximate distinction is fundamental. Exact DDs support direct optimization over the represented set. Approximate DDs exist because exact diagrams may be exponential in the number of variables, so practical methods impose width limits and accept either over-approximation or under-approximation. A recurrent misconception is that DDs are uniformly compact representations; the survey literature instead emphasizes that scalability is highly problem-dependent and that approximate DDs are a response to worst-case exponential growth (Castro et al., 2022).

For exact DDs, the network-flow reformulation is central. If $D=(N,A)$ is a DD with arc-flow variables $y_a$, then the standard flow-balance and variable-linking constraints define a polyhedron $NF(D)$ whose projection onto the original variables satisfies

$$\operatorname{proj}_x(NF(D)) = \operatorname{conv}(X),$$

where $X$ is the encoded feasible set. This observation explains why DDs function both as combinatorial search objects and as convexification devices in mathematical programming (Castro et al., 2022).

2. Bounding and search in discrete global optimization

The most developed DD-based global optimization paradigm is branch-and-bound driven by bounded-width decision diagrams derived from a dynamic programming formulation. In this framework, a restricted DD yields a feasible solution and hence a primal bound, while a relaxed DD yields a dual bound. For maximization, the relaxed DD provides an upper bound and the restricted DD a lower bound; for minimization, the direction reverses, so relaxed DDs provide lower bounds and restricted DDs feasible upper bounds. The bound is obtained by solving a shortest- or longest-path problem in the diagram, depending on objective sense (Castro et al., 2022, Rudich et al., 2023).

The branch-and-bound algorithm based on DDs introduced in earlier work and refined subsequently is explicitly state-centric rather than variable-centric. Each node in the search corresponds to a subproblem induced by the underlying dynamic program, and bounded-width DDs are compiled to provide lower and upper bounds for that subproblem. Eventually, every part of the search space is either explored or pruned, which certifies optimality. This differs from conventional mixed-integer programming branch-and-bound in that overlapping dynamic programming states arise naturally, creating both opportunities for compression and risks of redundant computation (Coppé et al., 2022).

Width control is the principal algorithmic trade-off. Wider DDs generally produce stronger bounds, because fewer merges or deletions are needed, but construction cost increases rapidly. The resulting tension—bound strength versus compilation cost—is the organizing issue behind much of the recent literature on DD-based global optimization (Rudich et al., 2022, Rudich et al., 2023).

3. Peel-and-bound and the reuse of relaxed diagrams

Peel-and-bound (PnB) addresses the main inefficiency of standard DD-based branch-and-bound: the repeated reconstruction of similar relaxed diagrams for closely related subproblems. Inspired by warm-start techniques in conventional optimization, PnB maintains a queue of relaxed DDs, selects an exact node $u$ in a current diagram $\mathscr{D}$, peels the subgraph induced by $u$, and uses that peeled subdiagram as the initial object for the next relaxation rather than rebuilding from a width-one diagram. The subsequent refinement performs filtering and node splitting only where needed to reach the target width $w_m$ (Rudich et al., 2022).

The peeling step is not merely a graph extraction. It copies the subgraph rooted at the selected exact node, filters infeasible or inconsistent arcs under the subproblem’s added constraints, and preserves feasible paths through the subproblem. In the original formulation, the procedure was instantiated for the sequence ordering problem (SOP), where the relaxed and restricted DDs follow the construction of Cire and van Hoeve (2013), and node-selection heuristics such as choosing the last exact node on the shortest path were used to guide peeling (Rudich et al., 2022).

Its computational significance is explicit in the complexity expression. If $\alpha$ is the fraction of nodes peeled, the time per iteration is

$y_a$0

which is substantially smaller than full reconstruction when reuse is extensive. This formalizes the intuition that the benefit of PnB grows with structural overlap among subproblems (Rudich et al., 2022).

The extended PnB framework adds several ingredients: methods for using relaxed DDs to improve solutions found by restricted DDs, heuristic choices for parallelization, hyper-optimization for sequencing problems, and a generalized implementation intended to handle any discrete optimization problem. It also integrates rough relaxed bounds for more aggressive pruning and discusses node-selection heuristics including “frontier,” “maximal,” and “last exact node” (Rudich et al., 2023).

Empirically, the method was evaluated on 41 SOP instances from TSPLIB and on 467 traveling salesman problem with time windows (TSPTW) instances. On SOP at width $y_a$1, PnB had better lower bounds in 34 of 35 unsolved instances relative to standard DD-based branch-and-bound, improving the relaxed bound by 545% on average; problems were closed 580% faster in median, and queue size was reduced by 308%. On TSPTW, PnB outperformed ddo, closed 65% more instances to optimality than the single-threaded baseline, and closed 15 open benchmark instances. On the makespan variant, it closed 94% of instances unseeded and 97% with best-known-solution seeding (Rudich et al., 2023).

A plausible implication is that PnB changes the effective meaning of width selection: wider DDs become computationally viable not because width itself becomes cheaper, but because the marginal cost of reusing previously compiled structure can dominate the cost of rebuilding from scratch.

4. Caching, dominance, and suboptimality detection

A distinct acceleration line exploits the fact that DD-based branch-and-bound over dynamic programming models repeatedly encounters the same state via different search paths. The caching method of Bergman-style DD branch-and-bound with dominance and suboptimality detection stores, for each dynamic programming state, an expansion threshold that determines whether further compilation from that state can still improve the search (Coppé et al., 2022).

If a node $y_a$2 has dynamic programming state $y_a$3 and path value $y_a$4, expansion is skipped whenever

$y_a$5

where $y_a$6 is the cached threshold for that state. The threshold combines two components. The dominance threshold records the best partial value already observed for the state; any weaker partial solution is dominated. The pruning threshold incorporates incumbent-based suboptimality detection using filtering inequalities and upper bounds on completions. Their combination is

$y_a$7

with $y_a$8 derived from dominance relations among partial solutions and $y_a$9 derived from pruning by incumbent-based bounds (Coppé et al., 2022).

This mechanism is integrated at two levels. During DD compilation, nodes whose state-value pair fails the threshold test are not expanded. At branch-and-bound node selection, the same logic can skip subproblems before diagram construction proceeds further. The cache is implemented as a hash table storing $NF(D)$0 for each state, where the flag distinguishes whether expansion at the threshold value has already occurred (Coppé et al., 2022).

Computationally, the effect is to reduce repeated expansions in both restricted and relaxed DDs, preserve best-first search, and make narrower diagrams more competitive because redundant work is eliminated. The paper reports significantly more solved instances, less time, and fewer expanded nodes across TSPTW, the pigment sequencing problem, and the single-row facility layout problem. The same study also notes the principal limitation: cache size can approach the state-space size, though in practice the memory trade-off was often offset by smaller DDs and fewer expansions. It further observes that static variable orderings benefit most, whereas dynamic orderings reduce overlap and therefore reduce caching benefits (Coppé et al., 2022).

5. Graphical reformulations for structured two-stage problems and MINLPs

The DD viewpoint extends beyond standard discrete branch-and-bound by treating optimization problems as constrained shortest-path problems over a DD network. For structured two-stage optimization, the key idea is to encode the follower or second-stage feasible set as a DD and represent the leader’s or uncertainty-induced conditions either as side constraints in the network-flow model or as extra state variables in a dynamic programming recursion (Lozano et al., 2022).

For two-stage problems with interdiction constraints, the method models the second-stage feasible set as a DD and encodes interdiction directly on arcs through indicator functions, yielding a single-level network-flow reformulation. For classical robust optimization, the DD network is paired with an iterative identification of label variables akin to an L-shaped method: one solves a constrained shortest-path problem over the current DD model, identifies violating scenarios through separation, augments the state space, and repeats. The computational study reports considerable improvements relative to general methods, including average solution times reduced by over an order of magnitude on competitive project selection and a DD-based robust TSPTW method that solved 159 of 160 instances, often in less than one tenth of the time of a MILP cutting-plane approach (Lozano et al., 2022).

A broader extension appears in the DD-based graphical framework for global MINLP. There, each nonlinear constraint, or intersection of constraints, is reformulated as a DD whose paths encode assignments over partitioned domains. For separable constraints, nodes can represent cumulative state such as partial sums; for nonseparable constraints, state values depend on assignments along the path. Convexification is obtained from the convex hull of the DD solution set, strengthened by arc reduction results that preserve the hull while keeping only min/max label arcs between node pairs. To control size, relaxed DDs are formed by node merging under a width threshold $NF(D)$1, producing valid outer approximations (Davarnia et al., 2024).

Cutting planes are generated from a flow-based linear model of the DD, using either a dual separation oracle or a derivative-free subgradient algorithm that relies on longest-path computations in the graph. These cuts define linear outer approximations that are then embedded in a spatial branch-and-bound scheme. Under consistency of the lower-bound rules used in DD state calculations and lower semicontinuity of the constraints, nested domain refinement drives the DD relaxation toward the pointwise limit, providing convergence guarantees. The framework is presented as addressing a longstanding gap in the DD literature by offering a general-purpose DD-based approach for general MINLPs, and it is applied to difficult unsolved MINLP Library instances that are otherwise inadmissible for state-of-the-art global solvers such as BARON or SCIP (Davarnia et al., 2024).

6. Variable ordering, learning, and open research directions

Variable ordering is one of the most consequential design choices in DD-based global optimization. The order of variables determines the layering structure and strongly affects whether merging or pruning will preserve a strong relaxation. The literature emphasizes that finding an optimal ordering is NP-hard, and even improving an ordering is NP-complete in the contexts studied. Poor orderings can create early state collisions that weaken relaxed bounds or discard critical feasible structure in restricted diagrams (Cappart et al., 2018).

One response is to learn the ordering policy directly. In the deep reinforcement learning approach of Cappart et al., DD construction is cast as a Markov decision process whose state consists of the current ordered variable list and the partially constructed DD, and whose action selects the next variable. For relaxed DDs, the reward is the negative change in the upper bound; for restricted DDs, it is the improvement in the lower bound. Fitted Q-learning with a neural approximation of $NF(D)$2, structure2vec graph embeddings, experience replay, and adaptive $NF(D)$3-greedy exploration is then used to learn orderings that tighten bounds. On synthetic Maximum Independent Set and Maximum Cut instances drawn from known distributions, the learned policies generally outperformed random orderings and standard heuristics for both relaxed and restricted DDs. The same study reports that models should be trained separately for relaxed and restricted DDs, and that generalization is best when test instances resemble the training distribution (Cappart et al., 2018).

The broader research agenda remains defined by the survey literature. Principal challenges include exponential growth of exact DDs, implementation complexity, the sensitivity of approximation quality to width and ordering, limited theory for continuous and mixed-integer sets, and the absence of mature software infrastructure comparable to LP, MIP, or CP ecosystems. Corresponding directions include hybrid paradigms that use DDs selectively inside larger solvers, coordination across multiple smaller DDs, learning-based variable ordering and construction policies, stronger propagation over approximate DDs, and more systematic support for continuous or mixed discrete-continuous models (Castro et al., 2022).

Taken together, these strands show that decision diagram-based global optimization is not a single algorithm but a graphical optimization paradigm. Its core objects—exact, relaxed, and restricted DDs—support path optimization, convexification, and search; its main algorithmic advances have centered on reusing compiled structure, exploiting dynamic programming overlap, and importing ideas from warm-starting, cutting planes, and learning. The resulting methods are particularly effective when problem structure can be encoded as a layered state-transition graph and when the quality-cost trade-off induced by width can be managed rather than eliminated.