def test_qpu_result_to_cirq_result():
result = ionq.QPUResult({
0b00: 1,
0b01: 2
},
num_qubits=2,
measurement_dict={'x': [0, 1]})
assert result.to_cirq_result() == cirq.Result(
params=cirq.ParamResolver({}),
measurements={'x': [[0, 0], [0, 1], [0, 1]]})
params = cirq.ParamResolver({'a': 0.1})
assert result.to_cirq_result(params) == cirq.Result(
params=params, measurements={'x': [[0, 0], [0, 1], [0, 1]]})
result = ionq.QPUResult({
0b00: 1,
0b01: 2
},
num_qubits=2,
measurement_dict={'x': [0]})
assert result.to_cirq_result() == cirq.Result(
params=cirq.ParamResolver({}), measurements={'x': [[0], [0], [0]]})
result = ionq.QPUResult({
0b00: 1,
0b01: 2
},
num_qubits=2,
measurement_dict={'x': [1]})
assert result.to_cirq_result() == cirq.Result(
params=cirq.ParamResolver({}), measurements={'x': [[0], [1], [1]]})
# cirq.Result only compares pandas data frame, so possible to have supplied an list of
# list instead of a numpy multidimensional array. Check this here.
assert type(result.to_cirq_result().measurements['x']) == np.ndarray
def test_qpu_result_to_cirq_result():
result = ionq.QPUResult({0b00: 1, 0b01: 2}, num_qubits=2, measurement_dict={'x': [0, 1]})
assert result.to_cirq_result() == cirq.ResultDict(
params=cirq.ParamResolver({}), measurements={'x': np.array([[0, 0], [0, 1], [0, 1]])}
)
params = cirq.ParamResolver({'a': 0.1})
assert result.to_cirq_result(params) == cirq.ResultDict(
params=params, measurements={'x': np.array([[0, 0], [0, 1], [0, 1]])}
)
result = ionq.QPUResult({0b00: 1, 0b01: 2}, num_qubits=2, measurement_dict={'x': [0]})
assert result.to_cirq_result() == cirq.ResultDict(
params=cirq.ParamResolver({}), measurements={'x': np.array([[0], [0], [0]])}
)
result = ionq.QPUResult({0b00: 1, 0b01: 2}, num_qubits=2, measurement_dict={'x': [1]})
assert result.to_cirq_result() == cirq.ResultDict(
params=cirq.ParamResolver({}), measurements={'x': np.array([[0], [1], [1]])}
)
# cirq.Result only compares pandas data frame, so possible to have supplied an list of
# list instead of a numpy multidimensional array. Check this here.
assert type(result.to_cirq_result().measurements['x']) == np.ndarray
# Results bitstreams need to be consistent betwween measurement keys
# Ordering is by bitvector, so 0b01 0b01 0b10 should be the ordering for all measurement dicts.
result = ionq.QPUResult(
{0b10: 1, 0b01: 2}, num_qubits=2, measurement_dict={'x': [0, 1], 'y': [0], 'z': [1]}
)
assert result.to_cirq_result() == cirq.ResultDict(
params=cirq.ParamResolver({}),
measurements={
'x': np.array([[0, 1], [0, 1], [1, 0]]),
'y': np.array([[0], [0], [1]]),
'z': np.array([[1], [1], [0]]),
},
)
def test_qpu_result_measurement_multiple_key():
result = ionq.QPUResult(
{0b00: 10, 0b01: 20}, num_qubits=2, measurement_dict={'a': [0], 'b': [1]}
)
assert result.counts('a') == {0b0: 30}
assert result.counts('b') == {0b0: 10, 0b1: 20}
result = ionq.QPUResult(
{0b00: 10, 0b01: 20}, num_qubits=2, measurement_dict={'a': [1], 'b': [0]}
)
assert result.counts('a') == {0b0: 10, 0b1: 20}
assert result.counts('b') == {0b0: 30}
def test_qpu_result_eq():
equals_tester = cirq.testing.EqualsTester()
equals_tester.add_equality_group(
ionq.QPUResult({
0: 10,
1: 10
},
num_qubits=1,
measurement_dict={'a': [0]}),
ionq.QPUResult({
0: 10,
1: 10
},
num_qubits=1,
measurement_dict={'a': [0]}),
)
equals_tester.add_equality_group(
ionq.QPUResult({
0: 10,
1: 20
},
num_qubits=1,
measurement_dict={'a': [0]}))
equals_tester.add_equality_group(
ionq.QPUResult({
0: 15,
1: 15
},
num_qubits=1,
measurement_dict={'a': [0]}))
equals_tester.add_equality_group(
ionq.QPUResult({
0: 10,
1: 10
},
num_qubits=2,
measurement_dict={'a': [0]}))
equals_tester.add_equality_group(
ionq.QPUResult({
0: 10,
1: 10
},
num_qubits=1,
measurement_dict={'b': [0]}))
equals_tester.add_equality_group(
ionq.QPUResult({
0: 10,
1: 10
},
num_qubits=1,
measurement_dict={'a': [1]}))
equals_tester.add_equality_group(
ionq.QPUResult({
0: 10,
1: 10
},
num_qubits=1,
measurement_dict={'a': [0, 1]}))
def test_job_results_qpu():
job_dict = {
'id': 'my_id',
'status': 'completed',
'qubits': '2',
'target': 'qpu',
'metadata': {
'shots': 1000,
'measurement0': f'a{chr(31)}0,1'
},
'data': {
'histogram': {
'0': '0.6',
'2': '0.4'
}
},
'warning': {
'messages': ['foo', 'bar']
},
}
job = ionq.Job(None, job_dict)
with warnings.catch_warnings(record=True) as w:
results = job.results()
assert len(w) == 2
assert "foo" in str(w[0].message)
assert "bar" in str(w[1].message)
expected = ionq.QPUResult({0: 600, 1: 400}, 2, {'a': [0, 1]})
assert results == expected
def test_job_results_poll(mock_sleep):
ready_job = {
'id': 'my_id',
'status': 'ready',
}
completed_job = {
'id': 'my_id',
'status': 'completed',
'qubits': '1',
'target': 'qpu',
'metadata': {
'shots': 1000
},
'data': {
'histogram': {
'0': '0.6',
'1': '0.4'
}
},
}
mock_client = mock.MagicMock()
mock_client.get_job.side_effect = [ready_job, completed_job]
job = ionq.Job(mock_client, ready_job)
results = job.results(polling_seconds=0)
assert results == ionq.QPUResult({0: 600, 1: 400}, 1, measurement_dict={})
mock_sleep.assert_called_once()
def test_ordered_results_invalid_key():
result = ionq.QPUResult({
0b00: 1,
0b01: 2
},
num_qubits=2,
measurement_dict={'x': [1]})
with pytest.raises(ValueError, match='is not a key for'):
_ = result.ordered_results('y')
def test_qpu_result_to_cirq_result_no_keys():
result = ionq.QPUResult({
0b00: 1,
0b01: 2
},
num_qubits=2,
measurement_dict={})
with pytest.raises(ValueError, match='cirq results'):
_ = result.to_cirq_result()
def test_qpu_result_fields():
result = ionq.QPUResult({
0: 10,
1: 10
},
num_qubits=1,
measurement_dict={'a': [0]})
assert result.counts() == {0: 10, 1: 10}
assert result.repetitions() == 20
assert result.num_qubits() == 1
assert result.measurement_dict() == {'a': [0]}
def test_qpu_result_to_cirq_result_multiple_keys():
result = ionq.QPUResult(
{0b000: 2, 0b101: 3}, num_qubits=3, measurement_dict={'x': [1], 'y': [2, 0]}
)
assert result.to_cirq_result() == cirq.ResultDict(
params=cirq.ParamResolver({}),
measurements={
'x': np.array([[0], [0], [0], [0], [0]]),
'y': np.array([[0, 0], [0, 0], [1, 1], [1, 1], [1, 1]]),
},
)
def test_qpu_result_bad_measurement_key():
result = ionq.QPUResult({
0b00: 10,
0b01: 20
},
num_qubits=2,
measurement_dict={
'a': [0],
'b': [1]
})
with pytest.raises(ValueError, match='bad'):
result.counts('bad')
def test_qpu_result_measurement_key():
result = ionq.QPUResult({
0b00: 10,
0b01: 20
},
num_qubits=2,
measurement_dict={'a': [0]})
assert result.counts() == {0b00: 10, 0b01: 20}
result = ionq.QPUResult({
0b00: 10,
0b01: 20
},
num_qubits=2,
measurement_dict={'a': [0]})
assert result.counts('a') == {0b0: 30}
result = ionq.QPUResult({
0b00: 10,
0b01: 20
},
num_qubits=2,
measurement_dict={'a': [1]})
assert result.counts('a') == {0b0: 10, 0b1: 20}
result = ionq.QPUResult({
0b00: 10,
0b01: 20
},
num_qubits=2,
measurement_dict={'a': [0, 1]})
assert result.counts('a') == {0b00: 10, 0b01: 20}
result = ionq.QPUResult({
0b00: 10,
0b01: 20
},
num_qubits=2,
measurement_dict={'a': [1, 0]})
assert result.counts('a') == {0b00: 10, 0b10: 20}
result = ionq.QPUResult({
0b000: 10,
0b111: 20
},
num_qubits=3,
measurement_dict={'a': [2]})
assert result.counts('a') == {0b0: 10, 0b1: 20}
result = ionq.QPUResult({
0b000: 10,
0b100: 20
},
num_qubits=3,
measurement_dict={'a': [1, 2]})
assert result.counts('a') == {0b00: 30}
def test_job_results_qpu_target_endianness():
job_dict = {
'id': 'my_id',
'status': 'completed',
'qubits': '2',
'target': 'qpu.target',
'metadata': {
'shots': 1000
},
'data': {
'histogram': {
'0': '0.6',
'1': '0.4'
}
},
}
job = ionq.Job(None, job_dict)
results = job.results()
assert results == ionq.QPUResult({0: 600, 2: 400}, 2, measurement_dict={})
def test_job_results_qpu():
job_dict = {
'id': 'my_id',
'status': 'completed',
'qubits': '2',
'target': 'qpu',
'metadata': {
'shots': 1000,
'measurement0': f'a{chr(31)}0,1'
},
'data': {
'histogram': {
'0': '0.6',
'2': '0.4'
}
},
}
job = ionq.Job(None, job_dict)
results = job.results()
expected = ionq.QPUResult({0: 600, 1: 400}, 2, {'a': [0, 1]})
assert results == expected
def test_job_results_rounding_qpu():
job_dict = {
'id': 'my_id',
'status': 'completed',
'qubits': '2',
'target': 'qpu',
'metadata': {
'shots': 5000,
'measurement0': f'a{chr(31)}0,1'
},
'data': {
'histogram': {
'0': '0.0006',
'2': '0.9994'
}
},
}
# 5000*0.0006 ~ 2.9999 but should be interpreted as 3
job = ionq.Job(None, job_dict)
expected = ionq.QPUResult({0: 3, 1: 4997}, 2, {'a': [0, 1]})
results = job.results()
assert results == expected
def test_qpu_result_str():
result = ionq.QPUResult({0: 10, 1: 10}, num_qubits=2, measurement_dict={})
assert str(result) == '00: 10\n01: 10'
