I added 1 Million constraints to an LP unwittingly

Specific Domains Optimization (Mathematical)
, , , ,
1

This topic is sharing an experience, probably a noob has not seen before (me included).
Put it simply, I’m solving a disjointed bilinear programming using RLT, and wasn’t realizing that the number of constraints will be (almost) prohibitive.
I used JuMP to model the problem, I guess it probably takes more than 1 hour to add the whole set of constraints. This is the first time I witness the barrier method in the context of an LP.

julia> lpr
lpr_lMD
├ solver: Gurobi
├ objective_sense: MAX_SENSE
│ └ objective_function_type: JuMP.AffExpr
├ num_variables: 17169
├ num_constraints: 1492050
│ └ JuMP.AffExpr in MOI.GreaterThan{Float64}: 1492050
└ Names registered in the model
  └ :cross_multrix, :g_x_DJ, :g_x_Dv, :lpr_DI, :lpr_DJ, :lpr_Dv, :lpr_g

julia> solve_to_normality(lpr);
Gurobi Optimizer version 12.0.1 build v12.0.1rc0 (win64 - Windows 11.0 (26100.2))

CPU model: 11th Gen Intel(R) Core(TM) i5-1135G7 @ 2.40GHz, instruction set [SSE2|AVX|AVX2|AVX512]        
Thread count: 4 physical cores, 8 logical processors, using up to 8 threads

Optimize a model with 1492050 rows, 17169 columns and 13609742 nonzeros
Model fingerprint: 0x7d117878
Coefficient statistics:
  Matrix range     [3e-01, 1e+02]
  Objective range  [5e-02, 9e-01]
  Bounds range     [0e+00, 0e+00]
  RHS range        [3e-01, 5e+03]
Presolve removed 17338 rows and 0 columns
Presolve time: 11.55s
Presolved: 17169 rows, 1474881 columns, 13592573 nonzeros

Concurrent LP optimizer: primal simplex and barrier
Showing barrier log only...

Ordering time: 4.36s

Barrier statistics:
 AA' NZ     : 6.388e+07
 Factor NZ  : 1.474e+08 (roughly 1.8 GB of memory)
 Factor Ops : 1.687e+12 (roughly 10 seconds per iteration)
 Threads    : 3

                  Objective                Residual
