def test_quadratic_program_element_when_loaded_from_source(self):
     """Test QuadraticProgramElement when QuadraticProgram is loaded from an external source"""
     with self.subTest("from_ising"):
         q_p = QuadraticProgram()
         q_p.from_ising(PauliSumOp.from_list([("IZ", 1), ("ZZ", 2)]))
         self.assertEqual(id(q_p.objective.quadratic_program), id(q_p))
         for elem in q_p.variables:
             self.assertEqual(id(elem.quadratic_program), id(q_p))
         for elem in q_p.linear_constraints:
             self.assertEqual(id(elem.quadratic_program), id(q_p))
         for elem in q_p.quadratic_constraints:
             self.assertEqual(id(elem.quadratic_program), id(q_p))
     try:
         lp_file = self.get_resource_path("test_quadratic_program.lp",
                                          "problems/resources")
         q_p = QuadraticProgram()
         q_p.read_from_lp_file(lp_file)
         self.assertEqual(id(q_p.objective.quadratic_program), id(q_p))
         for elem in q_p.variables:
             self.assertEqual(id(elem.quadratic_program), id(q_p))
         for elem in q_p.linear_constraints:
             self.assertEqual(id(elem.quadratic_program), id(q_p))
         for elem in q_p.quadratic_constraints:
             self.assertEqual(id(elem.quadratic_program), id(q_p))
     except RuntimeError as ex:
         self.fail(str(ex))
Ejemplo n.º 2
0
 def test_maximize_to_minimize(self):
     """Test maximization to minimization conversion"""
     op_max = QuadraticProgram()
     op_min = QuadraticProgram()
     for i in range(2):
         op_max.binary_var(name="x{}".format(i))
         op_min.binary_var(name="x{}".format(i))
     op_max.integer_var(name="x{}".format(2), lowerbound=-3, upperbound=3)
     op_min.integer_var(name="x{}".format(2), lowerbound=-3, upperbound=3)
     op_max.maximize(constant=3,
                     linear={"x0": 1},
                     quadratic={("x1", "x2"): 2})
     op_min.minimize(constant=3,
                     linear={"x0": 1},
                     quadratic={("x1", "x2"): 2})
     # check conversion of maximization problem
     conv = MaximizeToMinimize()
     op_conv = conv.convert(op_max)
     self.assertEqual(op_conv.objective.sense,
                      op_conv.objective.Sense.MINIMIZE)
     x = [0, 1, 2]
     fval_min = op_conv.objective.evaluate(conv.interpret(x))
     self.assertAlmostEqual(fval_min, -7)
     self.assertAlmostEqual(op_max.objective.evaluate(x), -fval_min)
     # check conversion of minimization problem
     op_conv = conv.convert(op_min)
     self.assertEqual(op_conv.objective.sense, op_min.objective.sense)
     fval_min = op_conv.objective.evaluate(conv.interpret(x))
     self.assertAlmostEqual(op_min.objective.evaluate(x), fval_min)
Ejemplo n.º 3
0
 def test_penalty_recalculation_when_reusing2(self):
     """Test the penalty retrieval and recalculation of LinearEqualityToPenalty 2"""
     op = QuadraticProgram()
     op.binary_var("x")
     op.binary_var("y")
     op.binary_var("z")
     op.minimize(constant=3, linear={"x": 1}, quadratic={("x", "y"): 2})
     op.linear_constraint(linear={
         "x": 1,
         "y": 1,
         "z": 1
     },
                          sense="EQ",
                          rhs=2,
                          name="xyz_eq")
     # First, create a converter with no penalty
     lineq2penalty = LinearEqualityToPenalty()
     self.assertIsNone(lineq2penalty.penalty)
     # Then converter must calculate the penalty for the problem (should be 4.0)
     lineq2penalty.convert(op)
     self.assertEqual(4, lineq2penalty.penalty)
     # Re-use the converter for a new problem
     op2 = QuadraticProgram()
     op2.binary_var("x")
     op2.minimize(linear={"x": 10})
     op2.linear_constraint({"x": 1}, "==", 0)
     lineq2penalty.convert(op2)
     self.assertEqual(11, lineq2penalty.penalty)
    def test_str_repr(self):
        """Test str and repr"""
        with self.subTest("5 variables"):
            n = 5
            quadratic_program = QuadraticProgram()
            quadratic_program.binary_var_list(n)  # x0,...,x4
            expr = LinearExpression(quadratic_program,
                                    [float(e) for e in range(n)])
            self.assertEqual(str(expr), "x1 + 2*x2 + 3*x3 + 4*x4")
            self.assertEqual(repr(expr),
                             "<LinearExpression: x1 + 2*x2 + 3*x3 + 4*x4>")

        with self.subTest("50 variables"):
            # pylint: disable=cyclic-import
            from qiskit_optimization.translators.prettyprint import DEFAULT_TRUNCATE

            n = 50
            quadratic_program = QuadraticProgram()
            quadratic_program.binary_var_list(n)  # x0,...,x49
            expr = LinearExpression(quadratic_program,
                                    [float(e) for e in range(n)])

            expected = " ".join(["x1"] +
                                sorted([f"+ {i}*x{i}" for i in range(2, n)],
                                       key=lambda e: e.split(" ")[1]))
            self.assertEqual(str(expr), expected)
            self.assertEqual(
                repr(expr),
                f"<LinearExpression: {expected[:DEFAULT_TRUNCATE]}...>")
