Fix issue with incorrect lower bound on air05 (#890)

Fix an issue with incorrect lower bound on air05.

In 26.02, with the new scheduler worker model, it looks like the lower bound is not computed correctly if there are nodes still remaining in the `node_queue`. This PR fathoms all the nodes and pulls the lower bound from the search tree. 

In 26.02 we were also incorrectly fathoming nodes with objectives less than the optimal objective, due to the `rel_gap` check. This PR removes that check. 

In 26.04 we were incorrectly setting the cutoff to one less than it should be when the objective was integral. This PR fixes that bug.

Authors:
  - Chris Maes (https://github.com/chris-maes)

Approvers:
  - Alice Boucher (https://github.com/aliceb-nv)

URL: #890

Author: chris-maes

cpp/src/branch_and_bound/branch_and_bound.cpp

@@ -1317,7 +1317,7 @@ dual::status_t branch_and_bound_t<i_t, f_t>::solve_node_lp(
   simplex_solver_settings_t lp_settings = settings_;
   lp_settings.set_log(false);
   if (original_lp_.objective_is_integral) {
-    lp_settings.cut_off = std::ceil(upper_bound_ - settings_.integer_tol) - 1 + settings_.dual_tol;
+    lp_settings.cut_off = std::ceil(upper_bound_ - settings_.integer_tol) + settings_.dual_tol;
   } else {
     lp_settings.cut_off = upper_bound_ + settings_.dual_tol;
   }
@@ -1426,7 +1426,7 @@ void branch_and_bound_t<i_t, f_t>::plunge_with(branch_and_bound_worker_t<i_t, f_
     // - The lower bound of the parent is lower or equal to its children
     worker->lower_bound = lower_bound;
 
-    if (lower_bound > upper_bound || rel_gap < settings_.relative_mip_gap_tol) {
+    if (lower_bound > upper_bound) {
       search_tree_.graphviz_node(settings_.log, node_ptr, "cutoff", node_ptr->lower_bound);
       search_tree_.update(node_ptr, node_status_t::FATHOMED);
       worker->recompute_basis  = true;
@@ -1536,7 +1536,7 @@ void branch_and_bound_t<i_t, f_t>::dive_with(branch_and_bound_worker_t<i_t, f_t>
     f_t rel_gap         = user_relative_gap(original_lp_, upper_bound, lower_bound);
     worker->lower_bound = lower_bound;
 
-    if (node_ptr->lower_bound > upper_bound || rel_gap < settings_.relative_mip_gap_tol) {
+    if (node_ptr->lower_bound > upper_bound) {
       worker->recompute_basis  = true;
       worker->recompute_bounds = true;
       continue;
@@ -2471,8 +2471,30 @@ mip_status_t branch_and_bound_t<i_t, f_t>::solve(mip_solution_t<i_t, f_t>& solut
     lower_bound    = deterministic_compute_lower_bound();
     solver_status_ = deterministic_global_termination_status_;
   } else {
-    lower_bound = node_queue_.best_first_queue_size() > 0 ? node_queue_.get_lower_bound()
-                                                          : search_tree_.root.lower_bound;
+    if (node_queue_.best_first_queue_size() > 0) {
+      // We need to clear the queue and use the info in the search tree for the lower bound
+      while (node_queue_.best_first_queue_size() > 0) {
+        std::optional<mip_node_t<i_t, f_t>*> start_node = node_queue_.pop_best_first();
+
+        if (!start_node.has_value()) { continue; }
+        if (upper_bound_ < start_node.value()->lower_bound) {
+          // This node was put on the heap earlier but its lower bound is now greater than the
+          // current upper bound
+          search_tree_.graphviz_node(
+            settings_.log, start_node.value(), "cutoff", start_node.value()->lower_bound);
+          search_tree_.update(start_node.value(), node_status_t::FATHOMED);
+          continue;
+        } else {
+          node_queue_.push(
+            start_node.value());  // Needed to ensure we don't lose the correct lower bound
+          break;
+        }
+      }
+      lower_bound = node_queue_.best_first_queue_size() > 0 ? node_queue_.get_lower_bound()
+                                                            : search_tree_.root.lower_bound;
+    } else {
+      lower_bound = search_tree_.root.lower_bound;
+    }
   }
   set_final_solution(solution, lower_bound);
   return solver_status_;
@@ -2781,7 +2803,7 @@ void branch_and_bound_t<i_t, f_t>::run_deterministic_bfs_loop(
 
       f_t upper_bound = worker.local_upper_bound;
       f_t rel_gap     = user_relative_gap(original_lp_, upper_bound, node->lower_bound);
-      if (node->lower_bound > upper_bound || rel_gap < settings_.relative_mip_gap_tol) {
+      if (node->lower_bound > upper_bound) {
         worker.current_node = nullptr;
         worker.record_fathomed(node, node->lower_bound);
         search_tree.update(node, node_status_t::FATHOMED);
@@ -3570,8 +3592,7 @@ void branch_and_bound_t<i_t, f_t>::deterministic_dive(
 
     // Prune check using snapshot upper bound
     f_t rel_gap = user_relative_gap(original_lp_, worker.local_upper_bound, node_ptr->lower_bound);
-    if (node_ptr->lower_bound > worker.local_upper_bound ||
-        rel_gap < settings_.relative_mip_gap_tol) {
+    if (node_ptr->lower_bound > worker.local_upper_bound) {
       worker.recompute_bounds_and_basis = true;
       continue;
     }

cpp/src/pdlp/restart_strategy/pdlp_restart_strategy.cu

@@ -1995,14 +1995,14 @@ void pdlp_restart_strategy_t<i_t, f_t>::solve_bound_constrained_trust_region(
     f_t* end   = threshold_.data() + primal_size_h_ + dual_size_h_;
     auto highest_negInf_primal =
       thrust::find(handle_ptr_->get_thrust_policy(),
-                   thrust::make_reverse_iterator(thrust::device_ptr<f_t>(end)),
-                   thrust::make_reverse_iterator(thrust::device_ptr<f_t>(start)),
+                   cuda::std::reverse_iterator(thrust::device_ptr<f_t>(end)),
+                   cuda::std::reverse_iterator(thrust::device_ptr<f_t>(start)),
                    -std::numeric_limits<f_t>::infinity());
 
     // Set ranges accordingly
     i_t index_start_primal = 0;
     i_t index_end_primal   = primal_size_h_ + dual_size_h_;
-    if (highest_negInf_primal != thrust::make_reverse_iterator(thrust::device_ptr<f_t>(start))) {
+    if (highest_negInf_primal != cuda::std::reverse_iterator(thrust::device_ptr<f_t>(start))) {
       cuopt_assert(device_to_host_value(thrust::raw_pointer_cast(&*highest_negInf_primal)) ==
                      -std::numeric_limits<f_t>::infinity(),
                    "Incorrect primal reverse iterator");