Iter       Primal          Dual         Primal    Dual     Compl     Time
   0   5.71120126e+05  0.00000000e+00  6.05e+02 0.00e+00  3.95e+00    28s
   1   4.37893245e+05 -3.45183484e+02  4.47e+02 1.30e+01  2.71e+00    28s
   2   2.67897039e+05 -4.37239984e+02  2.42e+02 1.25e+01  1.67e+00    29s
   3   1.46906844e+05 -3.67646021e+02  1.24e+02 9.69e+00  9.33e-01    29s
   4   8.86396264e+04 -1.69332027e+02  7.03e+01 6.12e+00  5.43e-01    30s
   5   4.22819423e+04  8.78804336e+01  3.07e+01 2.29e+00  2.40e-01    40s
   6   2.02877786e+04  1.68938661e+02  1.15e+01 1.08e+00  9.31e-02    50s
   7   1.22500334e+04  2.35499963e+02  6.03e+00 3.12e-01  4.86e-02    60s
   8   5.81647899e+03  3.56104339e+02  2.32e+00 4.26e-13  2.00e-02    71s
   9   2.64678975e+03  7.30204234e+02  6.48e-01 3.13e-13  6.08e-03    81s
  10   2.34347636e+03  8.45237120e+02  4.75e-01 3.13e-13  4.55e-03    92s
  11   2.57521485e+03  1.28886597e+03  3.42e-01 3.98e-13  3.51e-03   112s
  12   2.83304679e+03  1.76408230e+03  2.55e-01 3.13e-13  2.77e-03   140s
  13   2.81240430e+03  2.07655283e+03  2.22e-01 3.98e-13  2.33e-03   175s
  14   2.88608928e+03  2.21103174e+03  2.10e-01 3.41e-13  2.21e-03   206s
  15   2.96672730e+03  2.48805003e+03  1.82e-01 3.13e-13  1.88e-03   233s
  16   3.04588895e+03  2.78311597e+03  1.56e-01 3.13e-13  1.55e-03   261s
  17   3.15331798e+03  3.06080233e+03  1.31e-01 2.77e-13  1.23e-03   290s
  18   3.18703776e+03  3.09122050e+03  1.23e-01 3.20e-13  1.17e-03   316s
  19   3.25205976e+03  3.27818355e+03  1.10e-01 3.06e-13  9.81e-04   337s
  20   3.34053747e+03  3.35671306e+03  9.11e-02 2.77e-13  8.24e-04   358s
  21   3.39744592e+03  3.49154561e+03  7.98e-02 3.77e-13  6.76e-04   381s
  22   3.48352309e+03  3.59061737e+03  6.00e-02 3.06e-13  4.86e-04   408s
  23   3.53725932e+03  3.66655784e+03  4.87e-02 3.48e-13  3.68e-04   438s
  24   3.57674623e+03  3.67790503e+03  4.11e-02 3.84e-13  3.16e-04   470s
  25   3.61864454e+03  3.71529940e+03  3.29e-02 3.93e-13  2.43e-04   506s
  26   3.64873013e+03  3.73499349e+03  2.71e-02 3.29e-13  1.96e-04   539s
  27   3.68860535e+03  3.75640763e+03  1.98e-02 3.28e-13  1.39e-04   578s
  28   3.74475396e+03  3.77121455e+03  1.01e-02 3.67e-13  7.64e-05   623s
  29   3.76230460e+03  3.78202237e+03  7.06e-03 3.47e-13  5.27e-05   661s
  30   3.79956188e+03  3.79464092e+03  1.00e-03 4.19e-13  1.27e-05   689s
  31   3.80517002e+03  3.80253731e+03  1.20e-05 3.71e-13  1.88e-06   718s
  32   3.80496948e+03  3.80487918e+03  5.52e-08 4.14e-13  6.11e-08   746s
  33   3.80494594e+03  3.80494560e+03  9.26e-10 4.74e-13  2.33e-10   774s
  34   3.80494581e+03  3.80494581e+03  3.71e-09 4.12e-13  2.33e-13   808s

Barrier solved model in 34 iterations and 807.94 seconds (421.92 work units)
Optimal objective 3.80494581e+03

Crossover log...

    7121 DPushes remaining with DInf 1.9624121e-05               809s
    3512 DPushes remaining with DInf 0.0000000e+00               810s
     505 DPushes remaining with DInf 0.0000000e+00               816s
     285 DPushes remaining with DInf 0.0000000e+00               821s
       0 DPushes remaining with DInf 0.0000000e+00               825s

  708357 PPushes remaining with PInf 1.0329409e-03               826s
  637301 PPushes remaining with PInf 0.0000000e+00               830s
  558277 PPushes remaining with PInf 0.0000000e+00               836s
  474805 PPushes remaining with PInf 0.0000000e+00               840s
  322196 PPushes remaining with PInf 0.0000000e+00               845s
  185897 PPushes remaining with PInf 0.0000000e+00               850s
   44324 PPushes remaining with PInf 0.0000000e+00               855s
    1108 PPushes remaining with PInf 0.0000000e+00               862s
       0 PPushes remaining with PInf 0.0000000e+00               862s

  Push phase complete: Pinf 0.0000000e+00, Dinf 1.0490706e-10    862s


Solved with barrier
Iteration    Objective       Primal Inf.    Dual Inf.      Time
  715481    3.8049458e+03   0.000000e+00   0.000000e+00    865s

Solved in 715481 iterations and 864.92 seconds (470.05 work units)
Optimal objective  3.804945806e+03

User-callback calls 718074, time in user-callback 0.45 sec