Ejemplo n.º 5
0
 def test_valid_variable_type(self):
     """Validate the types of the variables for QuadraticProgram.to_ising."""
     # Integer variable
     with self.assertRaises(QiskitOptimizationError):
         op = QuadraticProgram()
         op.integer_var(0, 10, "int_var")
         _ = op.to_ising()
     # Continuous variable
     with self.assertRaises(QiskitOptimizationError):
         op = QuadraticProgram()
         op.continuous_var(0, 10, "continuous_var")
         _ = op.to_ising()
    def test_linear_inequality_to_penalty4(self):
        """Test special constraint to penalty x1+x2+x3+... <= 1 -> P(x1*x2+x1*x3+...)"""

        op = QuadraticProgram()
        lip = LinearInequalityToPenalty()

        op.binary_var(name="x")
        op.binary_var(name="y")
        op.binary_var(name="z")
        # Linear constraints
        linear_constraint = {"x": 1, "y": 1, "z": 1}
        op.linear_constraint(linear_constraint, Constraint.Sense.LE, 1,
                             "P(xy+yz+zx)")

        # Test with no max/min
        with self.subTest("No max/min"):
            self.assertEqual(op.get_num_linear_constraints(), 1)
            penalty = 1
            quadratic = {
                ("x", "y"): penalty,
                ("x", "z"): penalty,
                ("y", "z"): penalty
            }
            op2 = lip.convert(op)
            qdct = op2.objective.quadratic.to_dict(use_name=True)
            self.assertEqual(qdct, quadratic)
            self.assertEqual(op2.get_num_linear_constraints(), 0)

        # Test maximize
        op = QuadraticProgram()
        op.binary_var_list(5)
        linear2 = [1, 1, 0, 0, 0]
        op.maximize(linear=linear2)
        op.linear_constraint([1, 1, 1, 1, 1], Constraint.Sense.LE, 1, "")

        with self.subTest("Maximum"):
            self.assertEqual(op.get_num_linear_constraints(), 1)
            lip.penalty = 5
            quadratic2 = [
                [0, 1, 1, 1, 1],
                [0, 0, 1, 1, 1],
                [0, 0, 0, 1, 1],
                [0, 0, 0, 0, 1],
                [0, 0, 0, 0, 0],
            ]
            op2 = lip.convert(op)
            ldct2 = op2.objective.linear.to_array()
            qdct2 = op2.objective.quadratic.to_array() / lip.penalty * -1
            self.assertEqual(ldct2.tolist(), linear2)
            self.assertEqual(qdct2.tolist(), quadratic2)
            self.assertEqual(op2.get_num_linear_constraints(), 0)
 def test_inequality_to_penalty_auto_define_penalty(self):
     """Test _auto_define_penalty() in InequalityToPenalty"""
     op = QuadraticProgram()
     op.integer_var(name="x", lowerbound=1, upperbound=3)
     op.integer_var(name="y", lowerbound=-1, upperbound=4)
     op.integer_var(name="z", lowerbound=-5, upperbound=-1)
     op.maximize(linear={"x": 1, "y": 1, "z": 1})
     lip = LinearInequalityToPenalty()
     self.assertEqual(lip._auto_define_penalty(op), 12)
     op = QuadraticProgram()
     op.integer_var(name="x", lowerbound=1, upperbound=3)
     op.integer_var(name="y", lowerbound=-1, upperbound=4)
     op.integer_var(name="z", lowerbound=-5, upperbound=-1)
     op.maximize(linear={"x": -1, "y": -1, "z": -1})
     lip = LinearInequalityToPenalty()
     self.assertEqual(lip._auto_define_penalty(op), 12)
     op = QuadraticProgram()
     op.integer_var(name="x", lowerbound=1, upperbound=3)
     op.integer_var(name="y", lowerbound=-1, upperbound=4)
     op.integer_var(name="z", lowerbound=-5, upperbound=-1)
     op.maximize(quadratic={
         (0, 0): 1,
         (0, 1): 1,
         (0, 2): 1,
         (1, 1): 1,
         (1, 2): 1,
         (2, 2): 1
     })
     lip = LinearInequalityToPenalty()
     self.assertEqual(lip._auto_define_penalty(op), 103)
     op = QuadraticProgram()
     op.integer_var(name="x", lowerbound=1, upperbound=3)
     op.integer_var(name="y", lowerbound=-1, upperbound=4)
     op.integer_var(name="z", lowerbound=-5, upperbound=-1)
     op.maximize(quadratic={
         (0, 0): -1,
         (0, 1): -1,
         (0, 2): -1,
         (1, 1): -1,
         (1, 2): -1,
         (2, 2): -1
     })
     lip = LinearInequalityToPenalty()
     self.assertEqual(lip._auto_define_penalty(op), 103)
     op = QuadraticProgram()
     op.integer_var(lowerbound=-2, upperbound=1, name="x")
     op.minimize(quadratic={("x", "x"): 1})
     lip = LinearInequalityToPenalty()
     self.assertEqual(lip._auto_define_penalty(op), 5)
 def test_name_setter(self):
     """ test name setter """
     q_p = QuadraticProgram()
     self.assertEqual(q_p.name, '')
     name = 'test name'
     q_p.name = name
     self.assertEqual(q_p.name, name)
