def test_intermediate_sweeps():
simulator = cirq.SimulatesIntermediateState()
final_state = np.array([1, 0, 0, 0])
def steps(*args, **kwargs):
result = mock.Mock()
result.measurements = {'a': np.array([True, True])}
result.simulator_state.return_value = final_state
yield result
simulator._simulator_iterator.side_effect = steps
circuit = mock.Mock(cirq.Circuit)
param_resolvers = [
mock.Mock(cirq.ParamResolver),
mock.Mock(cirq.ParamResolver)
]
qubit_order = mock.Mock(cirq.QubitOrder)
results = simulator.simulate_sweep(program=circuit,
params=param_resolvers,
qubit_order=qubit_order,
initial_state=2)
expected_results = [
cirq.SimulationTrialResult(measurements={'a': np.array([True, True])},
params=param_resolvers[0],
final_simulator_state=final_state),
cirq.SimulationTrialResult(measurements={'a': np.array([True, True])},
params=param_resolvers[1],
final_simulator_state=final_state)
]
assert results == expected_results
def test_intermediate_simulator():
simulator = cirq.SimulatesIntermediateState()
final_simulator_state = np.array([1, 0, 0, 0])
def steps(*args, **kwargs):
result = mock.Mock()
result.measurements = {'a': [True, True]}
yield result
result = mock.Mock()
result.measurements = {'b': [True, False]}
result.simulator_state.return_value = final_simulator_state
yield result
simulator._simulator_iterator.side_effect = steps
circuit = mock.Mock(cirq.Circuit)
param_resolver = mock.Mock(cirq.ParamResolver)
qubit_order = mock.Mock(cirq.QubitOrder)
result = simulator.simulate(program=circuit,
param_resolver=param_resolver,
qubit_order=qubit_order,
initial_state=2)
np.testing.assert_equal(result.measurements['a'], [True, True])
np.testing.assert_equal(result.measurements['b'], [True, False])
assert set(result.measurements.keys()) == {'a', 'b'}
assert result.params == param_resolver
np.testing.assert_equal(result.final_simulator_state,
final_simulator_state)
def steps(*args, **kwargs):
result = mock.Mock()
result.measurements = {'a': [True, True]}
yield result
result = mock.Mock()
result.measurements = {'b': [True, False]}
result.simulator_state.return_value = final_simulator_state
yield result
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_circuit_device_validation_passes_non_xmon_gate(build):
service = mock.Mock()
build.return_value = service
programs = service.projects().programs()
jobs = programs.jobs()
programs.create().execute.return_value = {
'name': 'projects/project-id/programs/test'
}
jobs.create().execute.return_value = {
'name': 'projects/project-id/programs/test/jobs/test',
'executionStatus': {
'state': 'READY'
}
}
jobs.get().execute.return_value = {
'name': 'projects/project-id/programs/test/jobs/test',
'executionStatus': {
'state': 'SUCCESS'
}
}
jobs.getResult().execute.return_value = {'result': _A_RESULT}
circuit = cirq.Circuit.from_ops(cirq.H.on(cirq.GridQubit(0, 1)),
device=cg.Foxtail)
result = cg.Engine(api_key="key").run(
program=circuit, job_config=cg.JobConfig('project-id'))
assert result.repetitions == 1
def test_run_circuit_failed(build):
service = mock.Mock()
build.return_value = service
programs = service.projects().programs()
jobs = programs.jobs()
programs.create().execute.return_value = {
'name': 'projects/project-id/programs/test'
}
jobs.create().execute.return_value = {
'name': 'projects/project-id/programs/test/jobs/test',
'executionStatus': {
'state': 'READY'
}
}
jobs.get().execute.return_value = {
'name': 'projects/project-id/programs/test/jobs/test',
'executionStatus': {
'state': 'FAILURE'
}
}
with pytest.raises(RuntimeError, match='It is in state FAILURE'):
cg.Engine(api_key="key").run(program=cirq.Circuit(),
job_config=cg.JobConfig(
'project-id',
gcs_prefix='gs://bucket/folder'))
def test_default_prefix(build):
service = mock.Mock()
build.return_value = service
programs = service.projects().programs()
jobs = programs.jobs()
programs.create().execute.return_value = {
'name': 'projects/project-id/programs/test'
}
jobs.create().execute.return_value = {
'name': 'projects/project-id/programs/test/jobs/test',
'executionStatus': {
'state': 'READY'
}
}
jobs.get().execute.return_value = {
'name': 'projects/project-id/programs/test/jobs/test',
'executionStatus': {
'state': 'SUCCESS'
}
}
jobs.getResult().execute.return_value = {'result': _A_RESULT}
result = cg.Engine(api_key="key").run(
program=cirq.Circuit(), job_config=cg.JobConfig('org.com:project-id'))
assert result.repetitions == 1
assert result.params.param_dict == {'a': 1}
assert result.measurements == {'q': np.array([[0]], dtype='uint8')}
build.assert_called_with(
'quantum',
'v1alpha1',
discoveryServiceUrl=('https://{api}.googleapis.com'
'/$discovery/rest?version='
'{apiVersion}&key=key'))
assert programs.create.call_args[1]['body']['gcs_code_location'][
'uri'].startswith('gs://gqe-project-id/programs/')
def test_cancel(build):
service = mock.Mock()
build.return_value = service
programs = service.projects().programs()
jobs = programs.jobs()
programs.create().execute.return_value = {
'name': 'projects/project-id/programs/test'
}
jobs.create().execute.return_value = {
'name': 'projects/project-id/programs/test/jobs/test',
'executionStatus': {
'state': 'READY'
}
}
jobs.get().execute.return_value = {
'name': 'projects/project-id/programs/test/jobs/test',
'executionStatus': {
'state': 'CANCELLED'
}
}
job = cg.Engine(api_key="key").run_sweep(
program=cirq.Circuit(),
job_config=cg.JobConfig('project-id', gcs_prefix='gs://bucket/folder'))
job.cancel()
assert job.job_resource_name == ('projects/project-id/programs/test/'
'jobs/test')
assert job.status() == 'CANCELLED'
assert jobs.cancel.call_args[1][
'name'] == 'projects/project-id/programs/test/jobs/test'
def test_anneal_minimize_calls_trace_func():
trace_func = mock.Mock()
anneal.anneal_minimize(
'initial', lambda s: 1.0 if s == 'initial' else 0.0,
lambda s: 'better', lambda: 1.0, 1.0, 0.5, 0.5, 1,
trace_func=trace_func)
trace_func.assert_has_calls([mock.call('initial', 1.0, 1.0, 1.0, True),
mock.call('better', 1.0, 0.0, 1.0, True)])
def test_run_sweep_params(build):
service = mock.Mock()
build.return_value = service
programs = service.projects().programs()
jobs = programs.jobs()
programs.create().execute.return_value = {
'name': 'projects/project-id/programs/test'
}
jobs.create().execute.return_value = {
'name': 'projects/project-id/programs/test/jobs/test',
'executionStatus': {
'state': 'READY'
}
}
jobs.get().execute.return_value = {
'name': 'projects/project-id/programs/test/jobs/test',
'executionStatus': {
'state': 'SUCCESS'
}
}
jobs.getResult().execute.return_value = {'result': _RESULTS}
job = cg.Engine(api_key="key").run_sweep(
program=cirq.moment_by_moment_schedule(cirq.UnconstrainedDevice,
cirq.Circuit()),
job_config=cg.JobConfig('project-id', gcs_prefix='gs://bucket/folder'),
params=[cirq.ParamResolver({'a': 1}),
cirq.ParamResolver({'a': 2})])
results = job.results()
assert len(results) == 2
for i, v in enumerate([1, 2]):
assert results[i].repetitions == 1
assert results[i].params.param_dict == {'a': v}
assert results[i].measurements == {'q': np.array([[0]], dtype='uint8')}
build.assert_called_with(
'quantum',
'v1alpha1',
discoveryServiceUrl=('https://{api}.googleapis.com'
'/$discovery/rest?version='
'{apiVersion}&key=key'))
assert programs.create.call_args[1]['parent'] == 'projects/project-id'
sweeps = programs.create.call_args[1]['body']['code']['parameter_sweeps']
assert len(sweeps) == 2
for i, v in enumerate([1, 2]):
assert sweeps[i]['repetitions'] == 1
assert sweeps[i]['sweep']['factors'][0]['sweeps'][0]['points'][
'points'] == [v]
assert jobs.create.call_args[1][
'parent'] == 'projects/project-id/programs/test'
assert jobs.get().execute.call_count == 1
assert jobs.getResult().execute.call_count == 1
def test_search_converts_trace_func(anneal_minimize):
q00 = GridQubit(0, 0)
q01 = GridQubit(0, 1)
seqs = [[q00, q01]]
edges = {(q00, q01)}
anneal_minimize.return_value = seqs, edges
trace_func = mock.Mock()
assert AnnealSequenceSearch(_create_device(
[]), seed=0xF00D0002).search(trace_func=trace_func) == seqs
wrapper_func = anneal_minimize.call_args[1]['trace_func']
wrapper_func((seqs, edges), 1.0, 2.0, 3.0, True)
trace_func.assert_called_once_with(seqs, 1.0, 2.0, 3.0, True)
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 test_wave_simulator_no_steps():
simulator = cirq.SimulatesIntermediateWaveFunction()
initial_state = np.array([1, 0, 0, 0], dtype=np.complex64)
simulator._simulator_iterator.return_value = iter([])
circuit = cirq.testing.random_circuit(2, 20, 0.99)
param_resolver = mock.Mock(cirq.ParamResolver)
qubit_order = circuit.all_qubits()
result = simulator.simulate(circuit=circuit,
param_resolver=param_resolver,
qubit_order=list(qubit_order),
initial_state=initial_state)
assert len(result.measurements) == 0
assert result.params == param_resolver
np.testing.assert_equal(result.final_state, initial_state)
def test_run_circuit(build):
service = mock.Mock()
build.return_value = service
programs = service.projects().programs()
jobs = programs.jobs()
programs.create().execute.return_value = {
'name': 'projects/project-id/programs/test'
}
jobs.create().execute.return_value = {
'name': 'projects/project-id/programs/test/jobs/test',
'executionStatus': {
'state': 'READY'
}
}
jobs.get().execute.return_value = {
'name': 'projects/project-id/programs/test/jobs/test',
'executionStatus': {
'state': 'SUCCESS'
}
}
jobs.getResult().execute.return_value = {
'result': MessageToDict(_A_RESULT)
}
result = cg.Engine(api_key="key").run(program=cirq.Circuit(),
job_config=cg.JobConfig(
'project-id',
gcs_prefix='gs://bucket/folder'))
assert result.repetitions == 1
assert result.params.param_dict == {'a': 1}
assert result.measurements == {'q': np.array([[0]], dtype='uint8')}
build.assert_called_with(
'quantum',
'v1alpha1',
discoveryServiceUrl=('https://{api}.googleapis.com'
'/$discovery/rest?version='
'{apiVersion}&key=key'))
assert programs.create.call_args[1]['parent'] == 'projects/project-id'
assert jobs.create.call_args[1][
'parent'] == 'projects/project-id/programs/test'
assert jobs.get().execute.call_count == 1
assert jobs.getResult().execute.call_count == 1
def test_job_labels(build):
job_name = 'projects/my-proj/programs/my-prog/jobs/my-job'
service = mock.Mock()
build.return_value = service
jobs = service.projects().programs().jobs()
engine = cg.Engine(api_key="key")
def body():
return jobs.patch.call_args[1]['body']
jobs.get().execute.return_value = {'labels': {'a': '1', 'b': '1'}}
engine.add_job_labels(job_name, {'a': '2', 'c': '1'})
assert body()['labels'] == {'a': '2', 'b': '1', 'c': '1'}
assert body()['labelFingerprint'] == ''
jobs.get().execute.return_value = {
'labels': {
'a': '1',
'b': '1'
},
'labelFingerprint': 'abcdef'
}
engine.set_job_labels(job_name, {'s': '1', 'p': '1'})
assert body()['labels'] == {'s': '1', 'p': '1'}
assert body()['labelFingerprint'] == 'abcdef'
jobs.get().execute.return_value = {
'labels': {
'a': '1',
'b': '1'
},
'labelFingerprint': 'abcdef'
}
engine.remove_job_labels(job_name, ['a', 'c'])
assert body()['labels'] == {'b': '1'}
assert body()['labelFingerprint'] == 'abcdef'
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Tests for simulator.py"""
from typing import List, Dict
import numpy as np
import pytest
import cirq
from cirq.testing.mock import mock
@mock.patch.multiple(cirq.SimulatesSamples, _run=mock.Mock())
def test_run_simulator_run():
simulator = cirq.SimulatesSamples()
expected_measurements = {'a': [[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(circuit=circuit,
repetitions=10,
param_resolver=param_resolver)
simulator._run.assert_called_once_with(circuit=circuit,
repetitions=10,
param_resolver=param_resolver)
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Tests for simulator.py"""
import numpy as np
import pytest
import cirq
from cirq.testing.mock import mock
@mock.patch.multiple(cirq.SimulatesSamples,
__abstractmethods__=set(),
_run=mock.Mock())
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 steps(*args, **kwargs):
result = mock.Mock()
result.measurements = {'a': np.array([True, True])}
result.simulator_state.return_value = final_state
yield result
