def test_equality_of_qbit(self): a, b, c = Binary("a"), Binary("b"), Binary("a") self.assertTrue(a == c) self.assertFalse(a != c) self.assertTrue(hash(a) == hash(c)) self.assertTrue(a != b) self.assertTrue(a != Spin("a"))
def test_compile_div(self): a, b = Binary("a"), Binary("b") exp = a * b / 2 + 1 expected_qubo = {('a', 'a'): 0.0, ('a', 'b'): 0.5, ('b', 'b'): 0.0} expected_offset = 1.0 q, offset = exp.compile().to_qubo() self.compile_check(exp, expected_qubo, expected_offset)
def test_compile_power(self): a, b = Binary("a"), Binary("b") exp = (a + b)**3 expected_qubo = {('a', 'a'): 1.0, ('a', 'b'): 6.0, ('b', 'b'): 1.0} expected_offset = 0.0 q, offset = exp.compile().to_qubo() self.compile_check(exp, expected_qubo, expected_offset)
def test_compile_expand_add(self): a, b = Binary("a"), Binary("b") exp = (a + b) * (a - b) # expected_qubo = {('a', 'a'): 1.0, ('a', 'b'): 0.0, ('b', 'b'): -1.0} expected_qubo = {('a', 'a'): 1.0, ('b', 'b'): -1.0} expected_offset = 0.0 self.compile_check(exp, expected_qubo, expected_offset)
def test_compile_binary(self): a, b = Binary("a"), Binary("b") exp = 1 + a * b + a - 2 # expected_qubo = {('a', 'a'): 1.0, ('a', 'b'): 1.0, ('b', 'b'): 0.0} expected_qubo = {('a', 'a'): 1.0, ('a', 'b'): 1.0} expected_offset = -1 self.compile_check(exp, expected_qubo, expected_offset)
def test_compile_reduce_degree(self): a, b, c, d = Binary("a"), Binary("b"), Binary("c"), Binary("d") exp = a * b * c + b * c * d expected_qubo = { ('a', 'a'): 0.0, ('a', 'b*c'): 1.0, ('b', 'b'): 0.0, ('b', 'b*c'): -10.0, ('b', 'c'): 5.0, ('c', 'c'): 0.0, ('b*c', 'c'): -10.0, ('b*c', 'b*c'): 15.0, ('b*c', 'd'): 1.0, ('d', 'd'): 0.0 } expected_offset = 0.0 expected_structure = { 'a': ('a', ), 'b': ('b', ), 'c': ('c', ), 'd': ('d', ) } self.compile_check(exp, expected_qubo, expected_offset, expected_structure)
def test_or(self): a, b = Binary('a'), Binary('b') exp = Or(a, b) model = exp.compile() for a, b in itertools.product(*[(0, 1)] * 2): e = int(model.energy({'a': a, 'b': b}, vartype='BINARY')) self.assertEqual(int(a + b > 0), e)
def test_to_qubo_with_index(self): a, b = Binary("a"), Binary("b") exp = 1 + a * b + a - 2 model = exp.compile() qubo, offset = model.to_qubo(index_label=True) assert_qubo_equal(qubo, {(0, 0): 1.0, (0, 1): 1.0, (1, 1): 0.0}) self.assertTrue(offset == -1)
def test_compile_3rd_order(self): a, b = Binary("a"), Binary("b") exp = (a + b - 2)**3 expected_qubo = {('a', 'a'): 7.0, ('a', 'b'): -6.0, ('b', 'b'): 7.0} expected_offset = -8.0 expected_structure = {'a': ('a', ), 'b': ('b', )} self.compile_check(exp, expected_qubo, expected_offset, expected_structure)
def test_compile_2nd_order(self): a, b = Binary("a"), Binary("b") exp = (Add(a, b) - 3)**2 expected_qubo = {('a', 'a'): -5.0, ('a', 'b'): 2.0, ('b', 'b'): -5.0} expected_offset = 9.0 expected_structure = {'a': ('a', ), 'b': ('b', )} self.compile_check(exp, expected_qubo, expected_offset, expected_structure)
def test_compile_expand(self): a, b = Binary("a"), Binary("b") exp = (a + b) * (a - b) expected_qubo = {('a', 'a'): 1.0, ('a', 'b'): 0.0, ('b', 'b'): -1.0} expected_offset = 0.0 expected_structure = {'a': ('a', ), 'b': ('b', )} self.compile_check(exp, expected_qubo, expected_offset, expected_structure)
def test_to_qubo(self): a, b = Binary("a"), Binary("b") exp = 1 + a * b + a - 2 model = exp.compile() qubo, offset = model.to_qubo() # assert_qubo_equal(qubo, {("a", "a"): 1.0, ("a", "b"): 1.0, ("b", "b"): 0.0}) assert_qubo_equal(qubo, {("a", "a"): 1.0, ("a", "b"): 1.0}) self.assertTrue(offset == -1)
def test_compile_div(self): a, b = Binary("a"), Binary("b") exp = (a + b - 2) / 2 expected_qubo = {('a', 'a'): 0.5, ('b', 'b'): 0.5} expected_offset = -1 expected_structure = {'a': ('a', ), 'b': ('b', )} self.compile_check(exp, expected_qubo, expected_offset, expected_structure)
def test_compile_subh(self): a, b = Binary("a"), Binary("b") p = Placeholder("p") exp = p * SubH((a + b - 1)**2, label="subh") + a * b expected_qubo = {('a', 'a'): -3.0, ('a', 'b'): 7.0, ('b', 'b'): -3.0} expected_offset = 3 feed_dict = {"p": 3} self.compile_check(exp, expected_qubo, expected_offset, feed_dict)
def test_to_ising_with_index(self): a, b = Binary("a"), Binary("b") exp = 1 + a * b + a - 2 model = exp.compile() linear, quad, offset = model.to_ising(index_label=True) self.assertTrue(linear == {0: 0.75, 1: 0.25}) assert_qubo_equal(quad, {(0, 1): 0.25}) self.assertTrue(offset == -0.25)
def test_not(self): a, b = Binary("a"), Binary("b") exp = NotConst(a, b, label="not") model = exp.compile() self.assertTrue(model.energy({"a": 1, "b": 0}, vartype="BINARY") == 0) self.assertTrue(model.energy({"a": 0, "b": 1}, vartype="BINARY") == 0) self.assertTrue(model.energy({"a": 1, "b": 1}, vartype="BINARY") > 0) self.assertTrue(model.energy({"a": 0, "b": 0}, vartype="BINARY") > 0)
def test_to_ising(self): a, b = Binary("a"), Binary("b") exp = 1 + a * b + a - 2 model = exp.compile() linear, quad, offset = model.to_ising() self.assertTrue(linear == {'a': 0.75, 'b': 0.25}) assert_qubo_equal(quad, {('a', 'b'): 0.25}) self.assertTrue(offset == -0.25)
def test_compile(self): a, b = Binary("a"), Binary("b") exp = 1 + a * b + a - 2 expected_qubo = {('a', 'a'): 1.0, ('a', 'b'): 1.0, ('b', 'b'): 0.0} expected_offset = -1 expected_structure = {'a': ('a', ), 'b': ('b', )} self.compile_check(exp, expected_qubo, expected_offset, expected_structure)
def test_array_error(self): # raise ValueError when the size of the sub lists is not same with self.assertRaises(ValueError): Array([[Binary('x0'), Binary('x1')], [Binary('x2')]]) # raise TypeError when index is neither int nor tuple[int] with self.assertRaises(TypeError): array = Array([Binary('x0'), Binary('x1')]) array[1.5]
def test_compile_placeholder(self): a, b = Binary("a"), Binary("b") p, q, r = Placeholder("p"), Placeholder("q"), Placeholder("r") exp = r * (q * p * (a + b)**2 + q) expected_qubo = {('a', 'a'): 12.0, ('a', 'b'): 24.0, ('b', 'b'): 12.0} expected_offset = 4 feed_dict = {"p": 3, "q": 2, "r": 2} q, offset = exp.compile().to_qubo(feed_dict=feed_dict) self.compile_check(exp, expected_qubo, expected_offset, feed_dict)
def test_xor(self): a, b = Binary('a'), Binary('b') exp = Xor(a, b) model = exp.compile() for a, b in itertools.product(*[(0, 1)] * 2): e = int(model.energy({'a': a, 'b': b}, vartype='BINARY')) if (a == 1 and b == 0) or (a == 0 and b == 1): self.assertTrue(e == 1) else: self.assertTrue(e == 0)
def test_array_division(self): array1 = Array.create('x', (2, 2), 'BINARY') expected = Array([[Binary('x[0][0]') / 2.0, Binary('x[0][1]') / 2.0], [Binary('x[1][0]') / 2.0, Binary('x[1][1]') / 2.0]]) self.assertTrue(array1 / 2.0 == expected) self.assertRaises(ValueError, lambda: 1 / array1) self.assertRaises(ValueError, lambda: array1 / array1)
def test_sub_qubo(self): a, b, c = Binary("a"), Binary("b"), Placeholder("c") exp = 1 + a * b + c * (a - 2) model = exp.compile() var_set = VarSetFromVarLabels([b]) sample_sol = {'a': 0, 'b': 1} sub_qubo, offset = model.sub_qubo(var_set, sample_sol, feed_dict={'c': 3.0}) self.assertTrue(sub_qubo == {("b", "b"): 0.0}) self.assertTrue(offset == -5.0)
def test_equality_of_const(self): c1 = Constraint(Binary("a"), label="c1") c2 = Constraint(Binary("b"), label="c1") c3 = Constraint(Binary("a"), label="c3") c4 = Constraint(Binary("a"), label="c1") self.assertTrue(c1 == c4) self.assertFalse(c1 != c4) self.assertTrue(hash(c1) == hash(c4)) self.assertTrue(c1 != c2) self.assertTrue(c1 != c3) self.assertTrue(c1 != Binary("a"))
def test_and_from_model(self): a, b, c = Binary("a"), Binary("b"), Binary("c") exp = (SubH(a + b, 'n1') + SubH(b + c, 'n2'))**2 model = exp.compile() set_x = VarSetFromSubH('n1') set_y = VarSetFromSubH('n2') set_z = AndVars(set_x, set_y) self.assertTrue(set_x.var_names(model) == {'a', 'b'}) self.assertTrue(set_y.var_names(model) == {'b', 'c'}) self.assertTrue(set_z.var_names(model) == {'b'})
def test_sub_ising(self): a, b, c = Binary("a"), Binary("b"), Placeholder("c") exp = 1 + a * b + c * (a - 2) model = exp.compile() var_set = VarSetFromVarLabels([b]) sample_sol = {'a': 0, 'b': 1} linear, quad, offset = model.sub_ising(var_set, sample_sol, feed_dict={'c': 3.0}) self.assertTrue(linear == {'b': 0.0}) self.assertTrue(quad == {}) self.assertTrue(offset == -5.0)
def test_or_from_vars(self): a, b, c = Binary("a"), Binary("b"), Binary("c") exp = (SubH(a + b, 'n1') + SubH(b + c, 'n2'))**2 model = exp.compile() set_x = VarSetFromVarLabels([a, b]) set_y = VarSetFromVarLabels([b, c]) set_z = OrVars(set_x, set_y) self.assertTrue(set_x.var_names(model) == {'a', 'b'}) self.assertTrue(set_y.var_names(model) == {'b', 'c'}) self.assertTrue(set_z.var_names(model) == {'a', 'b', 'c'})
def test_or(self): a, b, c = Binary("a"), Binary("b"), Binary("c") exp = OrConst(a, b, c, label="or") model = exp.compile() self.assertTrue( model.energy({ "a": 1, "b": 1, "c": 1 }, vartype="BINARY") == 0) self.assertTrue( model.energy({ "a": 1, "b": 0, "c": 1 }, vartype="BINARY") == 0) self.assertTrue( model.energy({ "a": 0, "b": 1, "c": 1 }, vartype="BINARY") == 0) self.assertTrue( model.energy({ "a": 0, "b": 0, "c": 0 }, vartype="BINARY") == 0) self.assertTrue( model.energy({ "a": 1, "b": 1, "c": 0 }, vartype="BINARY") > 0) self.assertTrue( model.energy({ "a": 1, "b": 0, "c": 0 }, vartype="BINARY") > 0) self.assertTrue( model.energy({ "a": 0, "b": 1, "c": 0 }, vartype="BINARY") > 0) self.assertTrue( model.energy({ "a": 0, "b": 0, "c": 1 }, vartype="BINARY") > 0)
def test_compile_constraint(self): a, b, c = Binary("a"), Binary("b"), Binary("c") exp = Constraint(a * b * c, label="constraint") # expected_qubo = {('a', '0*1'): -10.0, ('b', '0*1'): -10.0, ('0*1', '0*1'): 15.0, ('a', 'a'): 0.0, ('a', 'b'): 5.0, ('c', '0*1'): 1.0, ('b', 'b'): 0.0, ('c', 'c'): 0.0} expected_qubo = { ('a', 'a * b'): -10.0, ('b', 'a * b'): -10.0, ('a * b', 'a * b'): 15.0, ('a', 'b'): 5.0, ('c', 'a * b'): 1.0 } expected_offset = 0 self.compile_check(exp, expected_qubo, expected_offset, feed_dict={})
def test_compile_with_penalty(self): class CustomPenalty(WithPenalty): def __init__(self, hamiltonian, penalty, label): super().__init__(hamiltonian, penalty, label) a, b = Binary("a"), Binary("b") p = Placeholder("p") custom_penalty = p * CustomPenalty(a + b, a * b, "label") expected_qubo = {('a', 'a'): 2.0, ('a', 'b'): 1.0, ('b', 'b'): 2.0} expected_offset = 0.0 feed_dict = {"p": 2} self.compile_check(custom_penalty, expected_qubo, expected_offset, feed_dict)