Ejemplo n.º 9
0
    def test_setters(self):
        """ test setters. """

        quadratic_program = QuadraticProgram()
        for _ in range(5):
            quadratic_program.continuous_var()

        n = quadratic_program.get_num_vars()
        zeros = np.zeros((n, n))
        quadratic = QuadraticExpression(quadratic_program, zeros)

        coefficients_list = [[0 for _ in range(5)] for _ in range(5)]
        for i, v in enumerate(coefficients_list):
            for j, _ in enumerate(v):
                coefficients_list[min(i, j)][max(i, j)] += i * j
        coefficients_array = np.array(coefficients_list)
        coefficients_dok = dok_matrix(coefficients_list)
        coefficients_dict_int = {(i, j): v for (i, j), v in coefficients_dok.items()}
        coefficients_dict_str = {('x{}'.format(i), 'x{}'.format(j)): v for (i, j), v in
                                 coefficients_dok.items()}

        for coeffs in [coefficients_list,
                       coefficients_array,
                       coefficients_dok,
                       coefficients_dict_int,
                       coefficients_dict_str]:
            quadratic.coefficients = coeffs
            self.assertEqual((quadratic.coefficients != coefficients_dok).nnz, 0)
            self.assertTrue((quadratic.to_array() == coefficients_list).all())
            self.assertDictEqual(quadratic.to_dict(use_name=False), coefficients_dict_int)
            self.assertDictEqual(quadratic.to_dict(use_name=True), coefficients_dict_str)
Ejemplo n.º 10
0
def build_qubo_unconstrained_from_edges_dict(G, all_edges_dict, variables):
    qubo = QuadraticProgram()
    linear, quadratic = get_linear_quadratic_coeffs(G, all_edges_dict)
    for var in variables:
        qubo.binary_var(var)
    qubo.minimize(linear=linear, quadratic=quadratic)
    return qubo, linear, quadratic
    def test_feasibility(self):
        """Tests feasibility methods."""
        q_p = QuadraticProgram("test")
        _ = q_p.continuous_var(-1, 1, "x")
        _ = q_p.continuous_var(-10, 10, "y")
        q_p.minimize(linear={"x": 1, "y": 1})
        q_p.linear_constraint({"x": 1, "y": 1}, "<=", 10, "c0")
        q_p.linear_constraint({"x": 1, "y": 1}, ">=", -10, "c1")
        q_p.linear_constraint({"x": 1, "y": 1}, "==", 5, "c2")
        q_p.quadratic_constraint({"y": 1}, {("x", "x"): 1}, "<=", 10, "c3")
        q_p.quadratic_constraint({"y": 1}, {("x", "x"): 1}, ">=", 5, "c4")
        q_p.quadratic_constraint(None, {
            ("x", "x"): 1,
            ("y", "y"): 1
        }, "==", 25, "c5")

        self.assertTrue(q_p.is_feasible([0, 5]))
        self.assertFalse(q_p.is_feasible([1, 10]))
        self.assertFalse(q_p.is_feasible([1, -12]))
        self.assertFalse(q_p.is_feasible([1, 5]))
        self.assertFalse(q_p.is_feasible([5, 0]))
        self.assertFalse(q_p.is_feasible([1, 1]))
        self.assertFalse(q_p.is_feasible([0, 0]))

        feasible, variables, constraints = q_p.get_feasibility_info([10, 0])
        self.assertFalse(feasible)
        self.assertIsNotNone(variables)
        self.assertEqual(1, len(variables))
        self.assertEqual("x", variables[0].name)

        self.assertIsNotNone(constraints)
        self.assertEqual(3, len(constraints))
        self.assertEqual("c2", constraints[0].name)
        self.assertEqual("c3", constraints[1].name)
        self.assertEqual("c5", constraints[2].name)
