sleipnirgroup-jormungandr 0.6.6.dev17__tar.gz → 0.6.6.dev19__tar.gz

{sleipnirgroup_jormungandr-0.6.6.dev17 → sleipnirgroup_jormungandr-0.6.6.dev19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sleipnirgroup-jormungandr
-Version: 0.6.6.dev17
+Version: 0.6.6.dev19
 Summary: Reverse mode autodiff library and NLP solver DSL
 License-Expression: BSD-3-Clause
 License-File: LICENSE.txt

{sleipnirgroup_jormungandr-0.6.6.dev17 → sleipnirgroup_jormungandr-0.6.6.dev19}/include/sleipnir/optimization/solver/interior_point.hpp

@@ -21,7 +21,6 @@
 #include "sleipnir/optimization/solver/util/feasibility_restoration.hpp"
 #include "sleipnir/optimization/solver/util/filter.hpp"
 #include "sleipnir/optimization/solver/util/fraction_to_the_boundary_rule.hpp"
-#include "sleipnir/optimization/solver/util/is_locally_infeasible.hpp"
 #include "sleipnir/optimization/solver/util/kkt_error.hpp"
 #include "sleipnir/optimization/solver/util/regularized_ldlt.hpp"
 #include "sleipnir/util/assert.hpp"
@@ -383,24 +382,6 @@ ExitStatus interior_point(
     ScopedProfiler inner_iter_profiler{inner_iter_prof};
     ScopedProfiler feasibility_check_profiler{feasibility_check_prof};
 
-    // Check for local equality constraint infeasibility
-    if (is_equality_locally_infeasible(A_e, c_e)) {
-      if (options.diagnostics) {
-        print_c_e_local_infeasibility_error(c_e);
-      }
-
-      return ExitStatus::LOCALLY_INFEASIBLE;
-    }
-
-    // Check for local inequality constraint infeasibility
-    if (is_inequality_locally_infeasible(A_i, c_i)) {
-      if (options.diagnostics) {
-        print_c_i_local_infeasibility_error(c_i);
-      }
-
-      return ExitStatus::LOCALLY_INFEASIBLE;
-    }
-
     // Check for diverging iterates
     if (x.template lpNorm<Eigen::Infinity>() > Scalar(1e10) || !x.allFinite() ||
         s.template lpNorm<Eigen::Infinity>() > Scalar(1e10) || !s.allFinite()) {

{sleipnirgroup_jormungandr-0.6.6.dev17 → sleipnirgroup_jormungandr-0.6.6.dev19}/include/sleipnir/optimization/solver/sqp.hpp

@@ -19,7 +19,6 @@
 #include "sleipnir/optimization/solver/util/append_as_triplets.hpp"
 #include "sleipnir/optimization/solver/util/feasibility_restoration.hpp"
 #include "sleipnir/optimization/solver/util/filter.hpp"
-#include "sleipnir/optimization/solver/util/is_locally_infeasible.hpp"
 #include "sleipnir/optimization/solver/util/kkt_error.hpp"
 #include "sleipnir/optimization/solver/util/regularized_ldlt.hpp"
 #include "sleipnir/util/assert.hpp"
@@ -260,15 +259,6 @@ ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
     ScopedProfiler inner_iter_profiler{inner_iter_prof};
     ScopedProfiler feasibility_check_profiler{feasibility_check_prof};
 
-    // Check for local equality constraint infeasibility
-    if (is_equality_locally_infeasible(A_e, c_e)) {
-      if (options.diagnostics) {
-        print_c_e_local_infeasibility_error(c_e);
-      }
-
-      return ExitStatus::LOCALLY_INFEASIBLE;
-    }
-
     // Check for diverging iterates
     if (x.template lpNorm<Eigen::Infinity>() > Scalar(1e10) || !x.allFinite()) {
       return ExitStatus::DIVERGING_ITERATES;

{sleipnirgroup_jormungandr-0.6.6.dev17 → sleipnirgroup_jormungandr-0.6.6.dev19}/include/sleipnir/optimization/solver/util/bounds.hpp

@@ -215,7 +215,7 @@ void project_onto_bounds(
     // We assume that bound infeasibility is handled elsewhere.
     slp_assert(lower <= upper);
 
-    // See B.2 in [5] and section 3.6 in [2]
+    // See B.2 in [4] and section 3.6 in [2]
     if (isfinite(lower) && isfinite(upper)) {
       auto p_L = std::min(κ_1 * std::max(Scalar(1), abs(lower)),
                           κ_2 * (upper - lower));

{sleipnirgroup_jormungandr-0.6.6.dev17 → sleipnirgroup_jormungandr-0.6.6.dev19}/include/sleipnir/optimization/solver/util/feasibility_restoration.hpp

@@ -21,6 +21,7 @@
 #include "sleipnir/optimization/solver/util/append_as_triplets.hpp"
 #include "sleipnir/optimization/solver/util/lagrange_multiplier_estimate.hpp"
 #include "sleipnir/optimization/solver/util/problem_scaling.hpp"
+#include "sleipnir/util/print_diagnostics.hpp"
 
 namespace slp {
 
@@ -318,7 +319,26 @@ ExitStatus feasibility_restoration(
 
     return ExitStatus::SUCCESS;
   } else if (status == ExitStatus::SUCCESS) {
-    return ExitStatus::LOCALLY_INFEASIBLE;
+    // Feasibility restoration converged to a minimizer of the constraint
+    // violation. If the constraint violation is still above the tolerance,
+    // that minimizer is a certificate of local infeasibility. Declaring local
+    // infeasibility anywhere else risks false positives (e.g., a
+    // point-in-time test can reject iterates the solver would otherwise
+    // escape). See section 3.3, p. 14 of [2].
+    DenseVector c_e = matrices.c_e(x);
+    if (matrices.scaling.c_e.size() > 0) {
+      c_e = matrices.scaling.c_e.cwiseInverse().cwiseProduct(c_e);
+    }
+
+    if (c_e.template lpNorm<Eigen::Infinity>() > Scalar(options.tolerance)) {
+      if (options.diagnostics) {
+        print_c_e_local_infeasibility_error(c_e, Scalar(options.tolerance));
+      }
+
+      return ExitStatus::LOCALLY_INFEASIBLE;
+    }
+
+    return ExitStatus::FEASIBILITY_RESTORATION_FAILED;
   } else {
     return ExitStatus::FEASIBILITY_RESTORATION_FAILED;
   }
@@ -621,7 +641,45 @@ ExitStatus feasibility_restoration(
 
     return ExitStatus::SUCCESS;
   } else if (status == ExitStatus::SUCCESS) {
-    return ExitStatus::LOCALLY_INFEASIBLE;
+    // Feasibility restoration converged to a minimizer of the constraint
+    // violation. If the constraint violation is still above the tolerance,
+    // that minimizer is a certificate of local infeasibility. Declaring local
+    // infeasibility anywhere else risks false positives (e.g., a
+    // point-in-time test can reject iterates the solver would otherwise
+    // escape). See section 3.3, p. 14 of [2].
+    DenseVector c_e = matrices.c_e(x);
+    if (matrices.scaling.c_e.size() > 0) {
+      c_e = matrices.scaling.c_e.cwiseInverse().cwiseProduct(c_e);
+    }
+
+    DenseVector c_i = matrices.c_i(x);
+    if (matrices.scaling.c_i.size() > 0) {
+      c_i = matrices.scaling.c_i.cwiseInverse().cwiseProduct(c_i);
+    }
+
+    // Inequality constraints cᵢ(x) ≥ 0 are only violated where they're
+    // negative
+    const DenseVector c_i_violation = (-c_i).cwiseMax(Scalar(0));
+
+    const bool c_e_violated =
+        c_e.template lpNorm<Eigen::Infinity>() > Scalar(options.tolerance);
+    const bool c_i_violated = c_i_violation.template lpNorm<Eigen::Infinity>() >
+                              Scalar(options.tolerance);
+
+    if (c_e_violated || c_i_violated) {
+      if (options.diagnostics) {
+        if (c_e_violated) {
+          print_c_e_local_infeasibility_error(c_e, Scalar(options.tolerance));
+        }
+        if (c_i_violated) {
+          print_c_i_local_infeasibility_error(c_i, Scalar(options.tolerance));
+        }
+      }
+
+      return ExitStatus::LOCALLY_INFEASIBLE;
+    }
+
+    return ExitStatus::FEASIBILITY_RESTORATION_FAILED;
   } else {
     return ExitStatus::FEASIBILITY_RESTORATION_FAILED;
   }

{sleipnirgroup_jormungandr-0.6.6.dev17 → sleipnirgroup_jormungandr-0.6.6.dev19}/include/sleipnir/optimization/solver/util/filter.hpp

@@ -131,7 +131,7 @@ class Filter {
 
     // Sufficient decrease condition
     //
-    // See equation (2.13) of [4].
+    // See equation (2.13) of [3].
     Scalar ϕ = pow(α, Scalar(1.5));
     bool sufficient_decrease =
         trial_entry.cost <=

{sleipnirgroup_jormungandr-0.6.6.dev17 → sleipnirgroup_jormungandr-0.6.6.dev19}/include/sleipnir/util/print_diagnostics.hpp

@@ -110,15 +110,19 @@ void print_too_few_dofs_error(
 /// @tparam Scalar Scalar type.
 /// @param c_e The problem's equality constraints cₑ(x) evaluated at the current
 ///     iterate.
+/// @param tolerance Constraint violations at or below this tolerance aren't
+///     printed.
 template <typename Scalar>
 void print_c_e_local_infeasibility_error(
-    const Eigen::Vector<Scalar, Eigen::Dynamic>& c_e) {
+    const Eigen::Vector<Scalar, Eigen::Dynamic>& c_e, Scalar tolerance) {
+  using std::abs;
+
   slp::println(
       "The problem is locally infeasible due to violated equality "
       "constraints.");
   slp::println("Violated constraints (cₑ(x) = 0) in order of declaration:");
   for (int row = 0; row < c_e.rows(); ++row) {
-    if (c_e[row] < Scalar(0)) {
+    if (abs(c_e[row]) > tolerance) {
       slp::println("  {}/{}: {} = 0", row + 1, c_e.rows(), c_e[row]);
     }
   }
@@ -133,15 +137,17 @@ void print_c_e_local_infeasibility_error(
 /// @tparam Scalar Scalar type.
 /// @param c_i The problem's inequality constraints cᵢ(x) evaluated at the
 ///     current iterate.
+/// @param tolerance Constraint violations at or below this tolerance aren't
+///     printed.
 template <typename Scalar>
 void print_c_i_local_infeasibility_error(
-    const Eigen::Vector<Scalar, Eigen::Dynamic>& c_i) {
+    const Eigen::Vector<Scalar, Eigen::Dynamic>& c_i, Scalar tolerance) {
   slp::println(
       "The problem is locally infeasible due to violated inequality "
       "constraints.");
   slp::println("Violated constraints (cᵢ(x) ≥ 0) in order of declaration:");
   for (int row = 0; row < c_i.rows(); ++row) {
-    if (c_i[row] < Scalar(0)) {
+    if (c_i[row] < -tolerance) {
       slp::println("  {}/{}: {} ≥ 0", row + 1, c_i.rows(), c_i[row]);
     }
   }

{sleipnirgroup_jormungandr-0.6.6.dev17 → sleipnirgroup_jormungandr-0.6.6.dev19}/python/src/sleipnir/__init__.py

@@ -2,4 +2,4 @@
 
 from ._sleipnir import *
 
-__version__ = "0.6.6.dev17"
+__version__ = "0.6.6.dev19"

{sleipnirgroup_jormungandr-0.6.6.dev17 → sleipnirgroup_jormungandr-0.6.6.dev19}/python/test/optimization/solver/exit_status_test.py

@@ -1,5 +1,6 @@
 """These tests ensure coverage of the off-nominal exit statuses"""
 
+import pytest
 from sleipnir.autodiff import ExpressionType, sqrt
 from sleipnir.optimization import ExitStatus, Problem
 
@@ -72,6 +73,38 @@ def test_locally_infeasible_inequality_constraints():
     assert problem.solve(diagnostics=True) == ExitStatus.LOCALLY_INFEASIBLE
 
 
+def test_small_equality_constraint_scaling_is_feasible():
+    problem = Problem()
+
+    x = problem.decision_variable()
+    x.set_value(5005)
+
+    problem.subject_to(1e-5 * (x - 5) == 0)
+
+    assert problem.cost_function_type() == ExpressionType.NONE
+    assert problem.equality_constraint_type() == ExpressionType.LINEAR
+    assert problem.inequality_constraint_type() == ExpressionType.NONE
+
+    assert problem.solve(diagnostics=True) == ExitStatus.SUCCESS
+    assert x.value() == pytest.approx(5, abs=1e-3)
+
+
+def test_small_inequality_constraint_scaling_is_feasible():
+    problem = Problem()
+
+    x = problem.decision_variable()
+    x.set_value(5005)
+
+    problem.subject_to(1e-5 * (5 - x) >= 0)
+
+    assert problem.cost_function_type() == ExpressionType.NONE
+    assert problem.equality_constraint_type() == ExpressionType.NONE
+    assert problem.inequality_constraint_type() == ExpressionType.LINEAR
+
+    assert problem.solve(diagnostics=True) == ExitStatus.SUCCESS
+    assert x.value() <= 5 + 1e-3
+
+
 def test_nonfinite_cost():
     problem = Problem()
     x = problem.decision_variable()

sleipnirgroup_jormungandr-0.6.6.dev17/include/sleipnir/optimization/solver/util/is_locally_infeasible.hpp

@@ -1,62 +0,0 @@
-// Copyright (c) Sleipnir contributors
-
-#pragma once
-
-#include <Eigen/Core>
-#include <Eigen/SparseCore>
-
-// See docs/algorithms.md#Works_cited for citation definitions
-
-namespace slp {
-
-/// Returns true if the problem's equality constraints are locally infeasible.
-///
-/// @tparam Scalar Scalar type.
-/// @param A_e Equality constraint Jacobian Aₑ(x).
-/// @param c_e Equality constraints cₑ(x).
-template <typename Scalar>
-bool is_equality_locally_infeasible(
-    const Eigen::SparseMatrix<Scalar>& A_e,
-    const Eigen::Vector<Scalar, Eigen::Dynamic>& c_e) {
-  // The equality constraints are locally infeasible if
-  //
-  //   Aₑᵀcₑ → 0
-  //   ‖cₑ‖ > ε
-  //
-  // See "Infeasibility detection" in section 6 of [3].
-  return A_e.rows() > 0 && (A_e.transpose() * c_e).norm() < Scalar(1e-6) &&
-         c_e.norm() > Scalar(1e-2);
-}
-
-/// Returns true if the problem's inequality constraints are locally infeasible.
-///
-/// @tparam Scalar Scalar type.
-/// @param A_i Inequality constraint Jacobian Aᵢ(x).
-/// @param c_i Inequality constraints cᵢ(x).
-template <typename Scalar>
-bool is_inequality_locally_infeasible(
-    const Eigen::SparseMatrix<Scalar>& A_i,
-    const Eigen::Vector<Scalar, Eigen::Dynamic>& c_i) {
-  // The inequality constraints are locally infeasible if
-  //
-  //   Aᵢᵀcᵢ⁺ → 0
-  //   ‖cᵢ⁺‖ > ε
-  //
-  // where cᵢ⁺ = min(cᵢ, 0).
-  //
-  // See "Infeasibility detection" in section 6 of [3].
-  //
-  // cᵢ⁺ is used instead of cᵢ⁻ from the paper to follow the convention that
-  // feasible inequality constraints are ≥ 0.
-  if (A_i.rows() > 0) {
-    Eigen::Vector<Scalar, Eigen::Dynamic> c_i_plus = c_i.cwiseMin(Scalar(0));
-    if ((A_i.transpose() * c_i_plus).norm() < Scalar(1e-6) &&
-        c_i_plus.norm() > Scalar(1e-6)) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-}  // namespace slp