def test_setcover_pubo_solve():
e, sol = solve_pubo_bruteforce(problem.to_pubo())
solution = problem.convert_solution(sol)
assert problem.is_solution_valid(solution)
assert problem.is_solution_valid(sol)
assert solution == {0, 2}
assert allclose(e, len(solution))
def test_graphpartitioning_pubo_solve():
e, sol = solve_pubo_bruteforce(problem.to_pubo())
solution = problem.convert_solution(sol)
assert solution in solutions
assert problem.is_solution_valid(solution)
assert problem.is_solution_valid(sol)
assert allclose(e, 1)
e, sol = solve_pubo_bruteforce(problem_weighted.to_pubo())
solution = problem_weighted.convert_solution(sol)
assert solution in solutions_weighted
assert problem_weighted.is_solution_valid(solution)
assert problem_weighted.is_solution_valid(sol)
assert allclose(e, 1)
def test_jobsequencing_pubo_solve():
e, sol = solve_pubo_bruteforce(P)
solution = problem.convert_solution(sol)
assert problem.is_solution_valid(solution)
assert problem.is_solution_valid(sol)
assert solution in solutions
assert allclose(e, obj_val)
def test_quso_pubo_solve():
e, sols = solve_pubo_bruteforce(problem.to_pubo())
sol = problem.convert_solution(sols, False)
assert problem.is_solution_valid(sol)
assert problem.is_solution_valid(sols)
assert sol == solution
assert allclose(e, -10)
def test_numberpartitioning_pubo_solve():
e, sol = solve_pubo_bruteforce(problem_withsoln.to_pubo())
solution = problem_withsoln.convert_solution(sol)
assert solution in solutions_withsoln
assert problem_withsoln.is_solution_valid(solution)
assert problem_withsoln.is_solution_valid(sol)
assert allclose(e, 0)
e, sol = solve_pubo_bruteforce(problem_withoutsoln.to_pubo())
solution = problem_withoutsoln.convert_solution(sol)
assert solution in solutions_withoutsoln
assert not problem_withoutsoln.is_solution_valid(solution)
assert not problem_withoutsoln.is_solution_valid(sol)
assert e != 0
def test_pcso_le_constraint():
lam = Symbol("lam")
H = PCSO(
pubo_to_puso({
('a', ): -1,
('b', ): 2,
('a', 'b'): -3,
('b', 'c'): -4,
(): -2,
('d', ): -1
}))
H.add_constraint_le_zero(pubo_to_puso({
('a', ): 1,
('b', ): 1,
('b', 'c'): 1,
('d', ): 1,
(): -3
}),
lam=lam,
log_trick=False)
solution = boolean_to_spin({'c': 1, 'b': 1, 'a': 1, 'd': 0})
obj = -8
problem = H.subs(lam, .5)
sol = problem.remove_ancilla_from_solution(problem.solve_bruteforce())
assert all((problem.is_solution_valid(sol), sol == solution))
e, sol = solve_pubo_bruteforce(problem.to_pubo())
sol = problem.convert_solution(sol, spin=False)
sol = problem.remove_ancilla_from_solution(sol)
assert all((not problem.is_solution_valid(sol), sol != solution,
not allclose(e, obj)))
problem = H.subs(lam, 10)
sol = problem.solve_bruteforce()
sol = problem.remove_ancilla_from_solution(sol)
assert all((problem.is_solution_valid(sol), sol == solution))
e, sol = solve_pubo_bruteforce(problem.to_pubo())
sol = problem.convert_solution(sol)
sol = problem.remove_ancilla_from_solution(sol)
assert all(
(problem.is_solution_valid(sol), sol == solution, allclose(e, obj)))
def test_bilp_pubo_solve():
e, sol = solve_pubo_bruteforce(problem.to_pubo())
conv_solution = problem.convert_solution(sol)
assert allclose(conv_solution, solution)
assert problem.is_solution_valid(conv_solution)
assert problem.is_solution_valid(sol)
assert allclose(e, 2)
def test_vertexcover_pubo_solve():
e, sol = solve_pubo_bruteforce(problem.to_pubo())
solution = problem.convert_solution(sol)
assert solution == {"a", "c"}
assert problem.is_solution_valid(solution)
assert problem.is_solution_valid(sol)
assert allclose(e, 2)
def test_qubo_pubo_solve():
e, sols = solve_pubo_bruteforce(problem.to_pubo())
sol = problem.convert_solution(sols)
assert problem.is_solution_valid(sol)
assert problem.is_solution_valid(sols)
assert sol == solution
assert allclose(e, obj)
assert (problem.value(sol) == qubo_value(sol, problem) == e)
def test_AlternatingSectorsChain_pubo_solve():
e, sol = solve_pubo_bruteforce(problem.to_pubo(True))
solution = problem.convert_solution(sol)
assert solution == (-1, ) * 12 or solution == (1, ) * 12
assert problem.is_solution_valid(solution)
assert problem.is_solution_valid(sol)
assert allclose(e, -66)
# not pbc
e, sol = solve_pubo_bruteforce(problem.to_pubo(False))
solution = problem.convert_solution(sol)
assert solution == (-1, ) * 12 or solution == (1, ) * 12
assert problem.is_solution_valid(solution)
assert problem.is_solution_valid(sol)
assert allclose(e, -65)
def test_pcso_eq_constraint():
lam = Symbol('lam')
H = PCSO(
pubo_to_puso({
('a', ): -1,
('b', ): 2,
('a', 'b'): -3,
('b', 'c'): -4,
(): -2
}))
H.add_constraint_eq_zero(pubo_to_puso({
('a', ): 1,
('b', ): 1,
('b', 'c'): -1
}),
lam=lam)
solution = boolean_to_spin({'c': 1, 'b': 1, 'a': 0})
obj = -4
problem = H.subs(lam, 1)
sol = problem.solve_bruteforce()
assert all((problem.is_solution_valid(sol), sol == solution))
e, sol = solve_pubo_bruteforce(problem.to_pubo())
sol = problem.convert_solution(sol, False)
assert all((not problem.is_solution_valid(sol), sol != solution,
not allclose(e, obj)))
problem = H.subs(lam, 10)
sol = problem.solve_bruteforce()
assert all((problem.is_solution_valid(sol), sol == solution))
e, sol = solve_pubo_bruteforce(problem.to_pubo())
sol = problem.convert_solution(sol)
assert all(
(problem.is_solution_valid(sol), sol == solution, allclose(e, obj)))
def runtests(self):
assert self.problem.solve_bruteforce() == self.solution
e, sol = solve_qubo_bruteforce(self.problem.to_qubo())
assert self.is_valid(e, sol, False)
e, sol = solve_quso_bruteforce(self.problem.to_quso())
assert self.is_valid(e, sol, True)
for deg in (None, ) + tuple(range(2, self.problem.degree + 1)):
e, sol = solve_puso_bruteforce(self.problem.to_puso(deg))
assert self.is_valid(e, sol, True)
e, sol = solve_pubo_bruteforce(self.problem.to_pubo(deg))
assert self.is_valid(e, sol, False)
assert (self.problem.value(self.solution) == puso_value(
self.solution, self.problem) == e)