julia> JuMP.solution_summary(lpr)
solution_summary(; result = 1, verbose = false)
├ solver_name          : Gurobi
├ Termination
│ ├ termination_status : OPTIMAL
│ ├ result_count       : 1
│ ├ raw_status         : Model was solved to optimality (subject to tolerances), and an optimal solution is available.
│ └ objective_bound    : 3.80495e+03
├ Solution (result = 1)
│ ├ primal_status        : FEASIBLE_POINT
│ ├ dual_status          : FEASIBLE_POINT
│ ├ objective_value      : 3.80495e+03
│ └ dual_objective_value : 3.80495e+03
└ Work counters
  ├ solve_time (sec)   : 8.64936e+02
  ├ simplex_iterations : 715481
  ├ barrier_iterations : 34
  └ node_count         : 0

And a question for me now is:
is there a way that I can add the 1 Million constraints in a lazy fashion? (note that this is an LP)

2

There is a way through callbacks: Solver-independent Callbacks · JuMP

3

Yes, I know there is a callback for MIP. But I’m not sure is there a callback method for a pure LP.
It appears that Gurobi doesn’t support pure-LP callback (is it?)

1 Like
4

Oh, good point. I don’t know actually! I had always assumed it did, but never tried it.

5

I find Lazy and LazyConstraints in Gurobi’s doc.
The former can be used outside of callback, while the latter seems to be the opposite. The disquieting fact is that both are with note Only affects MIP models, whereas mine is a pure LP.

For my specific application here, I guess I need the Lazy attribute—Maybe I should set all that 1 million constraints to Lazy with value being 1.

Since mine is an LP, maybe I need to add a dummy_decision to promote it to a MIP, like this

import JuMP, Gurobi; GRB_ENV = Gurobi.Env();
let
    model = JuMP.direct_model(Gurobi.Optimizer(GRB_ENV))
    JuMP.@variable(model, x)
    dummy_decision = JuMP.@variable(model, binary = true, upper_bound = 0)
    JuMP.@constraint(model, c[i = 1:987], x >= log(i));
    JuMP.MOI.set.(JuMP.backend(model), Gurobi.ConstraintAttribute("Lazy"), JuMP.index.(c), 1);
    JuMP.@objective(model, Min, x)
    JuMP.set_attribute(model, "PreSolve", 0) # To make the evidence 🍅 visible
    JuMP.optimize!(model) # see the following Logging
end
Set parameter Presolve to value 0
Gurobi Optimizer version 12.0.1 build v12.0.1rc0 (win64 - Windows 11.0 (26100.2))

CPU model: 11th Gen Intel(R) Core(TM) i5-1135G7 @ 2.40GHz, instruction set [SSE2|AVX|AVX2|AVX512]
Thread count: 4 physical cores, 8 logical processors, using up to 8 threads

Non-default parameters:
Presolve  0

Optimize a model with 987 rows, 2 columns and 987 nonzeros
Model fingerprint: 0xaaaf0af2
Variable types: 1 continuous, 1 integer (1 binary)
Coefficient statistics:
  Matrix range     [1e+00, 1e+00]
  Objective range  [1e+00, 1e+00]
  Bounds range     [0e+00, 0e+00]
  RHS range        [7e-01, 7e+00]
Found heuristic solution: objective 6.8946700
Extracted 987 lazy constraints # 🍅
Variable types: 1 continuous, 1 integer (1 binary)

Explored 0 nodes (0 simplex iterations) in 0.00 seconds (0.00 work units)
Thread count was 8 (of 8 available processors)

Solution count 1: 6.89467 

Optimal solution found (tolerance 1.00e-04)
Best objective 6.894670039415e+00, best bound 6.894670039415e+00, gap 0.0000%

User-callback calls 34, time in user-callback 0.00 sec

It’s still strange. Why does Gurobi do not support lazy cuts in pure LP?

This example is adapted from Gurobi.jl, do you think the example there is proper? @odow , since your model there is an LP, which is supposed to be immune to the Lazy attribute setting.

6

Gurobi does not support lazy constraints in an LP.

You can use an iterative cutting plane method, where you iteratively call optimize! and then @constraint. Gurobi will automatically warm-start the problem from the previous solution.

This example is adapted from Gurobi.jl, do you think the example there is proper?

It just demonstrates how to set the variable, constraint, and model attributes. It isn’t intended to be a proper example.

1 Like
7

