def test_graphpartitioning_qubo_solve():
e, sol = solve_qubo_bruteforce(problem.to_qubo())
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_qubo_bruteforce(problem.to_qubo(10))
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_qubo_bruteforce(problem_weighted.to_qubo())
solution = problem_weighted.convert_solution(sol)
assert solution == problem_weighted.convert_solution(
[sol[i] for i in range(problem_weighted.num_binary_variables)])
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_qubo_logtrick_solve():
e, sol = solve_qubo_bruteforce(Q_log)
solution = problem_log.convert_solution(sol)
assert problem_log.is_solution_valid(solution)
assert problem_log.is_solution_valid(sol)
assert solution in solutions
assert allclose(e, obj_val)
e, sol = solve_qubo_bruteforce(problem_log.to_qubo(3))
solution = problem_log.convert_solution(sol)
assert problem_log.is_solution_valid(solution)
assert problem_log.is_solution_valid(sol)
assert solution in solutions
assert allclose(e, obj_val)
def test_setcover_qubo_logtrick_solve():
e, sol = solve_qubo_bruteforce(problem_log.to_qubo())
solution = problem_log.convert_solution(sol)
assert problem_log.is_solution_valid(solution)
assert problem_log.is_solution_valid(sol)
assert solution == {0, 2}
assert allclose(e, len(solution))
p = SetCover(U, V, M=1)
e, sol = solve_qubo_bruteforce(p.to_qubo())
solution = p.convert_solution(sol)
assert p.is_solution_valid(solution)
assert p.is_solution_valid(sol)
assert solution == {0, 2}
assert allclose(e, len(solution))
def test_jobsequencing_qubo_solve():
e, sol = solve_qubo_bruteforce(Q)
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_bilp_qubo_solve():
e, sol = solve_qubo_bruteforce(problem.to_qubo())
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)
e, sol = solve_qubo_bruteforce(problem.to_qubo(10, 1))
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_setcover_qubo_solve():
e, sol = solve_qubo_bruteforce(problem.to_qubo())
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_weighted_setcover():
e, sol = solve_qubo_bruteforce(problem_weighted.to_qubo())
solution = problem_weighted.convert_solution(sol)
assert problem_weighted.is_solution_valid(solution)
assert problem_weighted.is_solution_valid(sol)
assert solution == {0, 2}
assert allclose(e, 1.1)
def test_quso_qubo_solve():
e, sols = solve_qubo_bruteforce(problem.to_qubo())
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_vertexcover_qubo_solve():
e, sol = solve_qubo_bruteforce(problem.to_qubo())
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_qubo_solve():
e, sols = solve_qubo_bruteforce(problem.to_qubo())
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_numberpartitioning_qubo_solve():
e, sol = solve_qubo_bruteforce(problem_withsoln.to_qubo())
solution = problem_withsoln.convert_solution(sol)
assert solution == problem_withsoln.convert_solution(
[sol[i] for i in range(problem_withsoln.num_binary_variables)])
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_qubo_bruteforce(problem_withoutsoln.to_qubo())
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_AlternatingSectorsChain_qubo_solve():
e, sol = solve_qubo_bruteforce(problem.to_qubo(True))
solution = problem.convert_solution(sol)
assert solution == problem.convert_solution(solution, True)
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_qubo_bruteforce(problem.to_qubo(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 solve_bruteforce(self, all_solutions=False):
"""solve_bruteforce.
Solves the Set Cover problem exactly with a brute force method. THIS
SHOULD NOT BE USED FOR LARGE PROBLEMS! The advantage over this method
as opposed to using a brute force QUBO solver is that the QUBO
formulation has many slack variables.
Parameters
----------
all_solutions : boolean (optional, defaults to False).
If ``all_solutions`` is set to True, all the best solutions to the
problem will be returned rather than just one of the best. If the
problem is very big, then it is best if ``all_solutions == False``,
otherwise this function will use a lot of memory.
Returns
-------
res : set or list of sets.
A set of which sets are included in the set cover. So if this
function returns ``{0, 2, 3}``, then the set cover is the sets
``V[0]``, ``V[2]``, and ``V[3]``. If ``all_solutions == True``,
then ``res`` will be a list of sets, where each element of the list
is one of the optimal solutions.
Examples
--------
>>> from qubovert import SetCover
>>> U = {"a", "b", "c", "d"}
>>> V = [{"a", "b"}, {"a", "c"}, {"c", "d"}]
>>> problem = SetCover(U, V)
>>> print(problem.solve_bruteforce())
{0, 2}
"""
# minimize the objective function
Q = {(i, ): self._weights[i] for i in range(self._N)}
# subject to the constraint
valid = self.is_solution_valid
obj, sol = solve_qubo_bruteforce(Q, all_solutions, valid)
if obj is None:
raise ValueError("Problem is not solvable. See "
"``SetCover.is_coverable()``")
if all_solutions:
return [self.convert_solution(s) for s in sol]
return self.convert_solution(sol)
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)