def test_implicit_solver_topology(self):
"""All data adapters should work on Chimera-implied solvers."""
# sample
with BrickedClient() as client:
solver = client.get_solver(qpu=True)
response = solver.sample_ising(*self.problem, **self.params)
# simulate old solver, without explicit topology property
del response.solver.properties['topology']
# convert and validate
data = from_qmi_response(self.problem, response, params=self.params)
self.verify_data_encoding(problem=self.problem,
response=response,
solver=solver,
params=self.params,
data=data)
# in addition to `topology` missing, remove "structure", so Chimera
# can't be implied
delattr(solver, 'edges')
# ensure `from_qmi_response` adapter fails on unstructured old solver
with self.assertRaises(TypeError):
from_qmi_response(self.problem, response, params=self.params)
def test_from_qmi_response__qubo(self):
"""Inspector data is correctly encoded for a simple QUBO triangle problem."""
# vars = (0, 1, 4, 5)
# h = {}, J = {(0, 4): 1, (0, 5): 1, (1, 5): -1, (4, 1): 1}
problem = {
(0, 4): 0.5,
(0, 5): 0.5,
(1, 4): 0.5,
(1, 5): -0.5,
(4, 0): 0.5,
(4, 1): 0.5,
(5, 0): 0.5,
(5, 1): -0.5,
}
# sample
with BrickedClient() as client:
solver = client.get_solver(qpu=True)
response = solver.sample_qubo(problem, **self.params)
# convert
data = from_qmi_response(problem, response, params=self.params)
# validate data encoding
self.verify_data_encoding(problem=problem,
response=response,
solver=solver,
params=self.params,
data=data)
def test_from_qmi_response__problem_encoding(self):
"""Problem data is serialized even when it uses non-standard types (like numpy.int64)."""
# `self.problem` == (
# {0: 0.0, 4: 0.0, 1: 0.0, 5: 0.0},
# {(0, 4): 1.0, (0, 5): 1.0, (4, 1): 1.0, (1, 5): -1.0}
# )
h = {
0: numpy.int64(0),
4: numpy.double(0),
1: numpy.int8(0),
5: Decimal('0'),
}
J = {
(0, 4): numpy.float128(1),
(0, 5): Decimal('1'),
(4, 1): Fraction(2, 2),
(1, 5): numpy.int32(-1),
}
problem = (h, J)
# sample
with BrickedClient() as client:
solver = client.get_solver(qpu=True)
response = solver.sample_ising(*problem, **self.params)
# convert
data = from_qmi_response(problem, response, params=self.params)
# validate data encoding
self.verify_data_encoding(problem=problem,
response=response,
solver=solver,
params=self.params,
data=data)
def show_qmi(problem, response, embedding_context=None, warnings=None, params=None):
"""
Visualize a quantum machine instruction (QMI).
"""
data = from_qmi_response(problem=problem, response=response,
embedding_context=embedding_context,
warnings=warnings, params=params)
id_ = push_inspector_data(data)
return open_problem(id_)
def test_solver_graph_validation(self):
"""All data adapters should fail on non-Chimera/Pegasus solvers."""
# sample
with BrickedClient() as client:
solver = client.get_solver(qpu=True)
response = solver.sample_ising(*self.problem, **self.params)
# resolve it before we mangle with it
response.result()
# change solver topology to non-chimera/pegasus to test solver validation
response.solver.properties['topology']['type'] = 'unknown'
# ensure `from_qmi_response` adapter fails on unstructured solver
with self.assertRaises(TypeError):
from_qmi_response(self.problem, response, params=self.params)
# ensure `from_bqm_response` adapter fails on unstructured solver
with self.assertRaises(TypeError):
from_bqm_response(self.bqm,
self.embedding_context,
response,
params=self.params)
def test_solver_type_validation(self):
"""All data adapters should fail on non-StructuredSolvers."""
# sample
with BrickedClient() as client:
solver = client.get_solver(qpu=True)
response = solver.sample_ising(*self.problem, **self.params)
# resolve it before we mangle with it
response.result()
# change solver to unstructured to test solver validation
response.solver = unstructured_solver_mock
# ensure `from_qmi_response` adapter fails on unstructured solver
with self.assertRaises(TypeError):
from_qmi_response(self.problem, response, params=self.params)
# ensure `from_bqm_response` adapter fails on unstructured solver
with self.assertRaises(TypeError):
from_bqm_response(self.bqm,
self.embedding_context,
response,
params=self.params)
def test_from_qmi_response__ising(self):
"""Inspector data is correctly encoded for a simple Ising triangle problem."""
# sample
with BrickedClient() as client:
solver = client.get_solver(qpu=True)
response = solver.sample_ising(*self.problem, **self.params)
# convert
data = from_qmi_response(self.problem, response, params=self.params)
# validate data encoding
self.verify_data_encoding(problem=self.problem,
response=response,
solver=solver,
params=self.params,
data=data)
def test_from_qmi_response__single_qubit(self):
"""Problem/solutions are correctly encoded for single-qubit problems."""
problem = ({0: 1}, {})
# sample
with BrickedClient() as client:
solver = client.get_solver(qpu=True)
response = solver.sample_ising(*problem, **self.params)
# convert
data = from_qmi_response(problem, response, params=self.params)
# validate data encoding
self.verify_data_encoding(problem=problem,
response=response,
solver=solver,
params=self.params,
data=data)
def test_from_qmi_response__couplings_only(self):
"""Problem/solutions are correctly encoded when qubits are referenced via couplings only."""
problem = ({}, self.ising_embedded[1])
# sample
with BrickedClient() as client:
solver = client.get_solver(qpu=True)
response = solver.sample_ising(*problem, **self.params)
# convert
data = from_qmi_response(problem, response, params=self.params)
# validate data encoding
self.verify_data_encoding(problem=problem,
response=response,
solver=solver,
params=self.params,
data=data)
def test_from_qmi_response__ising_bqm(self):
"""Inspector data is correctly encoded for a simple Ising triangle problem given as a BQM."""
problem = (self.bqm_embedded.linear, self.bqm_embedded.quadratic)
# sample
with BrickedClient() as client:
solver = client.get_solver(qpu=True)
response = solver.sample_ising(*problem, **self.params)
# convert
data = from_qmi_response(problem, response, params=self.params)
# validate data encoding
self.verify_data_encoding(problem=problem,
response=response,
solver=solver,
params=self.params,
data=data)
def test_problem_label_in_response(self):
"""All data adapters should propagate problem label."""
# sample ising -> response
with BrickedClient() as client:
solver = client.get_solver(qpu=True)
response = solver.sample_ising(*self.problem,
label=self.label,
**self.params)
# ensure `from_qmi_response` adapter propagates label
data = from_qmi_response(self.problem, response, params=self.params)
self.assertEqual(data['details']['label'], self.label)
# ensure `from_bqm_response` adapter propagates label
data = from_bqm_response(self.bqm,
self.embedding_context,
response,
params=self.params)
self.assertEqual(data['details']['label'], self.label)