Ejemplo n.º 12
0
 def test_objective_handling(self):
     """test objective handling"""
     q_p = QuadraticProgram()
     q_p.binary_var("x")
     q_p.binary_var("y")
     q_p.binary_var("z")
     q_p.minimize()
     obj = q_p.objective
     self.assertEqual(obj.sense, QuadraticObjective.Sense.MINIMIZE)
     self.assertEqual(obj.constant, 0)
     self.assertDictEqual(obj.linear.to_dict(), {})
     self.assertDictEqual(obj.quadratic.to_dict(), {})
     q_p.maximize(1, {"y": 1}, {("z", "x"): 1, ("y", "y"): 1})
     obj = q_p.objective
     self.assertEqual(obj.sense, QuadraticObjective.Sense.MAXIMIZE)
     self.assertEqual(obj.constant, 1)
     self.assertDictEqual(obj.linear.to_dict(), {1: 1})
     self.assertDictEqual(obj.linear.to_dict(use_name=True), {"y": 1})
     self.assertListEqual(obj.linear.to_array().tolist(), [0, 1, 0])
     self.assertDictEqual(obj.quadratic.to_dict(), {(0, 2): 1, (1, 1): 1})
     self.assertDictEqual(
         obj.quadratic.to_dict(symmetric=True), {(0, 2): 0.5, (2, 0): 0.5, (1, 1): 1}
     )
     self.assertDictEqual(obj.quadratic.to_dict(use_name=True), {("x", "z"): 1, ("y", "y"): 1})
     self.assertDictEqual(
         obj.quadratic.to_dict(use_name=True, symmetric=True),
         {("x", "z"): 0.5, ("z", "x"): 0.5, ("y", "y"): 1},
     )
     self.assertListEqual(obj.quadratic.to_array().tolist(), [[0, 0, 1], [0, 1, 0], [0, 0, 0]])
     self.assertListEqual(
         obj.quadratic.to_array(symmetric=True).tolist(),
         [[0, 0, 0.5], [0, 1, 0], [0.5, 0, 0]],
     )
    def test_init(self):
        """test init."""

        quadratic_program = QuadraticProgram()
        for _ in range(5):
            quadratic_program.continuous_var()

        coefficients_list = [[0 for _ in range(5)] for _ in range(5)]
        for i, v in enumerate(coefficients_list):
            for j, _ in enumerate(v):
                coefficients_list[min(i, j)][max(i, j)] += i * j
        coefficients_array = np.array(coefficients_list)
        coefficients_dok = dok_matrix(coefficients_list)
        coefficients_dict_int = {(i, j): v
                                 for (i, j), v in coefficients_dok.items()}
        coefficients_dict_str = {(f"x{i}", f"x{j}"): v
                                 for (i, j), v in coefficients_dok.items()}

        for coeffs in [
                coefficients_list,
                coefficients_array,
                coefficients_dok,
                coefficients_dict_int,
                coefficients_dict_str,
        ]:
            quadratic = QuadraticExpression(quadratic_program, coeffs)
            self.assertEqual((quadratic.coefficients != coefficients_dok).nnz,
                             0)
            self.assertTrue((quadratic.to_array() == coefficients_list).all())
            self.assertDictEqual(quadratic.to_dict(use_name=False),
                                 coefficients_dict_int)
            self.assertDictEqual(quadratic.to_dict(use_name=True),
                                 coefficients_dict_str)
    def test_setters(self):
        """test setters."""

        quadratic_program = QuadraticProgram()
        for _ in range(5):
            quadratic_program.continuous_var()

        zeros = np.zeros(quadratic_program.get_num_vars())
        linear = LinearExpression(quadratic_program, zeros)

        coefficients_list = list(range(5))
        coefficients_array = np.array(coefficients_list)
        coefficients_dok = dok_matrix([coefficients_list])
        coefficients_dict_int = {i: i for i in range(1, 5)}
        coefficients_dict_str = {f"x{i}": i for i in range(1, 5)}

        for coeffs in [
            coefficients_list,
            coefficients_array,
            coefficients_dok,
            coefficients_dict_int,
            coefficients_dict_str,
        ]:
            linear.coefficients = coeffs
            self.assertEqual((linear.coefficients != coefficients_dok).nnz, 0)
            self.assertTrue((linear.to_array() == coefficients_list).all())
            self.assertDictEqual(linear.to_dict(use_name=False), coefficients_dict_int)
            self.assertDictEqual(linear.to_dict(use_name=True), coefficients_dict_str)
