Recursive RINS

[nguidotti]

This PR implements the recursive RINS heuristics. More specifically, it applies a dive-like procedure to create a RINS sub-MIP, presolved it with Papilo and then passes to the cut-and-branch procedure. It also launch a CPU FJ worker over the sub-MIP that runs in parallel to cut-and-branch.

Since the current implementation, does not have an unified problem representation, this PR also adds:

• A routine for converting a lp_problem_t (standard form) to user_problem_t (range form).
• Allow Papilo to be applied to an user_problem_t instead of optimization_problem_t.
• Adds an upper bound callback for retrieving the upper bound of the main solver (since it may change if another worker find a better incumbent).

Additionally, the number of worker per diving heuristic is no longer tied to the total number of workers, which allows the solver to use all diving heuristics in low thread counts (we rotate between the different heuristics for each diving worker launch).

Results

MIPLIB2017, 10min, GH200

================================================================================
 main-2026-07-03 (1) vs recursive-submip (2)
================================================================================

------------------------------------------------------------------------------------------------------------------------------
|                                        |       Run 1        |       Run 2        |     Abs. Diff.     |   Rel. Diff. (%)   |
------------------------------------------------------------------------------------------------------------------------------
| Imported                                                 240                  240                   +0                 --- |
| Feasible                                                 227                  228                   +1                 --- |
| Optimal                                                   86                   91                   +5                 --- |
| Solutions with <0.1% primal gap                          138                  151                  +13                 --- |
| Nodes explored (mean)                              1.326e+07            1.296e+07           -3.057e+05               -2.31 |
| Nodes explored (shifted geomean)                   1.262e+04            1.239e+04                 -230               -1.82 |
| Relative MIP gap (mean)                               0.2777               0.2726             -0.00512               -1.84 |
| Relative MIP gap (shifted geomean)                   0.09089              0.08901            -0.001883               -2.07 |
| Solve time (mean)                                      422.6                435.4               +12.79               +3.03 |
| Solve time (shifted geomean)                           196.9                226.6               +29.66               +15.1 |
| Primal gap (mean)                                      9.969                 9.29               -0.679               -6.81 |
| Primal gap (shifted geomean)                          0.4584               0.3491              -0.1093               -23.8 |
| Primal integral (mean)                                 25.02                22.97               -2.051                -8.2 |
| Primal integral (shifted geomean)                      2.849                2.421              -0.4275                 -15 |
------------------------------------------------------------------------------------------------------------------------------


----------------------------------------------------------------------
|             Name             |     status 1     |     status 2     |
----------------------------------------------------------------------
| neos-1171737                           feasible            optimal |
| radiationm40-10-02                     feasible            optimal |
| rail01                                  timeout           feasible |
| ran14x18-disj-8                        feasible            optimal |
| triptim1                               feasible            optimal |
| unitcal_7                              feasible            optimal |
----------------------------------------------------------------------

[copy-pr-bot]

Auto-sync is disabled for draft pull requests in this repository. Workflows must be run manually.

Contributors can view more details about this message here.

[chris-maes]

Note: presolve based on time limit introduce non-determinism into the solve.

[nguidotti]

I do not think Papilo supports or uses work limit

[aliceb-nv]

Have we tested if Papilo needs this scaled-down time limit here? On a restarted problem it may be able to reach the fixed point quickly. If not, then the expensive Probing pass has a separate work unit that can be tuned - I assume it's also possible to set a limit on the number of rounds.

[nguidotti]

I copy the settings from the regular presolve pass. Honestly, I would not spend too much effort for this since I hope we can replace the presolve + cut-and-branch for the submip for a call to the entire solver stack (with maybe some parts turn off) when we have the unified problem object

[aliceb-nv]

I'd rather not introduce sources of nondeterminism in new PRs please :( We'll need a way to run a determinsitic "light" papilo presolve pass at some point regardless

[nguidotti]

The recursive RINS is disable for the deterministic mode. In any case, we have the same problem when calling the Papilo in the regular solve, right?

[nguidotti]

When and for which node the recursive RINS triggers is quite non-deterministic, too.

[aliceb-nv]

We don't have this issue when running Papilo at the root because we disable the time limit there in determinsitic mode. Papilo terminates on its own, with some caps on the Probing work limits

[aliceb-nv]

Okay,, let's track that recursive RINS is strictly non-determinsitic with an issue. That's something I'll have to address later

[nguidotti]

Created here: #1579. If the solver is deterministic and we can call the solver stack directly, then we probably only need to do is make the triggering logic deterministic.

[chris-maes]

What is the augmented space? Just with the addition of slack variables. Note that slack variables are always placed at the end, and so the conversion from the problem with slacks to without slacks is trivial, you just drop variables at the end.

[nguidotti]

We start with a range form, user_problem_t with $m \times n$, and then add the slacks to transform into the standard form, lp_problem_t with $(m + m_s) \times (n + n_s)$. Then we add cuts and the system become $(m + m_s + m_c) \times (n + n_s + n_c)$. Let us call this the augmented problem.

For the submip, we need to convert the augmented problem back to range form. However, this is a direct conversion (set the range rows as equality and all slacks and cuts are preserved) so the user_problem_t will have the dimensions $(m + m_s + m_c) \times (n + n_s + n_c)$. When calling Papilo for the submip problem, it now consider the augmented system as the original space. Hence, it will crush/uncrush the solution to the $(m + m_s + m_c) \times (n + n_s + n_c)$ augmented system, not for the original $m \times n$ user_problem_t which the routine set_solution_from_heuristic expects. For this reason, we need to first uncrush the solution from the presolved space of the augmented system via Papilo, then uncrush the results again to the original $m \times n$ user_problem_t. Note that this is recursive (a sub-mip 2 levels deep will need to do 2 conversion which is done by going up the solver stack).

We will have a similar issue with restarts unless we accumulate the reductions into a single Papilo object that was created in the beginning

[chris-maes]

Is a callback necessary here? I think you might be able to simplify things by just having a variable cutoff that can be set to the upper bound by the main solve. Or better yet, why not just have the submip have a pointer to the upper bound variable of the main solve. That way every time the main solve updates the upper bound, the submip can see it.

[nguidotti]

This was originally what I did (having a pointer to the upper bound of the main solve). The current approach is more flexible, though. This allows not only to stop due to the cutoff but also if the solver status changes (e.g., let say the solver reaches the node/time limit and stops, then this callback can signal all the sub-MIP solves to stop immediately)

[chris-maes]

What is going on here? Could you add some comment to explain?

[nguidotti]

Added comment:

    // Launch a CPU FJ worker on the presolved sub-MIP with a fixed budget (in terms of work units)
    // to run in parallel with the cut-and-branch algorithm with the goal of finding a quick feasible 
    // solution for the sub-MIP problem. The CPU FJ uses the current incumbent (crushed into the 
    // presolved space) as initial guess. The worker is automatically stop when we go out of the
    // scope.

[chris-maes]

I only made it through branch_and_bound.cpp. I need to finish the review later.