Merge pull request #2671 from ERGO-Code/instantly-apply-implics

Apply implications when performing a bound change

Author: Opt-Mucca

highs/mip/HighsDomain.cpp

@@ -2053,9 +2053,14 @@ void HighsDomain::changeBound(HighsDomainChange boundchg, Reason reason) {
   domchgstack_.push_back(boundchg);
   domchgreason_.push_back(reason);
 
-  if (binary && !infeasible_ && isFixed(boundchg.column))
+  if (binary && !infeasible_ && isFixed(boundchg.column)) {
     mipsolver->mipdata_->cliquetable.addImplications(
         *this, boundchg.column, col_lower_[boundchg.column] > 0.5);
+    if (!infeasible_) {
+      mipsolver->mipdata_->implications.applyImplications(
+          *this, boundchg.column, col_lower_[boundchg.column] > 0.5);
+    }
+  }
 }
 
 void HighsDomain::setDomainChangeStack(

highs/mip/HighsImplications.cpp

@@ -829,3 +829,44 @@ void HighsImplications::cleanupVub(HighsInt col, HighsInt vubCol,
     infeasible = mipsolver.mipdata_->domain.infeasible();
   }
 }
+
+void HighsImplications::applyImplications(HighsDomain& domain,
+                                          const HighsInt col,
+                                          const HighsInt val) {
+  assert(domain.isFixed(col));
+
+  auto checkImplication = [&](const HighsDomainChange& domchg) -> bool {
+    assert(!domain.infeasible());
+    if (domain.isFixed(domchg.column)) return false;
+    const bool isint =
+        domain.variableType(domchg.column) != HighsVarType::kContinuous;
+    // Directly change bounds on all integer columns. Only change continuous
+    // columns that fix the column, as changing their domains risks
+    // suppressing further bound changes found in propagation, e.g.,
+    // change [0, 100] -> [0, 50], propagation could tighten to [0, 48], but
+    // such a tightening would not be applied due to min boundRange improvement.
+    if (domchg.boundtype == HighsBoundType::kLower) {
+      if ((!isint && domchg.boundval >
+                         domain.col_upper_[domchg.column] - domain.feastol()) ||
+          (isint && domchg.boundval >
+                        domain.col_lower_[domchg.column] + domain.feastol())) {
+        domain.changeBound(domchg, HighsDomain::Reason::cliqueTable(col, val));
+      }
+    } else {
+      if ((!isint && domchg.boundval <
+                         domain.col_lower_[domchg.column] + domain.feastol()) ||
+          (isint && domchg.boundval <
+                        domain.col_upper_[domchg.column] - domain.feastol())) {
+        domain.changeBound(domchg, HighsDomain::Reason::cliqueTable(col, val));
+      }
+    }
+    return domain.infeasible();
+  };
+
+  HighsInt loc = 2 * col + val;
+  if (implications[loc].computed) {
+    for (HighsDomainChange& domchg : implications[loc].implics) {
+      if (checkImplication(domchg)) break;
+    }
+  }
+}

highs/mip/HighsImplications.h

@@ -179,6 +179,8 @@ class HighsImplications {
   void cleanupVub(HighsInt col, HighsInt vubCol,
                   HighsImplications::VarBound& vub, double ub, bool& redundant,
                   bool& infeasible, bool allowBoundChanges = true) const;
+
+  void applyImplications(HighsDomain& domain, HighsInt col, HighsInt val);
 };
 
 #endif