Merge pull request #3 from lanl-ansi/include-var-in-set

Include variable-in-set constraints

Author: Robbybp

src/get_equality.jl

@@ -154,7 +154,7 @@ julia> display(eq_cons)
 function get_equality_constraints(model::JuMP.Model)::Vector{JuMP.ConstraintRef}
     constraints = JuMP.all_constraints(
         model,
-        include_variable_in_set_constraints=false,
+        include_variable_in_set_constraints=true,
     )
     return get_equality_constraints(constraints)
 end

src/identify_variables.jl

@@ -83,15 +83,16 @@ Each variable appears at most one time in the returned vector.
 function identify_unique_variables(
     model::JuMP.Model; include_inequality::Bool=false,
 )::Vector{JuMP.VariableRef}
+    # Note that this method exists mostly for convenience, and is not used
+    # by any of the "upstream" methods, e.g. get_bipartite_incidence_graph
     if include_inequality
         # Note that this may include some constraints which are not compatible
         # with downstream function calls (e.g. constraints where the function
         # and terms are vectors). We will allow downstream errors to be raised
         # rather than silently ignoring these constraints.
         constraints = JuMP.all_constraints(
             model,
-            # TODO: Should this be an optional argument to this function?
-            include_variable_in_set_constraints=false,
+            include_variable_in_set_constraints=true,
         )   
     else
         constraints = get_equality_constraints(model)
@@ -227,6 +228,12 @@ function identify_unique_variables(
     ))
 end
 
