Make dual program

bindings/pydrake/solvers/BUILD.bazel

@@ -71,6 +71,7 @@ drake_pybind_library(
         "solvers_py_scs.cc",
         "solvers_py_sdpa_free_format.cc",
         "solvers_py_semidefinite_relaxation.cc",
+        "solvers_py_dual_convex_program.cc",
         "solvers_py_snopt.cc",
         "solvers_py_unrevised_lemke.cc",
     ],

bindings/pydrake/solvers/solvers_py.cc

@@ -22,6 +22,7 @@ top-level documentation for :py:mod:`pydrake.math`.
   internal::DefineSolversMathematicalProgram(m);
   internal::DefineSolversAugmentedLagrangian(m);
   internal::DefineSolversBranchAndBound(m);
+  internal::DefineSolversDualConvexProgram(m);
   internal::DefineSolversMixedIntegerOptimizationUtil(m);
   internal::DefineSolversMixedIntegerRotationConstraint(m);
   internal::DefineSolversSdpaFreeFormat(m);

bindings/pydrake/solvers/solvers_py.h

@@ -18,6 +18,9 @@ void DefineSolversAugmentedLagrangian(py::module m);
 /* Defines bindings per solvers_py_branch_and_bound.cc. */
 void DefineSolversBranchAndBound(py::module m);
 
+/* Defines bindings per solvers_py_dual_convex_program.cc. */
+void DefineSolversDualConvexProgram(py::module m);
+
 /* Defines the Clarabel bindings. See solvers_py_clarabel.cc. */
 void DefineSolversClarabel(py::module m);
 

bindings/pydrake/solvers/solvers_py_dual_convex_program.cc

@@ -0,0 +1,30 @@
+#include "drake/bindings/pydrake/common/eigen_pybind.h"
+#include "drake/bindings/pydrake/documentation_pybind.h"
+#include "drake/bindings/pydrake/pydrake_pybind.h"
+#include "drake/bindings/pydrake/solvers/solvers_py.h"
+#include "drake/bindings/pydrake/symbolic_types_pybind.h"
+#include "drake/solvers/dual_convex_program.h"
+
+namespace drake {
+namespace pydrake {
+namespace internal {
+
+void DefineSolversDualConvexProgram(py::module m) {
+  // NOLINTNEXTLINE(build/namespaces): Emulate placement in namespace.
+  using namespace drake::solvers;
+  constexpr auto& doc = pydrake_doc.drake.solvers;
+
+  m.def(
+      "CreateDualConvexProgram",
+      [](const MathematicalProgram& prog) {
+        std::unordered_map<Binding<Constraint>, MatrixX<symbolic::Expression>>
+            constraint_to_dual_variable_map;
+        CreateDualConvexProgram(prog, &constraint_to_dual_variable_map);
+        return constraint_to_dual_variable_map;
+      },
+      py::arg("prog"), doc.CreateDualConvexProgram.doc);
+}
+
+}  // namespace internal
+}  // namespace pydrake
+}  // namespace drake

bindings/pydrake/solvers/test/dual_convex_program.py

@@ -0,0 +1,24 @@
+import numpy as np
+import unittest
+
+from pydrake.solvers import (
+    CreateDualConvexProgram,
+    MathematicalProgram,
+)
+from pydrake.symbolic import Variables
+
+
+class TestDualConvexProgram(unittest.TestCase):
+    def test_CreateDualConvexProgram(self):
+        prog = MathematicalProgram()
+        y = prog.NewContinuousVariables(2, "y")
+        A = np.array([[0.5, 0.7], [-.2, 0.4], [-2.3, -4.5]])
+        lb = np.array([1.3, -.24, 0.25])
+        ub = np.array([5.6, 0.1, 1.4])
+        prog.AddLinearConstraint(A, lb, ub, y)
+        dual_prog = CreateDualConvexProgram(prog=prog)
+
+        self.assertEqual(dual_prog.num_vars(), 6)
+        self.assertEqual(len(dual_prog.linear_equality_constraints()),
+                         1)
+        self.assertEqual(len(dual_prog.linear_constraints(), 1))

solvers/BUILD.bazel

@@ -42,6 +42,7 @@ drake_cc_package_library(
         ":create_cost",
         ":csdp_solver",
         ":decision_variable",
+        ":dual_convex_program",
         ":equality_constrained_qp_solver",
         ":evaluator_base",
         ":function",
@@ -425,6 +426,7 @@ drake_cc_library(
     ],
     deps = [
         "//math:eigen_sparse_triplet",
+        "//math:matrix_util",
     ],
 )
 
@@ -1093,6 +1095,19 @@ drake_cc_library(
     deps = [],
 )
 
+drake_cc_library(
+    name = "dual_convex_program",
+    srcs = ["dual_convex_program.cc"],
+    hdrs = ["dual_convex_program.h"],
+    interface_deps = [
+        ":mathematical_program",
+    ],
+    deps = [
+        ":aggregate_costs_constraints",
+        "//math:matrix_util",
+    ],
+)
+
 drake_cc_optional_library(
     name = "csdp_solver_error_handling",
     opt_out_condition = "//tools:no_csdp",
@@ -2048,4 +2063,22 @@ drake_cc_googletest(
     ],
 )
 
+drake_cc_googletest(
+    name = "dual_convex_program_test",
+    deps = [
+        ":aggregate_costs_constraints",
+        ":choose_best_solver",
+        ":dual_convex_program",
+        ":linear_program_examples",
+        ":mathematical_program",
+        ":mathematical_program_test_util",
+        ":second_order_cone_program_examples",
+        ":semidefinite_program_examples",
+        ":solve",
+        ":sos_examples",
+        "//common/test_utilities:eigen_matrix_compare",
+        "//common/test_utilities:expect_throws_message",
+    ],
+)
+
 add_lint_tests(enable_clang_format_lint = False)