def test_trial_result_equality():
et = cirq.testing.EqualsTester()
et.add_equality_group(
cirq.TrialResult(params=cirq.ParamResolver({}),
repetitions=5,
measurements={'a': np.array([[0]])}))
et.add_equality_group(
cirq.TrialResult(params=cirq.ParamResolver({}),
repetitions=6,
measurements={'a': np.array([[0]])}))
et.add_equality_group(
cirq.TrialResult(params=cirq.ParamResolver({}),
repetitions=5,
measurements={'a': np.array([[1]])}))
def test_hamiltonian_objective_value_not_implemented():
obj = HamiltonianObjective(test_hamiltonian)
trial_result = cirq.TrialResult(params=cirq.ParamResolver({}),
measurements={},
repetitions=1)
with pytest.raises(NotImplementedError):
_ = obj.value(trial_result)
def test_histogram():
result = cirq.TrialResult(params=cirq.ParamResolver({}),
repetitions=5,
measurements={
'ab':
np.array(
[[0, 1], [0, 1], [0, 1], [1, 0], [0, 1]],
dtype=np.bool),
'c':
np.array([[0], [0], [1], [0], [1]],
dtype=np.bool)
})
assert result.histogram(key='ab') == collections.Counter({1: 4, 2: 1})
assert result.histogram(key='ab', fold_func=tuple) == collections.Counter({
(False, True):
4,
(True, False):
1
})
assert result.histogram(key='ab',
fold_func=lambda e: None) == collections.Counter({
None:
5,
})
assert result.histogram(key='c') == collections.Counter({0: 3, 1: 2})
def test_repr():
v = cirq.TrialResult(params=cirq.ParamResolver({'a': 2}),
repetitions=2,
measurements={'m': np.array([[1, 2]])})
assert repr(v) == ("TrialResult(params=ParamResolver({'a': 2}), "
"repetitions=2, measurements={'m': array([[1, 2]])})")
def test_text_diagram_jupyter():
result = cirq.TrialResult(params=cirq.ParamResolver({}),
repetitions=5,
measurements={
'ab':
np.array(
[[0, 1], [0, 1], [0, 1], [1, 0], [0, 1]],
dtype=np.bool),
'c':
np.array([[0], [0], [1], [0], [1]],
dtype=np.bool)
})
# Test Jupyter console output from
class FakePrinter:
def __init__(self):
self.text_pretty = ''
def text(self, to_print):
self.text_pretty += to_print
p = FakePrinter()
result._repr_pretty_(p, False)
assert p.text_pretty == 'ab=00010, 11101\nc=00101'
# Test cycle handling
p = FakePrinter()
result._repr_pretty_(p, True)
assert p.text_pretty == 'TrialResult(...)'
def test_results_to_proto_sweep_repetitions():
measurements = [v2.MeasureInfo('foo', [q(0, 0)], slot=0)]
trial_results = [[
cirq.TrialResult(params=cirq.ParamResolver({'i': 0}),
measurements={
'foo': np.array([[0]], dtype=bool),
},
repetitions=1),
cirq.TrialResult(params=cirq.ParamResolver({'i': 1}),
measurements={
'foo': np.array([[0], [1]], dtype=bool),
},
repetitions=2),
]]
with pytest.raises(ValueError, match='different numbers of repetitions'):
v2.results_to_proto(trial_results, measurements)
def test_results_to_proto():
measurements = [v2.MeasureInfo('foo', [q(0, 0)], slot=0)]
trial_results = [
[
cirq.TrialResult(params=cirq.ParamResolver({'i': 0}),
measurements={
'foo': np.array([[0], [1], [0], [1]],
dtype=bool),
},
repetitions=4),
cirq.TrialResult(params=cirq.ParamResolver({'i': 1}),
measurements={
'foo': np.array([[0], [1], [1], [0]],
dtype=bool),
},
repetitions=4),
],
[
cirq.TrialResult(params=cirq.ParamResolver({'i': 0}),
measurements={
'foo': np.array([[0], [1], [0], [1]],
dtype=bool),
},
repetitions=4),
cirq.TrialResult(params=cirq.ParamResolver({'i': 1}),
measurements={
'foo': np.array([[0], [1], [1], [0]],
dtype=bool),
},
repetitions=4),
],
]
proto = v2.results_to_proto(trial_results, measurements)
assert isinstance(proto, result_pb2.Result)
assert len(proto.sweep_results) == 2
deserialized = v2.results_from_proto(proto, measurements)
assert len(deserialized) == 2
for sweep_results, expected in zip(deserialized, trial_results):
assert len(sweep_results) == len(expected)
for trial_result, expected_trial_result in zip(sweep_results, expected):
assert trial_result.params == expected_trial_result.params
assert trial_result.repetitions == expected_trial_result.repetitions
np.testing.assert_array_equal(
trial_result.measurements['foo'],
expected_trial_result.measurements['foo'])
def test_swap_network_trotter_ansatz_value_not_implemented():
ansatz = SwapNetworkTrotterAnsatz(test_hamiltonian)
study = HamiltonianVariationalStudy('study', ansatz, test_hamiltonian)
trial_result = cirq.TrialResult(params=ansatz.param_resolver(
ansatz.default_initial_params()),
measurements={},
repetitions=1)
with pytest.raises(NotImplementedError):
_ = study.value(trial_result)
def test_multi_measurement_histogram():
result = cirq.TrialResult(
params=cirq.ParamResolver({}),
repetitions=5,
measurements={
'ab': np.array([[0, 1],
[0, 1],
[0, 1],
[1, 0],
[0, 1]], dtype=np.bool),
'c': np.array([[0], [0], [1], [0], [1]], dtype=np.bool)
})
assert result.multi_measurement_histogram(keys=[]) == collections.Counter(
{(): 5})
assert (result.multi_measurement_histogram(keys=['ab']) ==
collections.Counter({
(1,): 4,
(2,): 1,
}))
assert (result.multi_measurement_histogram(keys=['c']) ==
collections.Counter({
(0,): 3,
(1,): 2,
}))
assert (result.multi_measurement_histogram(keys=['ab', 'c']) ==
collections.Counter({
(1, 0,): 2,
(1, 1,): 2,
(2, 0,): 1,
}))
assert result.multi_measurement_histogram(keys=[],
fold_func=lambda e: None
) == collections.Counter({
None: 5,
})
assert result.multi_measurement_histogram(keys=['ab'],
fold_func=lambda e: None
) == collections.Counter({
None: 5,
})
assert result.multi_measurement_histogram(keys=['ab', 'c'],
fold_func=lambda e: None
) == collections.Counter({
None: 5,
})
assert result.multi_measurement_histogram(keys=['ab', 'c'],
fold_func=lambda e: tuple(
tuple(f) for f in e)
) == collections.Counter({
((False, True), (False,)): 2,
((False, True), (True,)): 2,
((True, False), (False,)): 1,
})
def test_json_bit_packing_and_dtype():
prng = np.random.RandomState(1234)
bits = prng.randint(2, size=(256, 256)).astype(np.uint8)
digits = prng.randint(256, size=(256, 256)).astype(np.uint8)
bits_result = cirq.TrialResult(params=cirq.ParamResolver({}),
measurements={'m': bits})
digits_result = cirq.TrialResult(params=cirq.ParamResolver({}),
measurements={'m': digits})
bits_json = cirq.to_json(bits_result)
digits_json = cirq.to_json(digits_result)
loaded_bits_result = cirq.read_json(json_text=bits_json)
loaded_digits_result = cirq.read_json(json_text=digits_json)
assert loaded_bits_result.measurements['m'].dtype == np.uint8
assert loaded_digits_result.measurements['m'].dtype == np.uint8
np.testing.assert_allclose(len(bits_json), len(digits_json) / 8, rtol=0.02)
def test_str():
result = cirq.TrialResult(params=cirq.ParamResolver({}),
repetitions=5,
measurements={
'ab':
np.array([[0, 1], [0, 1], [0, 1], [1, 0],
[0, 1]]),
'c':
np.array([[0], [0], [1], [0], [1]])
})
assert str(result) == 'ab=00010, 11101\nc=00101'
def test_run_simulator_sweeps():
simulator = cirq.SimulatesSamples()
expected_measurements = {'a': np.array([[1]])}
simulator._run.return_value = expected_measurements
circuit = mock.Mock(cirq.Circuit)
param_resolvers = [mock.Mock(cirq.ParamResolver),
mock.Mock(cirq.ParamResolver)]
expected_results = [cirq.TrialResult(repetitions=10,
measurements=expected_measurements,
params=param_resolvers[0]),
cirq.TrialResult(repetitions=10,
measurements=expected_measurements,
params=param_resolvers[1])]
assert expected_results == simulator.run_sweep(program=circuit,
repetitions=10,
params=param_resolvers)
simulator._run.assert_called_with(circuit=circuit,
repetitions=10,
param_resolver=mock.ANY)
assert simulator._run.call_count == 2
def run_sweep(self, program, params, repetitions):
"""Returns all ones in the correct sample shape."""
return [
cirq.TrialResult(
params=param,
measurements={
'tfq':
np.array([[1] * len(program.all_qubits())] *
repetitions,
dtype=np.int32),
}) for param in cirq.to_resolvers(params)
]
def test_run_simulator_run():
simulator = cirq.SimulatesSamples()
expected_measurements = {'a': np.array([[1]])}
simulator._run.return_value = expected_measurements
circuit = mock.Mock(cirq.Circuit)
param_resolver = mock.Mock(cirq.ParamResolver)
expected_result = cirq.TrialResult(repetitions=10,
measurements=expected_measurements,
params=param_resolver)
assert expected_result == simulator.run(program=circuit,
repetitions=10,
param_resolver=param_resolver)
simulator._run.assert_called_once_with(circuit=circuit,
repetitions=10,
param_resolver=param_resolver)
def test_compute_displays_result_eq():
eq = cirq.testing.EqualsTester()
u = cirq.ComputeDisplaysResult(params=cirq.ParamResolver({'a': 2}),
display_values={'k': 1.0})
v = cirq.ComputeDisplaysResult(params=cirq.ParamResolver({'a': 2}),
display_values={'k': 1.0})
w = cirq.ComputeDisplaysResult(params=cirq.ParamResolver({'b': 2}),
display_values={'k': 1.0})
x = cirq.TrialResult(params=cirq.ParamResolver({'a': 2}),
measurements={'k': np.array([[1]])},
repetitions=1)
eq.add_equality_group(u, v)
eq.add_equality_group(w)
eq.add_equality_group(x)
def test_run_delegation(create_job, get_results):
create_job.return_value = (
'steve',
qtypes.QuantumJob(name='projects/a/programs/b/jobs/steve',
execution_status=qtypes.ExecutionStatus(
state=qtypes.ExecutionStatus.State.SUCCESS)))
get_results.return_value = qtypes.QuantumResult(result=_to_any(
Merge(
"""sweep_results: [{
repetitions: 4,
parameterized_results: [{
params: {
assignments: {
key: 'a'
value: 1
}
},
measurement_results: {
key: 'q'
qubit_measurement_results: [{
qubit: {
id: '1_1'
}
results: '\006'
}]
}
}]
}]
""", v2.result_pb2.Result())))
program = cg.EngineProgram('a', 'b', EngineContext())
param_resolver = cirq.ParamResolver({})
results = program.run(job_id='steve',
repetitions=10,
param_resolver=param_resolver,
processor_ids=['mine'])
assert results == cirq.TrialResult(
params=cirq.ParamResolver({'a': 1.0}),
measurements={
'q': np.array([[False], [True], [True], [False]], dtype=np.bool)
})
def test_deprecation_log():
with cirq.testing.assert_logs('TrialResult was used but is deprecated'):
cirq.TrialResult(params=cirq.ParamResolver({}), measurements={})