Ejemplo n.º 15
0
    def setUp(self):
        super().setUp()
        random.seed(123)
        low = 0
        high = 100
        pos = {
            i: (random.randint(low, high), random.randint(low, high))
            for i in range(4)
        }
        self.graph = nx.random_geometric_graph(
            4, np.hypot(high - low, high - low) + 1, pos=pos)
        for w, v in self.graph.edges:
            delta = [
                self.graph.nodes[w]["pos"][i] - self.graph.nodes[v]["pos"][i]
                for i in range(2)
            ]
            self.graph.edges[w, v]["weight"] = np.rint(
                np.hypot(delta[0], delta[1]))

        op = QuadraticProgram()
        for i in range(16):
            op.binary_var()
        self.result = OptimizationResult(
            x=[1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
            fval=272,
            variables=op.variables,
            status=OptimizationResultStatus.SUCCESS,
        )
    def test_simple_qubo(self):
        """Test on a simple QUBO problem."""
        model = Model()
        # pylint:disable=invalid-name
        u = model.binary_var(name="u")
        v = model.binary_var(name="v")

        model.minimize((u - v + 2)**2)
        problem = QuadraticProgram()
        problem.from_docplex(model)

        backend = BasicAer.get_backend("statevector_simulator")
        qaoa = QAOA(quantum_instance=backend, reps=1)
        optimizer = WarmStartQAOAOptimizer(
            pre_solver=SlsqpOptimizer(),
            relax_for_pre_solver=True,
            qaoa=qaoa,
            epsilon=0.25,
        )
        result_warm = optimizer.solve(problem)

        self.assertIsNotNone(result_warm)
        self.assertIsNotNone(result_warm.x)
        np.testing.assert_almost_equal([0, 1], result_warm.x, 3)
        self.assertIsNotNone(result_warm.fval)
        np.testing.assert_almost_equal(1, result_warm.fval, 3)
    def test_quadratic_program_to_qubo_inequality_to_penalty(self):
        """Test QuadraticProgramToQubo, passing inequality pattern"""

        op = QuadraticProgram()
        conv = QuadraticProgramToQubo()
        op.binary_var(name="x")
        op.binary_var(name="y")

        # Linear constraints
        linear_constraint = {"x": 1, "y": 1}
        op.linear_constraint(linear_constraint, Constraint.Sense.GE, 1,
                             "P(1-x-y+xy)")

        conv.penalty = 1
        constant = 1
        linear = {"x": -conv.penalty, "y": -conv.penalty}
        quadratic = {("x", "y"): conv.penalty}
        op2 = conv.convert(op)
        cnst = op2.objective.constant
        ldct = op2.objective.linear.to_dict(use_name=True)
        qdct = op2.objective.quadratic.to_dict(use_name=True)
        self.assertEqual(cnst, constant)
        self.assertEqual(ldct, linear)
        self.assertEqual(qdct, quadratic)
        self.assertEqual(op2.get_num_linear_constraints(), 0)
    def test_linear_inequality_to_penalty3(self):
        """Test special constraint to penalty x1+x2+x3+... >= n-1 -> P(x1*x2+x1*x3+...)"""

        op = QuadraticProgram()
        lip = LinearInequalityToPenalty()
        op.binary_var_list(5)

        # Linear constraints
        n = 5
        op.linear_constraint([1, 1, 1, 1, 1], Constraint.Sense.GE, n - 1, "")

        # Test with no max/min
        with self.subTest("No max/min"):
            self.assertEqual(op.get_num_linear_constraints(), 1)
            penalty = 5
            lip.penalty = penalty

            constant = 10
            linear = [n - 1, n - 1, n - 1, n - 1, n - 1]
            quadratic = [
                [0, 1, 1, 1, 1],
                [0, 0, 1, 1, 1],
                [0, 0, 0, 1, 1],
                [0, 0, 0, 0, 1],
                [0, 0, 0, 0, 0],
            ]
            op2 = lip.convert(op)
            cnst2 = op2.objective.constant / penalty
            ldct2 = op2.objective.linear.to_array() / penalty * -1
            qdct2 = op2.objective.quadratic.to_array() / penalty
            self.assertEqual(cnst2, constant)
            self.assertEqual(ldct2.tolist(), linear)
            self.assertEqual(qdct2.tolist(), quadratic)
            self.assertEqual(op2.get_num_linear_constraints(), 0)
Ejemplo n.º 19
0
def qaoa(G):
    n = G.numberOfNodes()
    G = nw.nxadapter.nk2nx(G)
    w = nx.adjacency_matrix(G)
    problem = QuadraticProgram()
    _ = [problem.binary_var(f"x{i}") for i in range(n)]
    linear = w.dot(np.ones(n))
    quadratic = -w
    problem.maximize(linear=linear, quadratic=quadratic)
    c = [1]
    for _ in range(n - 1):
        c.append(0)
    problem.linear_constraint(c, '==', 1)

    cobyla = COBYLA()
    backend = BasicAer.get_backend('qasm_simulator')
    qaoa = QAOA(optimizer=cobyla, reps=3, quantum_instance=backend)
    algorithm = MinimumEigenOptimizer(qaoa)
    result = algorithm.solve(problem)
    L = result.x
    i = 0
    res = {}
    for x in L:
        res[i] = x
        i += 1
    return res
    def test_constrained_binary(self):
        """Constrained binary optimization problem."""
        model = Model()
        v = model.binary_var(name="v")
        w = model.binary_var(name="w")
        # pylint:disable=invalid-name
        t = model.binary_var(name="t")

        model.minimize(v + w + t)
        model.add_constraint(2 * v + 10 * w + t <= 3, "cons1")
        model.add_constraint(v + w + t >= 2, "cons2")

        problem = QuadraticProgram()
        problem.from_docplex(model)

        backend = BasicAer.get_backend("statevector_simulator")
        qaoa = QAOA(quantum_instance=backend, reps=1)
        aggregator = MeanAggregator()
        optimizer = WarmStartQAOAOptimizer(
            pre_solver=SlsqpOptimizer(),
            relax_for_pre_solver=True,
            qaoa=qaoa,
            epsilon=0.25,
            aggregator=aggregator,
        )
        result_warm = optimizer.solve(problem)

        self.assertIsNotNone(result_warm)
        self.assertIsNotNone(result_warm.x)
        np.testing.assert_almost_equal([1, 0, 1], result_warm.x, 3)
        self.assertIsNotNone(result_warm.fval)
        np.testing.assert_almost_equal(2, result_warm.fval, 3)
Ejemplo n.º 21
0
 def test_auto_penalty(self):
     """Test auto penalty function"""
     op = QuadraticProgram()
     op.binary_var("x")
     op.binary_var("y")
     op.binary_var("z")
     op.minimize(constant=3, linear={"x": 1}, quadratic={("x", "y"): 2})
     op.linear_constraint(linear={
         "x": 1,
         "y": 1,
         "z": 1
     },
                          sense="EQ",
                          rhs=2,
                          name="xyz_eq")
     lineq2penalty = LinearEqualityToPenalty(penalty=1e5)
     lineq2penalty_auto = LinearEqualityToPenalty()
     qubo = lineq2penalty.convert(op)
     qubo_auto = lineq2penalty_auto.convert(op)
     exact_mes = NumPyMinimumEigensolver()
     exact = MinimumEigenOptimizer(exact_mes)
     result = exact.solve(qubo)
     result_auto = exact.solve(qubo_auto)
     self.assertEqual(result.fval, result_auto.fval)
     np.testing.assert_array_almost_equal(result.x, result_auto.x)
Ejemplo n.º 22
0
 def test_integer_to_binary2(self):
     """Test integer to binary variables 2"""
     mod = QuadraticProgram()
     mod.integer_var(name="x", lowerbound=0, upperbound=1)
     mod.integer_var(name="y", lowerbound=0, upperbound=1)
     mod.minimize(1, {"x": 1}, {("x", "y"): 2})
     mod.linear_constraint({"x": 1}, "==", 1)
     mod.quadratic_constraint({"x": 1}, {("x", "y"): 2}, "==", 1)
     mod2 = IntegerToBinary().convert(mod)
     self.assertListEqual([e.name + "@0" for e in mod.variables],
                          [e.name for e in mod2.variables])
     self.assertDictEqual(mod.objective.linear.to_dict(),
                          mod2.objective.linear.to_dict())
     self.assertDictEqual(mod.objective.quadratic.to_dict(),
                          mod2.objective.quadratic.to_dict())
     self.assertEqual(mod.get_num_linear_constraints(),
                      mod2.get_num_linear_constraints())
     for cst, cst2 in zip(mod.linear_constraints, mod2.linear_constraints):
         self.assertDictEqual(cst.linear.to_dict(), cst2.linear.to_dict())
     self.assertEqual(mod.get_num_quadratic_constraints(),
                      mod2.get_num_quadratic_constraints())
     for cst, cst2 in zip(mod.quadratic_constraints,
                          mod2.quadratic_constraints):
         self.assertDictEqual(cst.linear.to_dict(), cst2.linear.to_dict())
         self.assertDictEqual(cst.quadratic.to_dict(),
                              cst2.quadratic.to_dict())
Ejemplo n.º 23
0
    def test_linear_equality_to_penalty_decode(self):
        """Test decode func of LinearEqualityToPenalty"""
        qprog = QuadraticProgram()
        qprog.binary_var("x")
        qprog.binary_var("y")
        qprog.binary_var("z")
        qprog.maximize(linear={"x": 3, "y": 1, "z": 1})
        qprog.linear_constraint(linear={
            "x": 1,
            "y": 1,
            "z": 1
        },
                                sense="EQ",
                                rhs=2,
                                name="xyz_eq")
        lineq2penalty = LinearEqualityToPenalty()
        qubo = lineq2penalty.convert(qprog)
        exact_mes = NumPyMinimumEigensolver()
        exact = MinimumEigenOptimizer(exact_mes)
        result = exact.solve(qubo)

        new_x = lineq2penalty.interpret(result.x)
        np.testing.assert_array_almost_equal(new_x, [1, 1, 0])
        infeasible_x = lineq2penalty.interpret([1, 1, 1])
        np.testing.assert_array_almost_equal(infeasible_x, [1, 1, 1])
Ejemplo n.º 24
0
    def test_ising_to_quadraticprogram_quadratic(self):
        """Test optimization problem to operators with linear=False"""
        op = QUBIT_OP_MAXIMIZE_SAMPLE
        offset = OFFSET_MAXIMIZE_SAMPLE

        quadratic = QuadraticProgram()
        quadratic.from_ising(op, offset, linear=False)

        self.assertEqual(quadratic.get_num_vars(), 4)
        self.assertEqual(quadratic.get_num_linear_constraints(), 0)
        self.assertEqual(quadratic.get_num_quadratic_constraints(), 0)
        self.assertEqual(quadratic.objective.sense,
                         quadratic.objective.Sense.MINIMIZE)
        self.assertAlmostEqual(quadratic.objective.constant, 900000)

        quadratic_matrix = np.zeros((4, 4))
        quadratic_matrix[0, 0] = -500001
        quadratic_matrix[0, 1] = 400000
        quadratic_matrix[0, 2] = 600000
        quadratic_matrix[0, 3] = 800000
        quadratic_matrix[1, 1] = -800001
        quadratic_matrix[1, 2] = 1200000
        quadratic_matrix[1, 3] = 1600000
        quadratic_matrix[2, 2] = -900001
        quadratic_matrix[2, 3] = 2400000
        quadratic_matrix[3, 3] = -800001

        np.testing.assert_array_almost_equal(
            quadratic.objective.quadratic.coefficients.toarray(),
            quadratic_matrix)
    def test_init(self):
        """test init."""

        quadratic_program = QuadraticProgram()
        for _ in range(5):
            quadratic_program.continuous_var()

        coefficients_list = list(range(5))
        coefficients_array = np.array(coefficients_list)
        coefficients_dok = dok_matrix([coefficients_list])
        coefficients_dict_int = {i: i for i in range(1, 5)}
        coefficients_dict_str = {"x{}".format(i): i for i in range(1, 5)}

        for coeffs in [
                coefficients_list,
                coefficients_array,
                coefficients_dok,
                coefficients_dict_int,
                coefficients_dict_str,
        ]:
            linear = LinearExpression(quadratic_program, coeffs)
            self.assertEqual((linear.coefficients != coefficients_dok).nnz, 0)
            self.assertTrue((linear.to_array() == coefficients_list).all())
            self.assertDictEqual(linear.to_dict(use_name=False),
                                 coefficients_dict_int)
            self.assertDictEqual(linear.to_dict(use_name=True),
                                 coefficients_dict_str)
Ejemplo n.º 26
0
    def test_write_to_lp_file(self):
        """test write problem"""
        q_p = QuadraticProgram("my problem")
        q_p.binary_var("x")
        q_p.integer_var(-1, 5, "y")
        q_p.continuous_var(-1, 5, "z")
        q_p.minimize(1, {"x": 1, "y": -1, "z": 10}, {("x", "x"): 0.5, ("y", "z"): -1})
        q_p.linear_constraint({"x": 1, "y": 2}, "==", 1, "lin_eq")
        q_p.linear_constraint({"x": 1, "y": 2}, "<=", 1, "lin_leq")
        q_p.linear_constraint({"x": 1, "y": 2}, ">=", 1, "lin_geq")
        q_p.quadratic_constraint(
            {"x": 1, "y": 1},
            {("x", "x"): 1, ("y", "z"): -1, ("z", "z"): 2},
            "==",
            1,
            "quad_eq",
        )
        q_p.quadratic_constraint(
            {"x": 1, "y": 1},
            {("x", "x"): 1, ("y", "z"): -1, ("z", "z"): 2},
            "<=",
            1,
            "quad_leq",
        )
        q_p.quadratic_constraint(
            {"x": 1, "y": 1},
            {("x", "x"): 1, ("y", "z"): -1, ("z", "z"): 2},
            ">=",
            1,
            "quad_geq",
        )

        reference_file_name = self.get_resource_path(
            "test_quadratic_program.lp", "problems/resources"
        )
        with tempfile.TemporaryDirectory() as tmp:
            temp_output_path = path.join(tmp, "temp.lp")
            q_p.write_to_lp_file(temp_output_path)
            with open(reference_file_name, encoding="utf8") as reference, open(
                temp_output_path, encoding="utf8"
            ) as temp_output_file:
                lines1 = temp_output_file.readlines()
                lines2 = reference.readlines()
                self.assertListEqual(lines1, lines2)

        with tempfile.TemporaryDirectory() as temp_problem_dir:
            q_p.write_to_lp_file(temp_problem_dir)
            with open(path.join(temp_problem_dir, "my_problem.lp"), encoding="utf8") as file1, open(
                reference_file_name, encoding="utf8"
            ) as file2:
                lines1 = file1.readlines()
                lines2 = file2.readlines()
                self.assertListEqual(lines1, lines2)

        with self.assertRaises(OSError):
            q_p.write_to_lp_file("/cannot/write/this/file.lp")

        with self.assertRaises(DOcplexException):
            q_p.write_to_lp_file("")
Ejemplo n.º 27
0
def build_qubo_unconstrained_from_nodes(G, routes_dict):
    all_edges_dict = get_edges_dict(routes_dict)
    qubo = QuadraticProgram()
    linear, quadratic = get_linear_quadratic_coeffs(G, all_edges_dict)
    for var in routes_dict.keys():
        qubo.binary_var(var)
    qubo.minimize(linear=linear, quadratic=quadratic)
    return qubo, linear, quadratic
    def test_bounds(self):
        """test lowerbound and upperbound"""

        with self.subTest("bounded"):
            quadratic_program = QuadraticProgram()
            quadratic_program.continuous_var_list(3, lowerbound=-1, upperbound=2)
            coefficients_list = list(range(3))
            bounds = LinearExpression(quadratic_program, coefficients_list).bounds
            self.assertAlmostEqual(bounds.lowerbound, -3)
            self.assertAlmostEqual(bounds.upperbound, 6)

        with self.subTest("bounded2"):
            quadratic_program = QuadraticProgram()
            quadratic_program.integer_var(lowerbound=-2, upperbound=-1, name="x")
            quadratic_program.integer_var(lowerbound=2, upperbound=4, name="y")
            bounds = LinearExpression(quadratic_program, {"x": 1, "y": 10}).bounds
            self.assertAlmostEqual(bounds.lowerbound, 18)
            self.assertAlmostEqual(bounds.upperbound, 39)

            bounds = LinearExpression(quadratic_program, {"x": -1, "y": 10}).bounds
            self.assertAlmostEqual(bounds.lowerbound, 21)
            self.assertAlmostEqual(bounds.upperbound, 42)

            bounds = LinearExpression(quadratic_program, {"x": 1, "y": -10}).bounds
            self.assertAlmostEqual(bounds.lowerbound, -42)
            self.assertAlmostEqual(bounds.upperbound, -21)

            bounds = LinearExpression(quadratic_program, {"x": -1, "y": -10}).bounds
            self.assertAlmostEqual(bounds.lowerbound, -39)
            self.assertAlmostEqual(bounds.upperbound, -18)

            bounds = LinearExpression(quadratic_program, {"x": 0, "y": 0}).bounds
            self.assertAlmostEqual(bounds.lowerbound, 0)
            self.assertAlmostEqual(bounds.upperbound, 0)

        with self.assertRaises(QiskitOptimizationError):
            quadratic_program = QuadraticProgram()
            quadratic_program.continuous_var_list(3, lowerbound=0, upperbound=INFINITY)
            coefficients_list = list(range(3))
            _ = LinearExpression(quadratic_program, coefficients_list).bounds

        with self.assertRaises(QiskitOptimizationError):
            quadratic_program = QuadraticProgram()
            quadratic_program.continuous_var_list(3, lowerbound=-INFINITY, upperbound=0)
            coefficients_list = list(range(3))
            _ = LinearExpression(quadratic_program, coefficients_list).bounds
Ejemplo n.º 29
0
 def test_symmetric_set(self):
     """ test symmetric set """
     q_p = QuadraticProgram()
     q_p.binary_var('x')
     q_p.binary_var('y')
     q_p.binary_var('z')
     quad = QuadraticExpression(q_p, {('x', 'y'): -1, ('y', 'x'): 2, ('z', 'x'): 3})
     self.assertDictEqual(quad.to_dict(use_name=True), {('x', 'y'): 1, ('x', 'z'): 3})
     self.assertDictEqual(quad.to_dict(symmetric=True, use_name=True),
                          {('x', 'y'): 0.5, ('y', 'x'): 0.5, ('x', 'z'): 1.5, ('z', 'x'): 1.5})
 def setUp(self):
     """Set up for the test"""
     super().setUp()
     self.num_set = [8, 7, 6, 5, 4]
     op = QuadraticProgram()
     for _ in range(5):
         op.binary_var()
     self.result = OptimizationResult(
         x=[1, 1, 0, 0, 0], fval=0, variables=op.variables,
         status=OptimizationResultStatus.SUCCESS)