[Bridges] change graph to favor Constraint bridges over Variable bridges

Author: odow

src/Bridges/debug.jl

@@ -664,7 +664,7 @@ function print_active_bridges(
             # The constraint can be both variable bridged and constraint
             # bridged. Which is cheaper?
             v_node = b.variable_node[(S,)]
-            if bridging_cost(b.graph, v_node) <= bridging_cost(b.graph, c_node)
+            if MOI.Bridges.is_variable_edge_best(b.graph, v_node)
                 return print_active_bridges(io, b, S, offset)
             end
         else

src/Bridges/graph.jl

@@ -330,7 +330,22 @@ constrained on creation, or as a free variable followed by a constraint.
 """
 function is_variable_edge_best(graph::Graph, node::VariableNode)
     _compute_bellman_ford(graph)
-    return graph.variable_dist[node.index] == _dist(graph, node)
+    # This is the cost of adding a constrained variable
+    dist_as_variable = graph.variable_dist[node.index]
+    # This is the cost of adding the constraint, if we were to add it.
+    dist_as_constraint = INFINITY
+    # If free variables are bridged but the functionize bridge was not
+    # added, constraint_node is `ConstraintNode(INVALID_NODE_INDEX)`.
+    constraint_node = graph.variable_constraint_node[node.index]
+    if constraint_node.index != INVALID_NODE_INDEX
+        dist_as_constraint = _dist(graph, constraint_node)
+        if dist_as_constraint != INFINITY
+            dist_as_constraint += graph.variable_constraint_cost[node.index]
+        end
+    end
+    # We should prefer the variable bridge ONLY if the cost is strictly less
+    # than bridging via constraints.
+    return dist_as_variable < dist_as_constraint
 end
 
 function _updated_dist(

src/Bridges/lazy_bridge_optimizer.jl

@@ -293,8 +293,17 @@ function node(
             )
         end
     else
-        # We add `+1` as we treat constrained variables as constraints.
-        set_variable_constraint_node(b.graph, variable_node, node(b, F, S), 1)
+        # Add a node to the graph so we can convert a constrained variable into
+        # a free variable plus a constraint. In MOI v1.50 and earlier, the cost
+        # associated with this node was +1. However, practice has shown that we
+        # want to encourage constraint bridges over variable bridges, and
+        # penalizing the switch from constrained variable to constraint with an
+        # additional +1 meant we often used a bridge like Variable.Vectorize.
+        # With +0 here, it's now better to use Constraint.Vectorize.
+        #
+        # For more details, see:
+        # https://github.com/jump-dev/ParametricOptInterface.jl/issues/201
+        set_variable_constraint_node(b.graph, variable_node, node(b, F, S), +0)
     end
     for (i, BT) in enumerate(b.variable_bridge_types)
         if Variable.supports_constrained_variable(BT, S)