Here is one more question. I have 2 vectors: r, c and one asymmetric matrix X.
r is a 101-element SparseArrays.SparseVector{Float64, Int64} with 101 stored entries:
c is a 170-element SparseArrays.SparseVector{Float64, Int64} with 3 stored entries:
X is a 101×170 Matrix{JuMP.AffExpr}:
I now need to write the constraint @constraint(model, r' * X * c >= 0),
Which style should I choose, to maximize the performance (assume I need to add 1 million of this type of constraint, assume 101 and 170 both increase)

  1. @constraint(model, transpose(r) * X * c >= 0)
  2. @constraint(model, transpose(r) * (X * c) >= 0)
  3. @constraint(model, dot(r, X, c) >= 0)
  4. @constraint(model, tr(c * transpose(r) * X) >= 0)
  5. @constraint(model, sm(r * transpose(c), X) >= 0), where sm is here.
  6. should I use transpose() or ' (adjoint)?

And this list can be enlarged because there are many equivalent forms.

8

It takes about 4 seconds on my laptop to add 7k constraints with JuMP.
is this slow?

for r in eachrow(A1)                                                                                           
       ite += 1                                                                                                   
       println("ite = $ite <= 201, time_elapsed = $(time() - t0)")                                                
       JuMP.@constraint(lpr, [c in eachrow(A2)], transpose(r) * cross_multrix * c >= 0)                           
end
ite = 1 <= 201, time_elapsed = 0.01900005340576172
ite = 2 <= 201, time_elapsed = 14.52999997138977 # the first one is a bit denser, taking 14 seconds
ite = 3 <= 201, time_elapsed = 18.377000093460083
ite = 4 <= 201, time_elapsed = 22.23099994659424
ite = 5 <= 201, time_elapsed = 26.15400004386902

To reproduce this procedure, please see code in this post.

9

Have you benchmarked the different forms? I would assume this depends on the sparsity of r and c.

I would do:

using JuMP, SparseArrays
model = Model()
@variable(model, x[1:101, 1:170])
X = 1.0 .* x
r = SparseArrays.sprand(101, 0.1)
c = SparseArrays.sprand(170, 0.1)
# @constraint(model, r' * X * c >= 0)
(r_I, r_V), (c_I, c_V)  = SparseArrays.findnz(r), SparseArrays.findnz(c)
@constraint(
    model, 
    sum(
        r_v * X[r_i, c_i] * c_v for
        (c_i, c_v) in zip(c_I, c_V), (r_i, r_v) in zip(r_I, r_V)
    ) >= 0
)
1 Like
10

Yes, this zip used is very proper. We have to manually write this procedure because LinearAlgebra doesn’t optimize the code for SparseArrays. With your style, I add 1434738 constraints within 12.5 seconds.

ite = 0
t0 = time()
for i in eachindex(eachrow(A1))
    ite += 1
    println("ite = $ite <= 201, time_elapsed = $(time() - t0)")
    for j in eachindex(eachrow(A2))
        r, c = A1[i, :], A2[j, :]
        JuMP.@constraint(lpr,
            sum(    rv * cv * cross_multrix[ri, ci] for
                (ri, rv) in zip(r.nzind, r.nzval), 
                (ci, cv) in zip(c.nzind, c.nzval)
            )   >= 0
        )
    end
end # ite = 201 <= 201, time_elapsed = 12.47000002861023

I made a slight modification to make it looks better. :slightly_smiling_face:

11

I’m afraid that there will be a nontrivial time overhead on the interaction of Gurobi and JuMP, if we alternately perform this. The odds are that it could be inferior than delivering all constraints to Gurobi all at once (in my application, the set of constraints are explict and finitely-many). (my guess).

12

You would typically add only the constraints that are violated in each iteration. Assuming only a small fraction of the constraints are ever relevant, the iterative approach is faster.

But yes, the true performance is problem dependent. You’ll have to experiment with your particular problem.

13

I think Lazy is somewhat pointless, compared with LazyConstraints.
The latter is useful when we have infinitely many (implicit) cuts, e.g. emulating a SDP constraint (see the while-loop in this example).
If we have finitely many explicit cuts (e.g., in the context of this topic), then we have 2 possibilities

  1. the number of these cuts are small, e.g. 10 cuts
  2. the number of these cuts are huge, e.g. 1 million

It’s manifest that it would be pointless to use Lazy for merely 10 cuts.
Now suppose we submit 1 million explicit cuts to Gurobi, setting the Lazy attribute. What’s its meaning?
Shouldn’t let gurobi decide which part of constraints should be deemed “lazy” to accelerate the solution procedure. After all, it is a black-box solver. It’s weird.

14

This doesn’t make sense either. Suppose I have 1 million explicit lazy constraints. Then the solution procedure should be like this

Gurobi's_optimize!(model)
x_val = value(x)
for i in 1:1000000
    if X_val violates the constr[i]
        re_add(constr[i])
    end
end
# do the above procedure again

You see that at every “callback”, we ought to loop over the huge collection of lazy constraints.
It’s not necessarily faster that the pure static method (without any “callback” procedure like the above code block).

15

In most cases you can construct a clever oracle that can generate the set of violated cuts more efficiently than enumerating them.

Something like this:

# min y st: y >= f(x), where f(x) := (x - 1)^2
using JuMP, Gurobi
model = Model(Gurobi.Optimizer)
@variable(model, x)
@variable(model, y >= 0)
@objective(model, Min, y)
f(x) = (x - 1)^2
∇f(x) = 2 * (x - 1)
while true
    optimize!(model)
    assert_is_solved_and_feasible(model)
    xv, yv = value(x), value(y)
    if yv >= f(xv) - 1e-6
        break
    end
    @constraint(model, y >= f(xv) + ∇f(xv) * (x - xv))
end
16

In the context of my example, this is not the case.
Mine is RLT cuts—a set of finitely many (but numerous) explicit constraints.

I did a test on whether there is a need to manually promote an pure-LP to a MIP by introducing a dummy integer decision (in order to piggyback on Gurobi’s Lazy constraint attribute).
The test result indicates: needless—it won’t be faster with this contrived trick, whether the problem scale is small, moderate or large.

import JuMP, Random, Gurobi; GRB_ENV = Gurobi.Env();
function optimise(m)
    JuMP.optimize!(m)
    return (
        JuMP.termination_status(m),
        JuMP.primal_status(m),
        JuMP.dual_status(m)
    )
end;
macro set_objective_function(m, f) return esc(:(JuMP.set_objective_function($m, JuMP.@expression($m, $f)))) end;
function Model(name)
    m = JuMP.direct_model(Gurobi.Optimizer(GRB_ENV))
    JuMP.MOI.set(m, JuMP.MOI.Name(), name)
    s = name[end-1]
    s == 'm' && JuMP.set_objective_sense(m, JuMP.MIN_SENSE)
    s == 'M' && JuMP.set_objective_sense(m, JuMP.MAX_SENSE)
    last(name) == 's' && JuMP.set_silent(m)
    m
end;
function solve_to_normality(m)
    t, p, d = optimise(m)
    name = JuMP.name(m)
    t == JuMP.OPTIMAL || error("$name: $(string(t))")
    p == JuMP.FEASIBLE_POINT || error("$name: (primal) $(string(p))")
    (name[end-2] == 'l' && d != p) && error("$name: (dual) $(string(d))")
    return JuMP.result_count(m)
end;
N = 22500
Random.seed!(1)
model = Model("test_bmD")
JuMP.set_attribute(model, "Presolve", 0)
JuMP.set_attribute(model, "TimeLimit", 60 * 9)
JuMP.@variable(model, rand(-9:.17:-1) <= x[1:N] <= rand(0.7:.173:9))
# dummy_decision = JuMP.@variable(model, binary = true, upper_bound = 0)
JuMP.@constraint(model, non_lazy_constr, sum(x) >= -5)
for i in 1:(N ÷ 2)  
    c = JuMP.@constraint(model, rand(-2:2, N)' * x <= rand(-1:1))
    # JuMP.MOI.set(JuMP.backend(model), Gurobi.ConstraintAttribute("Lazy"), JuMP.index(c), 1)
end
@set_objective_function(model, rand(-1:.17:1, N)' * x)
solve_to_normality(model)
JuMP.objective_bound(model) # [Test Result] LP: -52262.27784988559 > MIP: -53552.45952117307;
17

But apparently, Gurobi is going to struggle when the pure-LP it confronts is very large scale (e.g. my case above). This is how Gurobi’s log looks like after 9 minutes (note that there is not even a single line of barrier’s logging).

Non-default parameters:
TimeLimit  540
Presolve  0

Optimize a model with 11251 rows, 22500 columns and 202521669 nonzeros
Model fingerprint: 0x4022ea78
Coefficient statistics:
  Matrix range     [1e+00, 2e+00]
  Objective range  [2e-02, 1e+00]
  Bounds range     [7e-01, 9e+00]
  RHS range        [1e+00, 5e+00]

Concurrent LP optimizer: dual simplex and barrier
Showing barrier log only...

Ordering time: 4.31s

Barrier statistics:
 AA' NZ     : 6.329e+07
 Factor NZ  : 6.330e+07 (roughly 500 MB of memory)
 Factor Ops : 4.748e+11 (roughly 100 seconds per iteration)
 Threads    : 3

Barrier performed 0 iterations in 543.88 seconds (1020.84 work units)
Barrier solve interrupted - model solved by another algorithm



Stopped in 3229 iterations and 545.97 seconds (266.40 work units)
Time limit reached

User-callback calls 169, time in user-callback 0.08 sec
ERROR: test_lmD: TIME_LIMIT
Stacktrace:
 [1] error(s::String)
   @ Base .\error.jl:35
 [2] solve_to_normality(m::JuMP.Model)
   @ Main .\REPL[6]:4
 [3] top-level scope
   @ REPL[48]:1

julia> JuMP.objective_bound(model)
-52262.27784988559

in stark contrast, in the MIP case, we can monitor Gurobi’s MIP logging, like the follows

TimeLimit  540
Presolve  0

Optimize a model with 11251 rows, 22501 columns and 202521669 nonzeros
Model fingerprint: 0x751d7d29
Variable types: 22500 continuous, 1 integer (1 binary)
Coefficient statistics:
  Matrix range     [1e+00, 2e+00]
  Objective range  [2e-02, 1e+00]
  Bounds range     [7e-01, 9e+00]
  RHS range        [1e+00, 5e+00]
Presolve removed 0 rows and 0 columns (presolve time = 26s)...
Presolve removed 0 rows and 0 columns (presolve time = 85s)...
Extracted 11250 lazy constraints
Variable types: 22500 continuous, 1 integer (1 binary)

Root simplex log...

Iteration    Objective       Primal Inf.    Dual Inf.      Time
       0   -1.0082852e+05   4.462773e+04   0.000000e+00    128s
       1   -5.6291160e+04   0.000000e+00   0.000000e+00    128s

Root relaxation: objective -5.629116e+04, 1 iterations, 0.02 seconds (0.00 work units)

    Nodes    |    Current Node    |     Objective Bounds      |     Work
 Expl Unexpl |  Obj  Depth IntInf | Incumbent    BestBd   Gap | It/Node Time

     0     0 -56291.160    0    -          - -56291.160      -     -  203s
     0     0 -56278.151    0    -          - -56278.151      -     -  208s
     0     0 -56266.561    0    -          - -56266.561      -     -  208s
    # omit about hundred lines to make it look better
     0     0 -53564.388    0    -          - -53564.388      -     -  534s
     0     0 -53552.460    0    -          - -53552.460      -     -  539s
     0     0          -    0               - -53552.460      -     -  540s

Cutting planes:
  Lazy constraints: 156

Explored 1 nodes (42399 simplex iterations) in 669.97 seconds (264.43 work units)
Thread count was 8 (of 8 available processors)

Solution count 0

Time limit reached
Best objective -, best bound -5.355245952117e+04, gap -

User-callback calls 10444, time in user-callback 0.55 sec
ERROR: test_bmD: TIME_LIMIT
Stacktrace:
 [1] error(s::String)
   @ Base .\error.jl:35
 [2] solve_to_normality(m::JuMP.Model)
   @ Main .\REPL[6]:4
 [3] top-level scope
   @ REPL[34]:1

julia> JuMP.objective_bound(model)
-53552.45952117307
18

I wrote a procedure myself. I think it should be okay.

19

Let’s try to keep discussions of a topic to a single thread please. It gets quite hard to follow when parts of the thread are linked to code in a new thread.

20

I find one practical usage today—to set a collection of cuts as user cut.

import JuMP, Gurobi; GRB_ENV = Gurobi.Env()
function set_user_cut(model, c)
    JuMP.MOI.set(JuMP.backend(model), Gurobi.ConstraintAttribute("Lazy"), JuMP.index(c), -1)
end
user_cut_vec = JuMP.ConstraintRef[]
model = JuMP.direct_model(Gurobi.Optimizer(GRB_ENV))
JuMP.@variable(model, -0.8 <= x <= 1.8)
JuMP.@objective(model, Min, x)
JuMP.optimize!(model); JuMP.objective_value(model) # -0.8
for b in [0.1, 0.2]
    push!(user_cut_vec, JuMP.@constraint(model, x >= b))
end
JuMP.optimize!(model); JuMP.objective_value(model) # 0.2
set_user_cut.(model, user_cut_vec)
JuMP.optimize!(model); JuMP.objective_value(model) # 🟠 still 0.2
JuMP.set_binary(x)
JuMP.optimize!(model) # ⚠️ Gurobi reports Warning: max constraint violation (2.0000e-01) exceeds tolerance
JuMP.solution_summary(model; verbose = true)

The results of the last 2 lines are

julia> JuMP.optimize!(model) # ⚠️ Gurobi reports Warning: max constraint violation (2.0000e-01)  exceeds tolerance
Gurobi Optimizer version 12.0.1 build v12.0.1rc0 (win64 - Windows 11.0 (26100.2))

CPU model: 11th Gen Intel(R) Core(TM) i5-1135G7 @ 2.40GHz, instruction set [SSE2|AVX|AVX2|AVX512]
Thread count: 4 physical cores, 8 logical processors, using up to 8 threads

Optimize a model with 2 rows, 1 columns and 2 nonzeros
Model fingerprint: 0xe4d1c84c
Variable types: 0 continuous, 1 integer (1 binary)
Coefficient statistics:
  Matrix range     [1e+00, 1e+00]
  Objective range  [1e+00, 1e+00]
  Bounds range     [8e-01, 2e+00]
  RHS range        [1e-01, 2e-01]
Found heuristic solution: objective 1.0000000
Presolve removed 2 rows and 1 columns
Presolve time: 0.00s
Presolve: All rows and columns removed

Explored 0 nodes (0 simplex iterations) in 0.00 seconds (0.00 work units)
Thread count was 1 (of 8 available processors)

Solution count 2: 0 1

Optimal solution found (tolerance 1.00e-04)
Warning: max constraint violation (2.0000e-01) exceeds tolerance 🍅
         (model may be infeasible or unbounded - try turning presolve off)
Best objective 0.000000000000e+00, best bound 0.000000000000e+00, gap 0.0000%

User-callback calls 126, time in user-callback 0.00 sec

julia> JuMP.solution_summary(model; verbose = true)
solution_summary(; result = 1, verbose = true)
├ solver_name          : Gurobi
├ Termination
│ ├ termination_status : OPTIMAL
│ ├ result_count       : 2
│ ├ raw_status         : Model was solved to optimality (subject to tolerances), and an optimal solution is available.
│ └ objective_bound    : 0.00000e+00
├ Solution (result = 1)
│ ├ primal_status        : FEASIBLE_POINT
│ ├ dual_status          : NO_SOLUTION
│ ├ objective_value      : 0.00000e+00
│ ├ relative_gap         : 0.00000e+00
│ └ value
│   └ x : 0.00000e+00

The 🍅 Warning is a bit weird.
Indeed, if you follow the instruction and do JuMP.set_attribute(model, "Presolve", 0), then the result is rendered incorrect, given the definition of the user cut (see my link “Lazy” in the 5th post).