[ConstraintSolver] Add isConditionImplied helper.

[fhahn]

Summary

This patch adds a isConditionImplied function that
takes a constraint and returns true if the constraint
is implied by the current constraints in the system.

[fhahn]

Rebase

[fhahn]

rebase

[spatel]

LGTM

llvm/lib/Analysis/ConstraintSystem.cpp

115

Typo - existing

llvm/unittests/Analysis/ConstraintSystemTest.cpp

83

Typo: Slover -> Solver

[fhahn]

Address comments, rebase, will commit shortly.

llvm/include/llvm/Analysis/ConstraintSystem.h

for (auto &C : R) {
                 .getZExtValue();
     }
     Constraints.push_back(R);
     NumVariables = (uint32_t)std::max((size_t)NumVariables, R.size());
   }
 
   /// Retuns true if there may be a solution for the constraints in the system.
   bool mayHaveSolution();
+
+  static SmallVector<int64_t, 8> negate(SmallVector<int64_t, 8> R) {
+    // The negated constraint R is obtained by multiplying by -1 and adding 1 to
+    // the constant.
+    R[0] += 1;
+    for (unsigned i = 0; i < R.size(); i++)
+      R[i] *= -1;
+    return R;
+  }
+
+  bool isConditionImplied(SmallVector<int64_t, 8> R);
 };
 } // namespace llvm
 
 #endif

llvm/lib/Analysis/ConstraintSystem.cpp

for (unsigned i = 1; i < Constraints[0].size(); i++)
     std::cout << "x" << i << "\t";
   std::cout << "\n";
   for (auto &R : Constraints) {
     for (auto a : R)
       std::cout << a << "\t";
     std::cout << "\n";
   }
 }
+
+bool ConstraintSystem::isConditionImplied(SmallVector<int64_t, 8> R) {
+  // If there is no solution with the negation of R added to the system, the
+  // condition must hold based on the exsisting constraints.
+  R = ConstraintSystem::negate(R);
+
+  auto NewSystem = *this;
+  NewSystem.addVariableRow(R);
+  return !NewSystem.mayHaveSolution();
+}

llvm/unittests/Analysis/ConstraintSystemTest.cpp

TEST(ConstraintSloverTest, TestSolutionChecks) {
 
     // 2x + y + 3z <= 10,  2x + y >= 10
     CS.addVariableRow({10, 2, 1, 3});
     CS.addVariableRow({-10, -2, -1, 0});
 
     EXPECT_TRUE(CS.mayHaveSolution());
   }
 }
+
+TEST(ConstraintSloverTest, IsConditionImplied) {
+  {
+    // For the test below, we assume we know
+    // x <= 5 && y <= 3
+    ConstraintSystem CS;
+    CS.addVariableRow({5, 1, 0});
+    CS.addVariableRow({3, 0, 1});
+
+    // x + y <= 6 does not hold.
+    EXPECT_FALSE(CS.isConditionImplied({6, 1, 1}));
+    // x + y <= 7 does not hold.
+    EXPECT_FALSE(CS.isConditionImplied({7, 1, 1}));
+    // x + y <= 8 does hold.
+    EXPECT_TRUE(CS.isConditionImplied({8, 1, 1}));
+
+    // 2 * x + y <= 12 does hold.
+    EXPECT_FALSE(CS.isConditionImplied({12, 2, 1}));
+    // 2 * x + y <= 13 does hold.
+    EXPECT_TRUE(CS.isConditionImplied({13, 2, 1}));
+
+    //  x + y <= 12 does hold.
+    EXPECT_FALSE(CS.isConditionImplied({12, 2, 1}));
+    // 2 * x + y <= 13 does hold.
+    EXPECT_TRUE(CS.isConditionImplied({13, 2, 1}));
+
+    // x <= y == x - y <= 0 does not hold.
+    EXPECT_FALSE(CS.isConditionImplied({0, 1, -1}));
+    // y <= x == -x + y <= 0 does not hold.
+    EXPECT_FALSE(CS.isConditionImplied({0, -1, 1}));
+  }
+
+  {
+    // For the test below, we assume we know
+    // x + 1 <= y + 1 == x - y <= 0
+    ConstraintSystem CS;
+    CS.addVariableRow({0, 1, -1});
+
+    // x <= y == x - y <= 0 does hold.
+    EXPECT_TRUE(CS.isConditionImplied({0, 1, -1}));
+    // y <= x == -x + y <= 0 does not hold.
+    EXPECT_FALSE(CS.isConditionImplied({0, -1, 1}));
+
+    // x <= y + 10 == x - y <= 10 does hold.
+    EXPECT_TRUE(CS.isConditionImplied({10, 1, -1}));
+    // x + 10 <= y == x - y <= -10 does NOT hold.
+    EXPECT_FALSE(CS.isConditionImplied({-10, 1, -1}));
+  }
+
+  {
+    // For the test below, we assume we know
+    // x <= y == x - y <= 0
+    // y <= z == y - x <= 0
+    ConstraintSystem CS;
+    CS.addVariableRow({0, 1, -1, 0});
+    CS.addVariableRow({0, 0, 1, -1});
+
+    // z <= y == -y + z <= 0 does not hold.
+    EXPECT_FALSE(CS.isConditionImplied({0, 0, -1, 1}));
+    // x <= z == x - z <= 0 does hold.
+    EXPECT_TRUE(CS.isConditionImplied({0, 1, 0, -1}));
+  }
+}
+
 } // namespace