Relax-and-Cut Optimization Framework

• Relax-and-Cut is an optimization framework that begins with a tractable relaxed model and iteratively strengthens it using valid cuts to restore original structure.
• It bridges classical branch-and-cut methods with modern relax-optimize-recover pipelines applied in graph partitioning, nonconvex optimization, and MILP problems.
• The framework enhances computational efficiency by balancing relaxation strengthening and branching decisions, leading to improved solution quality in large-scale applications.

Searching arXiv for the cited framework papers and closely related uses of “relax-and-cut”. Searching arXiv for the ROS paper. Searching arXiv for the abstract branch-and-cut model. Searching arXiv for dynamic relaxation and cut-generation frameworks in optimization. A relax-and-cut framework denotes a family of optimization procedures that begin with a tractable relaxation of a hard discrete or nonconvex model and then restore, tighten, or recover the original structure by additional operations. In the strict operations-research sense, the term is closest to branch-and-cut, where a relaxation is progressively strengthened by cuts inside a search tree (Kazachkov et al., 2021). In a broader contemporary usage, the label is also applied to relax-optimize-recover pipelines for graph partitioning and related problems, although several authors explicitly distinguish such methods from classical cutting-plane or branch-and-cut algorithms (Qiu et al., 2024).

1. Strict and broad senses of the framework

In mathematical optimization, a relax-and-cut framework is most naturally understood as a procedure that starts from a relaxation, strengthens that relaxation by valid inequalities or related cut-generation steps, and coordinates those strengthening decisions with combinatorial search. The abstract branch-and-cut model formalizes exactly this interaction between bound improvement, node processing cost, and search-tree structure (Kazachkov et al., 2021).

A broader usage has emerged in graph optimization, differentiable optimization, and learning-to-optimize. There, “relax-and-cut” may denote a pipeline that relaxes a discrete assignment space to a continuous domain, optimizes the relaxed problem, and then recovers a discrete cut by rounding, sampling, or decoding. The ROS framework for Max-$k$-Cut is explicitly described as being “very close in spirit to a relax-and-cut or relax-and-round framework,” while also being “not branch-and-cut in the classical operations-research sense” because it has no branch-and-bound tree, no cutting planes, and no exact dual bounding mechanism (Qiu et al., 2024).

The distinction matters because several adjacent literatures use relaxation followed by randomized or deterministic recovery without cut generation in the polyhedral sense. The mechanism-design note “A Note on Relaxation and Rounding in Algorithmic Mechanism Design” is explicit on this point: it abstracts relaxation-and-rounding for truthful-in-expectation mechanisms, but it does not present cutting planes, constraint generation, or branch-and-cut (Fadaei, 2016).

2. Branch-and-cut as the classical formulation

The most formal abstract account is given by the branch-and-cut tree model. A tree $T$ has a node-labeling function

$\mathrm{gap}_T : V_T \to \mathbb{R}_{\ge 0},$

where $\mathrm{gap}_T(v)$ measures bound improvement at node $v$ relative to the root. The root satisfies

$\mathrm{gap}_T(v_0)=0.$

If a node has one child, it is a cut node with cut value $c_v\ge 0$, and