+function identify_unique_variables(
+    var::MOI.VariableIndex
+)::Vector{MOI.VariableIndex}
+    return [var]
+end
+
 
 """
     _get_variable_terms(fcn)

src/incidence_graph.jl

@@ -87,10 +87,17 @@ function get_bipartite_incidence_graph(
     include_inequality::Bool = false,
 )
     if include_inequality
+        # Note that this may generate some constraints that are incompatible
+        # with downstream function calls (e.g. constraints involving vector
+        # expressions).
+        #
+        # This is also repeated in identify_unique_variables(Model).
+        # Identifying all constraints (including inequalities, but probably
+        # not including VectorFunction constraints) may be something we want
+        # to standardize at some point. E.g. a get_scalar_constraints function.
         constraints = JuMP.all_constraints(
             model,
-            # TODO: Should this be an optional argument to this function?
-            include_variable_in_set_constraints=false,
+            include_variable_in_set_constraints = true,
         )   
     else
         constraints = get_equality_constraints(model)

test/get_equality.jl

@@ -18,7 +18,7 @@
 #  ___________________________________________________________________________
 
 module TestGetEquality
-import JuMP as jmp
+import JuMP
 import MathOptInterface as moi
 using Test: @test, @test_throws
 using JuMPIn: get_equality_constraints
@@ -28,9 +28,9 @@ include("models.jl") # Models
 function get_flow_model_with_inequalities()
     m = Models.make_degenerate_flow_model()
     # TODO: Some assertions with the @assert macro
-    @jmp.constraint(m, ineq1, m[:x][1] >= 0)
-    @jmp.constraint(m, ineq2, m[:x][1]^2 + m[:x][2]^2 <= 0.5)
-    @jmp.NLconstraint(m, ineq3, sqrt(m[:x][3]) >= 0.1)
+    @JuMP.constraint(m, ineq1, m[:x][1] >= 0)
+    @JuMP.constraint(m, ineq2, m[:x][1]^2 + m[:x][2]^2 <= 0.5)
+    @JuMP.NLconstraint(m, ineq3, sqrt(m[:x][3]) >= 0.1)
     return m
 end
 
@@ -42,15 +42,27 @@ function test_flow_model_with_inequalities()
 end
 
 function test_with_vector_constraint()
-    m = jmp.Model()
-    @jmp.variable(m, var[1:2])
-    @jmp.constraint(m, con, var in moi.Nonnegatives(2))
+    m = JuMP.Model()
+    @JuMP.variable(m, var[1:2])
+    @JuMP.constraint(m, con, var in moi.Nonnegatives(2))
     @test_throws(TypeError, eq_cons = get_equality_constraints(m))
 end
 
+function test_with_fixed_variables()
+    m = JuMP.Model()
+    @JuMP.variable(m, x[1:2])
+    # These bound constraints are picked up, then discarded as the
+    # one-sided interval sets never "imply equality"
+    @JuMP.variable(m, 0 <= y <= 1)
+    JuMP.fix(x[1], 1.0)
+    eq_cons = get_equality_constraints(m)
+    @test length(eq_cons) == 1
+end
+
 function runtests()
     test_flow_model_with_inequalities()
     test_with_vector_constraint()
+    test_with_fixed_variables()
 end
 
 end # module TestGetEquality

test/identify_variables.jl

@@ -179,6 +179,26 @@ function test_model_bad_constr_no_ineq()
     )
 end
 
+function test_fixing_constraint()
+    m = jmp.Model()
+    @jmp.variable(m, x[1:2])
+    jmp.fix(x[1], 1)
+    fixing_con = jmp.FixRef(x[1])
+    variables = identify_unique_variables(fixing_con)
+    @test length(variables) == 1
+    @test variables[1] === x[1]
+end
+
+function test_inequality_with_bounds()
+    m = jmp.Model()
+    @jmp.variable(m, x[1:2])
+    @jmp.variable(m, 0 <= y[1:2])
+    @jmp.constraint(m, x[1] + 2*x[2]^2 == 1)
+    variables = identify_unique_variables(m, include_inequality = true)
+    pred_var_set = Set([x[1], x[2], y[1], y[2]])
+    @test Set(variables) == pred_var_set
+end
+
 function runtests()
     test_linear()
     test_quadratic()
@@ -191,6 +211,8 @@ function runtests()
     test_model_bad_constr()
     test_model_bad_constr_no_ineq()
     test_function_with_variable_squared()
+    test_fixing_constraint()
+    test_inequality_with_bounds()
     return
 end
 

test/incidence_graph.jl

@@ -93,9 +93,25 @@ function test_get_incidence_graph_badconstraint()
     return
 end
 
+function test_include_bound_as_inequality()
+    m = jmp.Model()
+    @jmp.variable(m, 0 <= x[1:2])
+    @jmp.constraint(m, eq1, x[1] + 2*x[2] == 1)
+    graph, con_node_map, var_node_map = get_bipartite_incidence_graph(
+        m, include_inequality = true
+    )
+    A, B, E = graph
+    @test length(A) == 3
+    @test length(B) == 2
+    @test length(E) == 4
+    pred_con_set = Set([eq1, jmp.LowerBoundRef(x[1]), jmp.LowerBoundRef(x[2])])
+    @test pred_con_set == keys(con_node_map)
+end
+
 function runtests()
     test_get_incidence_graph()
     test_get_incidence_graph_badconstraint()
+    test_include_bound_as_inequality()
     return
 end
 

test/interface.jl

@@ -20,7 +20,7 @@
 module TestInterface
 
 using Test: @test, @test_throws
-import JuMP as jmp
+import JuMP
 import JuMPIn as ji
 
 # Note: Do not import from IncidenceGraphInterface here; this will
@@ -80,7 +80,7 @@ end
 
 function test_construct_interface_rectangular()
     m = make_degenerate_flow_model()
-    @jmp.constraint(
+    @JuMP.constraint(
         m,
         sum_flow_eqn,
         m[:flow] == sum(m[:flow_comp][:]),
@@ -165,8 +165,8 @@ function test_maximum_matching()
     matching = ji.maximum_matching(igraph)
     @test length(matching) == 7
     for (con, var) in matching
-        @test typeof(con) <: jmp.ConstraintRef
-        @test typeof(var) <: jmp.VariableRef
+        @test typeof(con) <: JuMP.ConstraintRef
+        @test typeof(var) <: JuMP.VariableRef
         @test var in Set(ji.get_adjacent(igraph, con))
         @test con in Set(ji.get_adjacent(igraph, var))
     end
@@ -225,6 +225,32 @@ function test_dulmage_mendelsohn()
     return nothing
 end
 
+function test_overconstrained_due_to_fixed_variable()
+    m = JuMP.Model()
+    @JuMP.variable(m, x[1:2])
+    @JuMP.constraint(m, x[1] + 2*x[2] == 1)
+    @JuMP.constraint(m, 3*x[2] - x[2] == 0)
+    JuMP.fix(x[1], 3)
+    igraph = ji.IncidenceGraphInterface(m)
+    con_dmp, var_dmp = ji.dulmage_mendelsohn(igraph)
+    @test length(var_dmp.overconstrained) == 2
+    @test length(con_dmp.overconstrained) == 2
+    @test length(con_dmp.unmatched) == 1
+end
+
+function test_overconstrained_due_to_including_bound()
+    m = JuMP.Model()
+    @JuMP.variable(m, x)
+    @JuMP.variable(m, 0.01 <= y)
+    @JuMP.constraint(m, 2*x + y == 1)
+    @JuMP.NLconstraint(m, x == sqrt(y))
+    igraph = ji.IncidenceGraphInterface(m, include_inequality = true)
+    con_dmp, var_dmp = ji.dulmage_mendelsohn(igraph)
+    @test length(var_dmp.overconstrained) == 2
+    @test length(con_dmp.overconstrained) == 2
+    @test length(con_dmp.unmatched) == 1
+end
+
 function runtests()
     test_construct_interface()
     test_construct_interface_rectangular()
@@ -234,6 +260,8 @@ function runtests()
     test_get_adjacent_to_variable()
     test_maximum_matching()
     test_dulmage_mendelsohn()
+    test_overconstrained_due_to_fixed_variable()
+    test_overconstrained_due_to_including_bound()
 end
 
 end