Uniformize solver output status between LP and SDP

Author: apozas

inflation/sdp/InflationSDP.py

@@ -824,7 +824,7 @@ def solve(self,
         self.solution_object = solveSDP_MosekFUSION(**args)
 
         self.status = self.solution_object["status"]
-        if self.status == "feasible":
+        if self.status == "optimal":
             self.success = True
             self.primal_objective = self.solution_object["primal_value"]
             self.objective_value  = self.solution_object["primal_value"]

inflation/sdp/sdp_utils.py

@@ -462,13 +462,14 @@ def constraint_dicts_to_sparse(constraints: List[dict]) -> (coo_array, coo_array
 
             status = M.getProblemStatus()
             if status == ProblemStatus.PrimalAndDualFeasible:
-                status_str = "feasible"
+                status_str = "optimal"
                 primal     = M.primalObjValue()
                 dual       = M.dualObjValue()
 
-            elif status in [ProblemStatus.DualInfeasible,
-                            ProblemStatus.PrimalInfeasible]:
-                status_str = "infeasible"
+            elif status == ProblemStatus.DualInfeasible:
+                status_str = "dual_infeas_cer"
+            elif status == ProblemStatus.PrimalInfeasible:
+                status_str = "primal_infeas_cer",
             elif status == ProblemStatus.Unknown:
                 status_str = "unknown"
                 code, desc = mosek.Env.getcodedesc(
@@ -495,11 +496,11 @@ def constraint_dicts_to_sparse(constraints: List[dict]) -> (coo_array, coo_array
             return {"status": status_str, "error": error_message}
         except Exception as e:
             status_str = "other"
-            error_message = "Unexpected error: {0}".format(e)
+            error_message = f"Unexpected error: {e}"
             print(error_message)
             return {"status": status_str, "error": error_message}
 
-        if status_str in ["feasible", "infeasible"]:
+        if status_str in ["optimal", "primal_infeas_cer", "dual_infeas_cer"]:
             certificate = {x: 0 for x in known_vars}
 
             # c0(P(a...|x...))
@@ -533,7 +534,7 @@ def constraint_dicts_to_sparse(constraints: List[dict]) -> (coo_array, coo_array
                     del certificate[x]
 
             # For debugging purposes
-            if status_str == "feasible" and verbose > 1:
+            if status_str == "optimal" and verbose > 1:
                 TOL = 1e-8  # Constraint tolerance
                 if var_inequalities:
                     x = A.todense() \

test/test_pipeline.py

@@ -452,7 +452,7 @@ def test_GHZ_commuting(self):
 
         sdp.set_distribution(self.GHZ(0.5 + 1e-2))
         sdp.solve()
-        self.assertEqual(sdp.status, "infeasible",
+        self.assertEqual(sdp.status, "dual_infeas_cer",
                          "The commuting SDP is not identifying incompatible " +
                          "distributions.")
         lp_fanout = InflationLP(self.cutInflation_c)
@@ -473,7 +473,7 @@ def test_GHZ_commuting(self):
                         "is not identifying incompatible distributions.")
         sdp.set_distribution(self.GHZ(0.5 - 1e-2))
         sdp.solve()
-        self.assertEqual(sdp.status, "feasible",
+        self.assertEqual(sdp.status, "optimal",
                          "The commuting SDP is not recognizing compatible " +
                          "distributions.")
         lp_fanout.set_distribution(self.GHZ(0.5 - 1e-2))
@@ -506,7 +506,7 @@ def test_GHZ_NC(self):
                                    (0.5+1e-2) / 2 + (0.5-1e-2) / 8),
                         "Setting the distribution is failing.")
         sdp.solve()
-        self.assertTrue(sdp.status in ["infeasible", "unknown"],
+        self.assertTrue(sdp.status in ["dual_infeas_cer", "unknown"],
                         "The non-commuting SDP is not identifying " +
                         "incompatible distributions.")
         sdp.solve(feas_as_optim=True)
@@ -518,7 +518,7 @@ def test_GHZ_NC(self):
                                    (0.5-1e-2) / 2 + (0.5+1e-2) / 8),
                         "Re-setting the distribution is failing.")
         sdp.solve()
-        self.assertEqual(sdp.status, "feasible",
+        self.assertEqual(sdp.status, "optimal",
                          "The non-commuting SDP is not recognizing " +
                          "compatible distributions.")
         sdp.solve(feas_as_optim=True)
@@ -531,20 +531,20 @@ def test_instrumental(self):
         sdp.generate_relaxation("local1")
         sdp.set_distribution(self.incompatible_dist)
         sdp.solve(feas_as_optim=False)
-        self.assertEqual(sdp.status, "infeasible",
+        self.assertEqual(sdp.status, "dual_infeas_cer",
                          "Failing to detect the infeasibility of the " +
                          "distribution that maximally violates Bonet's " +
                          "inequalty.")
         unnormalized_dist = np.ones((2, 2, 3, 1), dtype=float)
         sdp.set_distribution(unnormalized_dist)
         sdp.solve(feas_as_optim=False)
-        self.assertEqual(sdp.status, "infeasible",
+        self.assertEqual(sdp.status, "dual_infeas_cer",
                          "Failing to detect the infeasibility of an " +
                          "distribution that violates normalization.")
         compat_dist = unnormalized_dist / 4
         sdp.set_distribution(compat_dist)
         sdp.solve(feas_as_optim=False)
-        self.assertEqual(sdp.status, "feasible",
+        self.assertEqual(sdp.status, "optimal",
                          "A feasible distribution for the instrumental " +
                          "scenario is not being recognized as such.")
 
@@ -615,13 +615,13 @@ def test_supports(self):
                 pr_support[a, b, x, y] = np.random.randn()
         sdp.set_distribution(pr_support)
         sdp.solve(feas_as_optim=False)
-        self.assertEqual(sdp.status, "infeasible",
+        self.assertEqual(sdp.status, "dual_infeas_cer",
                          "Failing to detect the infeasibility of a support "
                          + "known to be incompatible.")
         compatible_support = np.ones((2, 2, 2, 2), dtype=float)
         sdp.set_distribution(compatible_support)
         sdp.solve(feas_as_optim=False)
-        self.assertEqual(sdp.status, "feasible",
+        self.assertEqual(sdp.status, "optimal",
                          "A feasible support for the Bell scenario is not " +
                          "being recognized as such.")