$\mathrm{gap}_T(v')=\mathrm{gap}_T(v)+c_v.$

If a node has two children, it is a branch node with gains $(\ell_v,r_v)$, and

$$\mathrm{gap}_T(v_1)=\mathrm{gap}_T(v)+\ell_v,\qquad \mathrm{gap}_T(v_2)=\mathrm{gap}_T(v)+r_v.$$

The tree proves a target bound $T$0 when every leaf satisfies $T$1 (Kazachkov et al., 2021).

This abstraction isolates the central relax-and-cut tradeoff. Cuts strengthen the current relaxation and improve the lower bound, but they can also make downstream node processing more expensive. To model that effect, the framework uses a nondecreasing time-function

$T$2

where $T$3 is the time to process a node inheriting $T$4 cuts along its root-to-node path. Total tree time is

$T$5

When $T$6, the objective reduces to tree size (Kazachkov et al., 2021).

The theory shows that cut placement is structurally delicate. For tree size, there exists an optimal tree in which all cuts lie on a path starting at the root. For running time, root cuts do not always suffice in general; however, when branching is symmetric, $T$7, there exists a time-minimal tree with only root cuts. The same model explains nonmonotonic cut effects: a small number of cuts may increase tree size, whereas a larger number may remove an entire branching layer and reduce the tree dramatically. With diminishing cut strength, the optimal strategy becomes a balance between cut-based strengthening and branching rather than an “all cuts first” rule (Kazachkov et al., 2021).

In this strict sense, a relax-and-cut framework is not merely “solve a relaxation and round.” It is a joint theory of relaxation strengthening, branching, and cost.

3. Relax-optimize-recover frameworks for graph cuts

The ROS framework for weighted Max-$T$8-Cut provides a representative broadened use of the term. The discrete problem is posed on an undirected graph

$T$9

with symmetric weight matrix $\mathrm{gap}_T : V_T \to \mathbb{R}_{\ge 0},$0, possibly with arbitrary edge signs, and assignment matrix $\mathrm{gap}_T : V_T \to \mathbb{R}_{\ge 0},$1 whose columns are one-hot vectors. After removing constants and negating the original cut objective, ROS uses the equivalent discrete trace formulation

$\mathrm{gap}_T : V_T \to \mathbb{R}_{\ge 0},$2

where

$\mathrm{gap}_T : V_T \to \mathbb{R}_{\ge 0},$3

The relaxation replaces one-hot columns by simplex-valued probability vectors: $\mathrm{gap}_T : V_T \to \mathbb{R}_{\ge 0},$4 leading to

$\mathrm{gap}_T : V_T \to \mathbb{R}_{\ge 0},$5

Because $\mathrm{gap}_T : V_T \to \mathbb{R}_{\ge 0},$6 is generally indefinite, this is not a convex SDP-style relaxation; it is a differentiable nonconvex continuous domain tailored to gradient-based optimization and softmax-output GNNs (Qiu et al., 2024).

ROS then applies a three-stage pipeline. First, it relaxes the discrete constraints to the simplex domain. Second, it optimizes the relaxed objective with a message-passing GNN trained without labels, using the continuous Max-$\mathrm{gap}_T : V_T \to \mathbb{R}_{\ge 0},$7-Cut objective itself as loss. Third, it maps the relaxed point $\mathrm{gap}_T : V_T \to \mathbb{R}_{\ge 0},$8 to a feasible cut by independent categorical sampling: $\mathrm{gap}_T : V_T \to \mathbb{R}_{\ge 0},$9 Running this sampling step $\mathrm{gap}_T(v)$0 times and keeping the best solution yields the final discrete cut; the experiments use $\mathrm{gap}_T(v)$1 (Qiu et al., 2024).

What makes ROS more than an ad hoc rounding heuristic is its explicit consistency theory. If $\mathrm{gap}_T(v)$2 is a globally optimal solution of the simplex relaxation, then every point in its support-based neighborhood has the same objective value. Independently of global optimality, the sampling stage preserves the relaxed objective in expectation: $\mathrm{gap}_T(v)$3 This establishes an expectation-level bridge between the relaxed and recovered objectives (Qiu et al., 2024).

At the same time, the paper is explicit about the framework’s limits. ROS is “close to a ‘relax-and-recover’ framework,” and “relax-and-cut style” is appropriate only in a broad sense: relax the combinatorial assignment, optimize in continuous space, then recover a cut. It is not branch-and-cut in the classical sense. Even so, the empirical performance is strong: the method scales to graphs with up to $\mathrm{gap}_T(v)$4 nodes in just a few seconds, solves large Gset instances such as G81 in $\mathrm{gap}_T(v)$5 s for $\mathrm{gap}_T(v)$6 and $\mathrm{gap}_T(v)$7 s for $\mathrm{gap}_T(v)$8, and generalizes from $\mathrm{gap}_T(v)$9 training graphs to out-of-distribution instances up to $v$0 (Qiu et al., 2024).

4. Cut generation as relaxation tightening in continuous and nonconvex optimization

A stricter relax-and-cut logic appears in continuous and mixed-integer nonconvex optimization, where cuts are literal convexifying or relaxation-tightening inequalities.

One example is the diagonal-perturbation framework for nonconvex quadratic optimization. The base problem is

$v$1

with indefinite $v$2. The framework constructs convex quadratic cutting surfaces by adaptive diagonal perturbations $v$3 satisfying $v$4. Each perturbation yields a valid convex inequality of the form

$v$5

where $v$6 and $v$7 are lower and upper envelopes for the one-dimensional quadratic terms. Separation reduces to a highly structured SDP-like problem with convex nonsmooth objective, solved by a specialized primal-barrier coordinate minimization algorithm. Computationally, the separation routine is at least an order of magnitude faster than interior-point SDP methods on problems up to a few hundred variables, and the resulting lower bounds are close to diagonal SDP bounds while being much faster on larger instances (Dong, 2014).

A second example is the dynamic relaxation framework for global ACOPF. After standard lifting in the branch-flow model, the remaining nonconvexity is the SOC-surface equality

$v$8

The paper starts from the SOCP relaxation

$v$9

and then tightens it with piecewise relaxations based on rotation-and-fold geometry. Two static formulations are introduced: Pyramidal Relaxation (PR) and Quasi-Pyramidal Relaxation (QPR). Their dynamic counterparts, DPR and DQPR, embed cut generation inside a branch-and-cut solver. When a candidate incumbent violates the target conic tolerance, the method adds inner cuts, and in DPR also outer cuts, only where needed. For any fixed depth $\mathrm{gap}_T(v_0)=0.$0, $\mathrm{gap}_T(v_0)=0.$1-DPR is equivalent to static $\mathrm{gap}_T(v_0)=0.$2-PR and $\mathrm{gap}_T(v_0)=0.$3-DQPR is equivalent to static $\mathrm{gap}_T(v_0)=0.$4-QPR. The error guarantees are explicit: $\mathrm{gap}_T(v_0)=0.$5 with $\mathrm{gap}_T(v_0)=0.$6. The purpose is exactness by progressive tightening rather than heuristic repair (Tang et al., 16 Jun 2025).

These frameworks exemplify the literal optimization meaning of relax-and-cut: start from a relaxation, separate violated strengthening inequalities, and solve the tightened model inside an exact global search process.

5. Temporal decomposition and dynamic security cuts in SCUC

The framework for temporal SCUC decomposition applies the same principle to a large-scale MILP with temporal coupling and $\mathrm{gap}_T(v_0)=0.$7 security constraints. The full SCUC model includes binary unit-commitment variables $\mathrm{gap}_T(v_0)=0.$8, generation outputs $\mathrm{gap}_T(v_0)=0.$9, ramping and minimum up/down constraints, and PTDF-based security inequalities

$c_v\ge 0$0

for all lines $c_v\ge 0$1, times $c_v\ge 0$2, and contingencies $c_v\ge 0$3 (Xiong et al., 28 Jul 2025).

The central temporal innovation is a four-region rolling decomposition. Previously fixed decisions form a fixed window $c_v\ge 0$4. Near-term periods form an integer window $c_v\ge 0$5, in which commitment variables remain binary. A future look-ahead region forms a relaxed window $c_v\ge 0$6, where the same commitment variables are retained but their integrality is relaxed to $c_v\ge 0$7. More distant periods are deferred entirely. The partially relaxed subproblem keeps exact integrality for $c_v\ge 0$8 and relaxes

$c_v\ge 0$9

This preserves immediate implementability while extending temporal look-ahead without incurring the full combinatorial burden of a longer exact horizon (Xiong et al., 28 Jul 2025).

The cutting component targets the network-security block. Instead of enumerating all contingency constraints up front, the method starts from $\mathrm{gap}_T(v')=\mathrm{gap}_T(v)+c_v.$0, omitting them initially. During branch-and-cut, each time an integer solution $\mathrm{gap}_T(v')=\mathrm{gap}_T(v)+c_v.$1 is found, the algorithm evaluates all omitted security constraints, identifies the violated set $\mathrm{gap}_T(v')=\mathrm{gap}_T(v)+c_v.$2, and adds those constraints via callback. If no omitted security constraint is violated, the incumbent is accepted. This avoids repeated full MILP re-solves and keeps the solver’s internal state intact (Xiong et al., 28 Jul 2025).

The framework optionally appends a Relaxation-Induced Neighborhood Search phase. After a feasible full-horizon solution $\mathrm{gap}_T(v')=\mathrm{gap}_T(v)+c_v.$3 is obtained, variables outside a selected time window are fixed to $\mathrm{gap}_T(v')=\mathrm{gap}_T(v)+c_v.$4, and the remaining neighborhood is re-optimized as an exact MIP. In the reported configuration, a 12-interval window advanced by 9 intervals reduces the average primal gap from $\mathrm{gap}_T(v')=\mathrm{gap}_T(v)+c_v.$5 to $\mathrm{gap}_T(v')=\mathrm{gap}_T(v)+c_v.$6 while keeping runtime at only $\mathrm{gap}_T(v')=\mathrm{gap}_T(v)+c_v.$7 of the Full+TF baseline (Xiong et al., 28 Jul 2025).

The computational results are large-scale and explicitly operational. On systems up to 13,659 buses, the method achieves optimality gaps below $\mathrm{gap}_T(v')=\mathrm{gap}_T(v)+c_v.$8 while requiring only $\mathrm{gap}_T(v')=\mathrm{gap}_T(v)+c_v.$9 of the computation time of monolithic Gurobi solutions. Relative to existing temporal decomposition, it reduces primal gaps by $(\ell_v,r_v)$0 and doubles solution speed (Xiong et al., 28 Jul 2025).

6. Adjacent frameworks, misconceptions, and conceptual extensions

One persistent misconception is to identify every relaxation-plus-recovery pipeline with relax-and-cut in the strict optimization sense. The literature considered here does not support that equation.

In mechanism design, the framework of Alaei and its later generalization via the interim relaxation are explicitly relaxation-and-rounding constructions. The relaxed object is an interim allocation rule feasible only in expectation; a two-level OCRS then restores ex-post feasibility while preserving a constant fraction of the relaxed value. This is a relax-and-round or relax-and-enforce-feasibility methodology, not a cutting-plane framework (Bhawalkar et al., 2024).

In graph machine learning and differentiable optimization, analogous broad uses recur. The MaxCut paper “A Scalable Lift-and-Project Differentiable Approach For the Maximum Cut Problem” is described as a differentiable relax-and-cut or lift-and-project framework: binary variables are relaxed to a box, optimized by projected gradient ascent, lifted to a higher-dimensional representation, and decoded by thresholding. Its novelty lies in continuous search, fixed-point analysis, and dimension alternation rather than in classical cut generation (Alkhouri et al., 23 Sep 2025). “Probabilistic Graph Cuts” likewise keeps the original cut semantics at the level of expected discrete cuts, replaces the intractable expectation by analytic hypergeometric upper bounds, and optimizes a penalized majorizer; the construction is mathematically close to a differentiable relax-and-cut scheme, but again the “cut” is the graph-partition objective rather than a branch-and-cut inequality (Ghriss, 4 Nov 2025).

The MMCP framework PIONEER makes the distinction even more explicit. It relaxes binary variables to $(\ell_v,r_v)$1, uses a GNN and a spectral penalty to optimize the relaxed objective, rounds the solution, and then repairs it by a spanning-tree heuristic. The paper itself characterizes the method as a neural continuous relaxation plus deterministic rounding plus spanning-tree repair, not as a classical cutting-plane method (Liu et al., 2024).

Across these examples, two meanings coexist. In the strict sense, a relax-and-cut framework is a branch-and-cut or cutting-surface method in which valid inequalities dynamically tighten a relaxation. In the broader sense, it can denote a relax-and-recover architecture that keeps an explicit mathematical link between a continuous surrogate and a discrete cut. Much of the recent literature is valuable precisely because it makes that distinction explicit rather than collapsing it.