def test_decode2(self):
x = Matrix("x", n_row=2, n_col=2)
exp = Constraint(-(x[1, 1] - x[0, 1])**2, label="const")
model = exp.compile()
self.assertRaises(
ValueError,
lambda: model.decode_solution([1, 0], var_type="binary"))
def test_decode2(self):
x = Array.create("x", (2, 2), vartype="BINARY")
exp = Constraint(-(x[1, 1] - x[0, 1])**2, label="const")
model = exp.compile()
self.assertRaises(
ValueError,
lambda: model.decode_solution([1, 0], vartype="BINARY"))
def test_constraint(self):
sampler = dimod.ExactSolver()
x = Array.create('x', shape=(3), vartype="BINARY")
H = Constraint(x[0] * x[1] * x[2], label="C1")
model = H.compile()
bqm = model.to_bqm()
responses = sampler.sample(bqm)
solutions = model.decode_sampleset(responses)
for sol in solutions:
if sol.energy == 1.0:
self.assertEqual(sol.subh['C1'], 1.0)
def test_placeholder_in_constraint(self):
a = Binary("a")
exp = Constraint(2 * Placeholder("c") + a, "const1")
m = exp.compile()
sol, broken, energy = m.decode_solution({"a": 1},
vartype="BINARY",
feed_dict={"c": 1})
self.assertEqual(energy, 3.0)
self.assertEqual(broken,
{'const1': {
'result': {
'a': 1
},
'penalty': 3.0
}})
self.assertEqual(sol, {'a': 1})
def test_decode(self):
x = Matrix("x", n_row=2, n_col=2)
exp = Constraint((x[1, 1] - x[0, 1])**2, label="const")
model = exp.compile()
# check __repr__ of CompiledQubo
expected_repr = "CompiledQubo({('x[0][1]', 'x[0][1]'): 1.0,\n" \
" ('x[0][1]', 'x[1][1]'): -2.0,\n" \
" ('x[1][1]', 'x[1][1]'): 1.0}, offset=0.0)"
self.assertEqual(repr(model.compiled_qubo), expected_repr)
# check __repr__ of Model
expected_repr = "Model(CompiledQubo({('x[0][1]', 'x[0][1]'): 1.0,\n"\
" ('x[0][1]', 'x[1][1]'): -2.0,\n"\
" ('x[1][1]', 'x[1][1]'): 1.0}, offset=0.0), "\
"structure={'x[0][0]': ('x', 0, 0),\n"\
" 'x[0][1]': ('x', 0, 1),\n"\
" 'x[1][0]': ('x', 1, 0),\n"\
" 'x[1][1]': ('x', 1, 1)})"
self.assertEqual(repr(model), expected_repr)
# when the constraint is not broken
# type of solution is dict[label, bit]
decoded_sol, broken, energy = model.decode_solution(
{
'x[0][1]': 1.0,
'x[1][1]': 1.0
}, var_type="binary")
self.assertTrue(decoded_sol == {'x': {0: {1: 1}, 1: {1: 1}}})
self.assertTrue(len(broken) == 0)
self.assertTrue(energy == 0)
# type of solution is list[bit]
decoded_sol, broken, energy = model.decode_solution([1, 1],
var_type="binary")
self.assertTrue(decoded_sol == {'x': {0: {1: 1}, 1: {1: 1}}})
self.assertTrue(len(broken) == 0)
self.assertTrue(energy == 0)
# type of solution is dict[index_label(int), bit]
decoded_sol, broken, energy = model.decode_solution({
0: 1.0,
1: 1.0
},
var_type="binary")
self.assertTrue(decoded_sol == {'x': {0: {1: 1}, 1: {1: 1}}})
self.assertTrue(len(broken) == 0)
self.assertTrue(energy == 0)
# when the constraint is broken
# type of solution is dict[label, bit]
decoded_sol, broken, energy = model.decode_solution(
{
'x[0][1]': 0.0,
'x[1][1]': 1.0
}, var_type="binary")
self.assertTrue(decoded_sol == {'x': {0: {1: 0}, 1: {1: 1}}})
self.assertTrue(len(broken) == 1)
self.assertTrue(energy == 1)
# type of solution is dict[label, spin]
decoded_sol, broken, energy = model.decode_solution(
{
'x[0][1]': 1.0,
'x[1][1]': -1.0
}, var_type="spin")
self.assertTrue(decoded_sol == {'x': {0: {1: 1}, 1: {1: -1}}})
self.assertTrue(len(broken) == 1)
self.assertTrue(energy == 1)
# invalid solution
self.assertRaises(
ValueError,
lambda: model.decode_solution([1, 1, 1], var_type="binary"))
self.assertRaises(
ValueError, lambda: model.decode_solution(
{
'x[0][2]': 1.0,
'x[1][1]': 0.0
}, var_type="binary"))
self.assertRaises(
TypeError, lambda: model.decode_solution(
(1, 1), var_type="binary"))
# invalid var_type
self.assertRaises(AssertionError,
lambda: model.decode_solution([1, 1], var_type="sp"))
import dimod
from pyqubo import Constraint, Array
exactsolver = dimod.ExactSolver()
# Set up variables
x = Array.create('x', shape=5, vartype='BINARY')
# Set up the QUBO. Start with the equation insisting that there are 3
# numbers turned on, and then the equation insisting that they sum up to 8.
H = Constraint((sum(x) - 3)**2, label='3_hot')
H += Constraint(
(x[0] + (2 * x[1]) + (3 * x[2]) + (4 * x[3]) + (5 * x[4]) - 8)**2,
label='8_sum')
# Compile the model, and turn it into a QUBO object
model = H.compile()
Q = model.to_qubo()
bqm = dimod.BinaryQuadraticModel.from_qubo(Q[0], offset=Q[1])
# solve the problem
results = exactsolver.sample(bqm)
# print the results
for sample, energy in results.data(['sample', 'energy']):
_, broken, _ = model.decode_solution(sample, vartype='BINARY')
if not broken:
print(sample, energy)
