def test_sweep_to_proto_points():
proto = v2.sweep_to_proto(cirq.Points('foo', [-1, 0, 1, 1.5]))
assert isinstance(proto, run_context_pb2.Sweep)
assert proto.HasField('single_sweep')
assert proto.single_sweep.parameter_key == 'foo'
assert proto.single_sweep.WhichOneof('sweep') == 'points'
assert list(proto.single_sweep.points.points) == [-1, 0, 1, 1.5]
def test_run_multiple_times(client):
setup_run_circuit_with_result_(client, _RESULTS)
engine = cg.Engine(project_id='proj',
proto_version=cg.engine.engine.ProtoVersion.V1)
program = engine.create_program(program=_CIRCUIT)
program.run(param_resolver=cirq.ParamResolver({'a': 1}))
run_context = v1.program_pb2.RunContext()
client().create_job.call_args[1]['run_context'].Unpack(run_context)
sweeps1 = run_context.parameter_sweeps
job2 = program.run_sweep(repetitions=2, params=cirq.Points('a', [3, 4]))
client().create_job.call_args[1]['run_context'].Unpack(run_context)
sweeps2 = run_context.parameter_sweeps
results = job2.results()
assert engine.context.proto_version == cg.engine.engine.ProtoVersion.V1
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')}
assert len(sweeps1) == 1
assert sweeps1[0].repetitions == 1
assert sweeps1[0].sweep.factors[0].sweeps[0].points.points == [1]
assert len(sweeps2) == 1
assert sweeps2[0].repetitions == 2
assert sweeps2[0].sweep.factors[0].sweeps[0].points.points == [3, 4]
assert client().get_job.call_count == 2
assert client().get_job_results.call_count == 2
def test_run_sweep_v2(client):
setup_run_circuit_with_result_(client, _RESULTS_V2)
engine = cg.Engine(
project_id='proj',
proto_version=cg.engine.engine.ProtoVersion.V2,
)
job = engine.run_sweep(program=_CIRCUIT,
job_id='job-id',
params=cirq.Points('a', [1, 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')}
client().create_program.assert_called_once()
client().create_job.assert_called_once()
run_context = v2.run_context_pb2.RunContext()
client().create_job.call_args[1]['run_context'].Unpack(run_context)
sweeps = run_context.parameter_sweeps
assert len(sweeps) == 1
assert sweeps[0].repetitions == 1
assert sweeps[0].sweep.single_sweep.points.points == [1, 2]
client().get_job.assert_called_once()
client().get_job_results.assert_called_once()
def test_gen_sweep_points():
points = [0.5, 1.0, 1.5, 2.0, 2.5]
sweep = params_pb2.SingleSweep(
parameter_key='foo', points=params_pb2.Points(points=list(points))
)
out = params._sweep_from_single_param_sweep_proto(sweep)
assert out == cirq.Points('foo', [0.5, 1.0, 1.5, 2.0, 2.5])
def test_custom_delay_sweep(experiment_type):
pulses = [1] if experiment_type == t2.ExperimentType.CPMG else None
results = t2.t2_decay(
sampler=cirq.DensityMatrixSimulator(noise=cirq.amplitude_damp(1)),
qubit=cirq.GridQubit(0, 0),
num_points=4,
repetitions=10,
min_delay=cirq.Duration(nanos=100),
max_delay=cirq.Duration(micros=1),
experiment_type=experiment_type,
num_pulses=pulses,
delay_sweep=cirq.Points('delay_ns',
[1.0, 10.0, 100.0, 1000.0, 10000.0]))
assert results == cirq.experiments.T2DecayResult(
x_basis_data=pd.DataFrame(columns=['delay_ns', 0, 1],
index=range(5),
data=[
[1.0, 10, 0],
[10.0, 10, 0],
[100.0, 10, 0],
[1000.0, 10, 0],
[10000.0, 10, 0],
]),
y_basis_data=pd.DataFrame(columns=['delay_ns', 0, 1],
index=range(5),
data=[
[1.0, 10, 0],
[10.0, 10, 0],
[100.0, 10, 0],
[1000.0, 10, 0],
[10000.0, 10, 0],
]),
)
def test_bad_result_proto(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'
}
}
result = _RESULTS_V2.copy()
result['@type'] = 'type.googleapis.com/unknown'
jobs.getResult().execute.return_value = {'result': result}
engine = cg.Engine(project_id='project-id',
proto_version=cg.engine.engine.ProtoVersion.V2)
job = engine.run_sweep(program=_SCHEDULE,
job_config=cg.JobConfig(
'project-id', gcs_prefix='gs://bucket/folder'),
params=cirq.Points('a', [1, 2]))
with pytest.raises(ValueError, match='invalid result proto version'):
job.results()
def sweep_from_proto(msg: run_context_pb2.Sweep) -> cirq.Sweep:
"""Creates a Sweep from a v2 protobuf message."""
which = msg.WhichOneof('sweep')
if which is None:
return cirq.UnitSweep
if which == 'sweep_function':
factors = [sweep_from_proto(m) for m in msg.sweep_function.sweeps]
func_type = msg.sweep_function.function_type
if func_type == run_context_pb2.SweepFunction.PRODUCT:
return cirq.Product(*factors)
if func_type == run_context_pb2.SweepFunction.ZIP:
return cirq.Zip(*factors)
raise ValueError(f'invalid sweep function type: {func_type}')
if which == 'single_sweep':
key = msg.single_sweep.parameter_key
if msg.single_sweep.WhichOneof('sweep') == 'linspace':
return cirq.Linspace(
key=key,
start=msg.single_sweep.linspace.first_point,
stop=msg.single_sweep.linspace.last_point,
length=msg.single_sweep.linspace.num_points,
)
if msg.single_sweep.WhichOneof('sweep') == 'points':
return cirq.Points(key=key, points=msg.single_sweep.points.points)
raise ValueError(f'single sweep type not set: {msg}')
# coverage: ignore
raise ValueError(f'sweep type not set: {msg}')
def test_run_sweep():
proc = SimulatedLocalProcessor(processor_id='test_proc')
q = cirq.GridQubit(5, 4)
circuit = cirq.Circuit(
cirq.X(q)**sympy.Symbol('t'), cirq.measure(q, key='m'))
sweep = cirq.Points(key='t', points=[1, 0])
job = proc.run_sweep(circuit,
params=sweep,
repetitions=100,
program_id='abc',
job_id='def')
assert proc.get_program('abc') == job.program()
assert proc.get_program('abc').get_job('def') == job
assert job.execution_status() == quantum.enums.ExecutionStatus.State.READY
assert len(job) == 2
assert np.all(job[0].measurements['m'] == 1)
assert np.all(job[1].measurements['m'] == 0)
# Test iteration
for idx, result in enumerate(job):
assert np.all(result.measurements['m'] == 1 - idx)
assert job.execution_status(
) == quantum.enums.ExecutionStatus.State.SUCCESS
# with default program_id and job_id
job = proc.run_sweep(circuit, params=sweep, repetitions=100)
assert job.execution_status() == quantum.enums.ExecutionStatus.State.READY
results = job.results()
assert np.all(results[0].measurements['m'] == 1)
assert np.all(results[1].measurements['m'] == 0)
assert job.execution_status(
) == quantum.enums.ExecutionStatus.State.SUCCESS
def test_run_sweep_v2(client_constructor):
client = setup_run_circuit_with_result_(client_constructor, _RESULTS_V2)
engine = cg.Engine(
project_id='project-id',
proto_version=cg.engine.engine.ProtoVersion.V2,
)
job = engine.run_sweep(program=_CIRCUIT,
job_config=cg.JobConfig('project-id'),
params=cirq.Points('a', [1, 2]))
results = job.results()
assert engine.proto_version == cg.engine.engine.ProtoVersion.V2
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')}
assert client.create_quantum_program.call_args[0][
0] == 'projects/project-id'
assert client.create_quantum_job.call_args[0][
0] == 'projects/project-id/programs/test'
run_context = v2.run_context_pb2.RunContext()
client.create_quantum_job.call_args[0][1].run_context.Unpack(run_context)
sweeps = run_context.parameter_sweeps
assert len(sweeps) == 1
assert sweeps[0].repetitions == 1
assert sweeps[0].sweep.single_sweep.points.points == [1, 2]
assert client.get_quantum_job.call_count == 1
assert client.get_quantum_result.call_count == 1
def test_run_batch(client):
client().create_program.return_value = (
'prog',
quantum.QuantumProgram(name='projects/proj/programs/prog'),
)
client().create_job.return_value = (
'job-id',
quantum.QuantumJob(name='projects/proj/programs/prog/jobs/job-id',
execution_status={'state': 'READY'}),
)
client().get_job.return_value = quantum.QuantumJob(
execution_status={'state': 'SUCCESS'},
update_time=_to_timestamp('2019-07-09T23:39:59Z'))
client().get_job_results.return_value = quantum.QuantumResult(
result=_BATCH_RESULTS_V2)
processor = cg.EngineProcessor('a', 'p', EngineContext())
job = processor.run_batch(
programs=[_CIRCUIT, _CIRCUIT],
job_id='job-id',
params_list=[cirq.Points('a', [1, 2]),
cirq.Points('a', [3, 4])],
)
results = job.results()
assert len(results) == 4
for i, v in enumerate([1, 2, 3, 4]):
assert results[i].repetitions == 1
assert results[i].params.param_dict == {'a': v}
assert results[i].measurements == {'q': np.array([[0]], dtype='uint8')}
for result in results:
assert result.job_id == job.id()
client().create_program.assert_called_once()
client().create_job.assert_called_once()
run_context = v2.batch_pb2.BatchRunContext()
client().create_job.call_args[1]['run_context'].Unpack(run_context)
assert len(run_context.run_contexts) == 2
for idx, rc in enumerate(run_context.run_contexts):
sweeps = rc.parameter_sweeps
assert len(sweeps) == 1
assert sweeps[0].repetitions == 1
if idx == 0:
assert sweeps[0].sweep.single_sweep.points.points == [1.0, 2.0]
if idx == 1:
assert sweeps[0].sweep.single_sweep.points.points == [3.0, 4.0]
client().get_job.assert_called_once()
client().get_job_results.assert_called_once()
def test_run_batch(simulation_type):
program = ParentProgram(
[
cirq.Circuit(
cirq.X(Q)**sympy.Symbol('t'), cirq.measure(Q, key='m')),
cirq.Circuit(
cirq.X(Q)**sympy.Symbol('x'), cirq.measure(Q, key='m2')),
],
None,
)
job = SimulatedLocalJob(
job_id='test_job',
processor_id='test1',
parent_program=program,
simulation_type=simulation_type,
repetitions=100,
sweeps=[
cirq.Points(key='t', points=[1, 0]),
cirq.Points(key='x', points=[0, 1])
],
)
if simulation_type == LocalSimulationType.ASYNCHRONOUS:
# Note: The simulation could have finished already
assert (job.execution_status() == quantum.ExecutionStatus.State.RUNNING
or job.execution_status()
== quantum.ExecutionStatus.State.SUCCESS)
else:
assert job.execution_status() == quantum.ExecutionStatus.State.READY
results = job.batched_results()
assert np.all(results[0][0].measurements['m'] == 1)
assert np.all(results[0][1].measurements['m'] == 0)
assert np.all(results[1][0].measurements['m2'] == 0)
assert np.all(results[1][1].measurements['m2'] == 1)
assert job.execution_status() == quantum.ExecutionStatus.State.SUCCESS
# Using flattened results
results = job.results()
assert np.all(results[0].measurements['m'] == 1)
assert np.all(results[1].measurements['m'] == 0)
assert np.all(results[2].measurements['m2'] == 0)
assert np.all(results[3].measurements['m2'] == 1)
for result in results:
assert result.job_id == 'test_job'
assert result.job_finished_time is not None
assert results == cirq.read_json(json_text=cirq.to_json(results))
def test_batch_size_validation_fails():
engine = cg.Engine(
project_id='proj',
proto_version=cg.engine.engine.ProtoVersion.V2,
)
with pytest.raises(ValueError, match='Number of circuits and sweeps'):
_ = engine.run_batch(programs=[_CIRCUIT, _CIRCUIT2],
gate_set=cg.XMON,
job_id='job-id',
params_list=[
cirq.Points('a', [1, 2]),
cirq.Points('a', [3, 4]),
cirq.Points('a', [5, 6])
],
processor_ids=['mysim'])
with pytest.raises(ValueError, match='Processor id must be specified'):
_ = engine.run_batch(
programs=[_CIRCUIT, _CIRCUIT2],
gate_set=cg.XMON,
job_id='job-id',
params_list=[cirq.Points('a', [1, 2]),
cirq.Points('a', [3, 4])])
with pytest.raises(ValueError, match='Gate set must be specified'):
_ = engine.run_batch(
programs=[_CIRCUIT, _CIRCUIT2],
job_id='job-id',
params_list=[cirq.Points('a', [1, 2]),
cirq.Points('a', [3, 4])],
processor_ids=['mysim'])
def test_run_in_batch_mode():
program = cg.EngineProgram('no-meow',
'no-meow',
EngineContext(),
result_type=ResultType.Batch)
with pytest.raises(ValueError, match='Please use run_batch'):
_ = program.run_sweep(repetitions=1,
processor_ids=['lazykitty'],
params=cirq.Points('cats', [1.0, 2.0, 3.0]))
def sweep_to_proto(
sweep: cirq.Sweep,
*,
out: Optional[run_context_pb2.Sweep] = None) -> run_context_pb2.Sweep:
"""Converts a Sweep to v2 protobuf message.
Args:
sweep: The sweep to convert.
out: Optional message to be populated. If not given, a new message will
be created.
Returns:
Populated sweep protobuf message.
Raises:
ValueError: If the conversion cannot be completed successfully.
"""
if out is None:
out = run_context_pb2.Sweep()
if sweep is cirq.UnitSweep:
pass
elif isinstance(sweep, cirq.Product):
out.sweep_function.function_type = run_context_pb2.SweepFunction.PRODUCT
for factor in sweep.factors:
sweep_to_proto(factor, out=out.sweep_function.sweeps.add())
elif isinstance(sweep, cirq.Zip):
out.sweep_function.function_type = run_context_pb2.SweepFunction.ZIP
for s in sweep.sweeps:
sweep_to_proto(s, out=out.sweep_function.sweeps.add())
elif isinstance(sweep,
cirq.Linspace) and not isinstance(sweep.key, sympy.Expr):
out.single_sweep.parameter_key = sweep.key
out.single_sweep.linspace.first_point = sweep.start
out.single_sweep.linspace.last_point = sweep.stop
out.single_sweep.linspace.num_points = sweep.length
elif isinstance(sweep,
cirq.Points) and not isinstance(sweep.key, sympy.Expr):
out.single_sweep.parameter_key = sweep.key
out.single_sweep.points.points.extend(sweep.points)
elif isinstance(sweep, cirq.ListSweep):
sweep_dict: Dict[str, List[float]] = {}
for param_resolver in sweep:
for key in param_resolver:
if isinstance(key, sympy.Expr):
raise ValueError(
f'cannot convert to v2 Sweep proto: {sweep}')
if key not in sweep_dict:
sweep_dict[key] = []
sweep_dict[key].append(
cast(float, param_resolver.value_of(key)))
out.sweep_function.function_type = run_context_pb2.SweepFunction.ZIP
for key in sweep_dict:
sweep_to_proto(cirq.Points(key, sweep_dict[key]),
out=out.sweep_function.sweeps.add())
else:
raise ValueError(f'cannot convert to v2 Sweep proto: {sweep}')
return out
def test_run_sweep_v2_new_proto(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'
}
}
results_new_proto = copy.deepcopy(_RESULTS_V2)
results_new_proto[
'@type'] = 'type.googleapis.com/cirq.google.api.v2.Result'
jobs.getResult().execute.return_value = {'result': results_new_proto}
engine = cg.Engine(
project_id='project-id',
proto_version=cg.engine.engine.ProtoVersion.V2,
)
job = engine.run_sweep(program=_SCHEDULE,
job_config=cg.JobConfig(
'project-id', gcs_prefix='gs://bucket/folder'),
params=cirq.Points('a', [1, 2]))
results = job.results()
assert engine.proto_version == cg.engine.engine.ProtoVersion.V2
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}'),
requestBuilder=mock.ANY)
assert programs.create.call_args[1]['parent'] == 'projects/project-id'
sweeps = jobs.create.call_args[1]['body']['run_context']['parameterSweeps']
assert len(sweeps) == 1
assert sweeps[0]['repetitions'] == 1
assert sweeps[0]['sweep']['singleSweep']['points']['points'] == [1, 2]
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_slice_access_error():
sweep = cirq.Points('a', [1, 2, 3])
with pytest.raises(TypeError, match='<class \'str\'>'):
_ = sweep['junk']
with pytest.raises(IndexError):
_ = sweep[4]
with pytest.raises(IndexError):
_ = sweep[-4]
def test_run_batch():
q = cirq.GridQubit(5, 4)
proc = SimulatedLocalProcessor(processor_id='test_proc')
circuits = [
cirq.Circuit(cirq.X(q)**sympy.Symbol('t'), cirq.measure(q, key='m')),
cirq.Circuit(cirq.X(q)**sympy.Symbol('x'), cirq.measure(q, key='m2')),
]
sweeps = [
cirq.Points(key='t', points=[1, 0]),
cirq.Points(key='x', points=[0, 1])
]
job = proc.run_batch(circuits, params_list=sweeps, repetitions=100)
assert job.execution_status() == quantum.ExecutionStatus.State.READY
results = job.batched_results()
assert np.all(results[0][0].measurements['m'] == 1)
assert np.all(results[0][1].measurements['m'] == 0)
assert np.all(results[1][0].measurements['m2'] == 0)
assert np.all(results[1][1].measurements['m2'] == 1)
assert job.execution_status() == quantum.ExecutionStatus.State.SUCCESS
def test_depolarizer_multiple_realizations():
q1 = cirq.NamedQubit('q1')
q2 = cirq.NamedQubit('q2')
cnot = Job(cirq.Circuit([
cirq.Moment([cirq.CNOT(q1, q2)]),
]))
all_errors3 = DepolarizerChannel(probability=1.0, realizations=3)
p0 = cirq.Symbol(DepolarizerChannel._parameter_name + '0')
p1 = cirq.Symbol(DepolarizerChannel._parameter_name + '1')
error_sweep = (cirq.Points(p0.name, [1.0, 1.0, 1.0]) +
cirq.Points(p1.name, [1.0, 1.0, 1.0]))
cnot_then_z3 = Job(
cirq.Circuit([
cirq.Moment([cirq.CNOT(q1, q2)]),
cirq.Moment([cirq.Z(q1)**p0, cirq.Z(q2)**p1])
]), cnot.sweep * error_sweep)
assert all_errors3.transform_job(cnot) == cnot_then_z3
def test_equality():
et = cirq.testing.EqualsTester()
et.add_equality_group(cirq.UnitSweep, cirq.UnitSweep)
# Simple sweeps with the same key are equal to themselves, but different
# from each other even if they happen to contain the same points.
et.make_equality_group(lambda: cirq.Linspace('a', 0, 10, 11))
et.make_equality_group(lambda: cirq.Linspace('b', 0, 10, 11))
et.make_equality_group(lambda: cirq.Points('a', list(range(11))))
et.make_equality_group(lambda: cirq.Points('b', list(range(11))))
# Product and Zip sweeps can also be equated.
et.make_equality_group(
lambda: cirq.Linspace('a', 0, 5, 6) * cirq.Linspace('b', 10, 15, 6))
et.make_equality_group(
lambda: cirq.Linspace('a', 0, 5, 6) + cirq.Linspace('b', 10, 15, 6))
et.make_equality_group(lambda: cirq.Points('a', [1, 2]) * (cirq.Linspace(
'b', 0, 5, 6) + cirq.Linspace('c', 10, 15, 6)))
def test_run_multiple_times(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}
engine = cg.Engine(project_id='project-id')
program = engine.create_program(program=_SCHEDULE)
program.run(param_resolver=cirq.ParamResolver({'a': 1}))
sweeps1 = jobs.create.call_args[1]['body']['run_context'][
'parameter_sweeps']
job2 = program.run_sweep(repetitions=2, params=cirq.Points('a', [3, 4]))
sweeps2 = jobs.create.call_args[1]['body']['run_context'][
'parameter_sweeps']
results = job2.results()
assert engine.proto_version == cg.engine.engine.ProtoVersion.V1
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}'),
requestBuilder=mock.ANY)
assert len(sweeps1) == 1
assert sweeps1[0]['repetitions'] == 1
assert sweeps1[0]['sweep']['factors'][0]['sweeps'][0]['points'][
'points'] == [1]
assert len(sweeps2) == 1
assert sweeps2[0]['repetitions'] == 2
assert sweeps2[0]['sweep']['factors'][0]['sweeps'][0]['points'][
'points'] == [3, 4]
assert jobs.get().execute.call_count == 2
assert jobs.getResult().execute.call_count == 2
def test_sampler_run_batch():
sampler = cirq.ZerosSampler()
a = cirq.LineQubit(0)
circuit1 = cirq.Circuit(cirq.X(a) ** sympy.Symbol('t'), cirq.measure(a, key='m'))
circuit2 = cirq.Circuit(cirq.Y(a) ** sympy.Symbol('t'), cirq.measure(a, key='m'))
params1 = cirq.Points('t', [0.3, 0.7])
params2 = cirq.Points('t', [0.4, 0.6])
results = sampler.run_batch(
[circuit1, circuit2], params_list=[params1, params2], repetitions=[1, 2]
)
assert len(results) == 2
for result, param in zip(results[0], [0.3, 0.7]):
assert result.repetitions == 1
assert result.params.param_dict == {'t': param}
assert result.measurements == {'m': np.array([[0]], dtype='uint8')}
for result, param in zip(results[1], [0.4, 0.6]):
assert result.repetitions == 2
assert result.params.param_dict == {'t': param}
assert len(result.measurements) == 1
assert np.array_equal(result.measurements['m'], np.array([[0], [0]], dtype='uint8'))
def _sweep_from_single_param_sweep_proto(
single_param_sweep: params_pb2.SingleSweep, ) -> cirq.Sweep:
key = single_param_sweep.parameter_key
if single_param_sweep.HasField('points'):
points = single_param_sweep.points
return cirq.Points(key, list(points.points))
if single_param_sweep.HasField('linspace'):
sl = single_param_sweep.linspace
return cirq.Linspace(key, sl.first_point, sl.last_point, sl.num_points)
raise ValueError('Single param sweep type undefined')
def test_depolarizer_parameterized_gates():
q1 = cirq.NamedQubit('q1')
q2 = cirq.NamedQubit('q2')
cnot_param = cirq.Symbol('cnot_turns')
cnot_gate = cirq.CZ(q1, q2)**cnot_param
job_sweep = cirq.Points('cnot_turns', [0.5])
cnot = Job(cirq.Circuit([cirq.Moment([cnot_gate])]), job_sweep)
all_errors = DepolarizerChannel(probability=1.0)
p0 = cirq.Symbol(DepolarizerChannel._parameter_name + '0')
p1 = cirq.Symbol(DepolarizerChannel._parameter_name + '1')
error_sweep = cirq.Points(p0.name, [1.0]) + cirq.Points(p1.name, [1.0])
cnot_then_z = Job(
cirq.Circuit([
cirq.Moment([cnot_gate]),
cirq.Moment([cirq.Z(q1)**p0, cirq.Z(q2)**p1])
]), job_sweep * error_sweep)
assert all_errors.transform_job(cnot) == cnot_then_z
def test_sampler():
engine = SimulatedLocalEngine(
[SimulatedLocalProcessor(processor_id='tester')])
q = cirq.GridQubit(5, 4)
circuit = cirq.Circuit(
cirq.X(q)**sympy.Symbol('t'), cirq.measure(q, key='m'))
sweep = cirq.Points(key='t', points=[1, 0])
results = engine.get_sampler('tester').run_sweep(circuit,
params=sweep,
repetitions=100)
assert np.all(results[0].measurements['m'] == 1)
assert np.all(results[1].measurements['m'] == 0)
def test_repr():
cirq.testing.assert_equivalent_repr(
cirq.study.sweeps.Product(cirq.UnitSweep),
setup_code='import cirq\nfrom collections import OrderedDict')
cirq.testing.assert_equivalent_repr(
cirq.study.sweeps.Zip(cirq.UnitSweep),
setup_code='import cirq\nfrom collections import OrderedDict')
cirq.testing.assert_equivalent_repr(
cirq.ListSweep(cirq.Linspace('a', start=0, stop=3, length=4)),
setup_code='import cirq\nfrom collections import OrderedDict')
cirq.testing.assert_equivalent_repr(cirq.Points('zero&pi', [0, 3.14159]))
cirq.testing.assert_equivalent_repr(cirq.Linspace('I/10', 0, 1, 10))
def test_bad_result_proto(client):
result = any_pb2.Any()
result.CopyFrom(_RESULTS_V2)
result.type_url = 'type.googleapis.com/unknown'
setup_run_circuit_with_result_(client, result)
engine = cg.Engine(project_id='project-id', proto_version=cg.engine.engine.ProtoVersion.V2)
job = engine.run_sweep(
program=_CIRCUIT, job_id='job-id', params=cirq.Points('a', [1, 2]), gate_set=cg.XMON
)
with pytest.raises(ValueError, match='invalid result proto version'):
job.results()
def test_run_sweep_v1(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}
engine = cg.Engine(project_id='project-id')
job = engine.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.Points('a', [1, 2]))
results = job.results()
assert engine.proto_version == cg.engine.engine.ProtoVersion.V1
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}'),
requestBuilder=mock.ANY)
assert programs.create.call_args[1]['parent'] == 'projects/project-id'
sweeps = jobs.create.call_args[1]['body']['run_context'][
'parameter_sweeps']
assert len(sweeps) == 1
assert sweeps[0]['repetitions'] == 1
assert sweeps[0]['sweep']['factors'][0]['sweeps'][0]['points'][
'points'] == [1, 2]
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_depolarizer_multiple_realizations():
q1 = cirq.QubitId()
q2 = cirq.QubitId()
cnot = Job(cirq.Circuit([
cirq.Moment([cirq.CNOT(q1, q2)]),
]))
all_errors3 = DepolarizerChannel(probability=1.0, realizations=3)
p0 = cirq.Symbol(DepolarizerChannel._parameter_name + '0')
p1 = cirq.Symbol(DepolarizerChannel._parameter_name + '1')
error_sweep = (cirq.Points(p0.name, [1.0, 1.0, 1.0]) +
cirq.Points(p1.name, [1.0, 1.0, 1.0]))
cnot_then_z3 = Job(
cirq.Circuit([
cirq.Moment([cirq.CNOT(q1, q2)]),
cirq.Moment([xmon_gates.ExpZGate(half_turns=p0).on(q1),
xmon_gates.ExpZGate(half_turns=p1).on(q2)])
]),
cnot.sweep * error_sweep)
assert all_errors3.transform_job(cnot) == cnot_then_z3
def test_sampler_sample_expectation_values_complex_param():
a = cirq.LineQubit(0)
t = sympy.Symbol('t')
sampler = cirq.Simulator(seed=1)
circuit = cirq.Circuit(cirq.global_phase_operation(t))
obs = cirq.Z(a)
results = sampler.sample_expectation_values(
circuit, [obs],
num_samples=5,
params=cirq.Points('t', [1, 1j, (1 + 1j) / np.sqrt(2)]))
assert np.allclose(results, [[1], [1], [1]])
def test_depolarizer_parameterized_gates():
q1 = cirq.QubitId()
q2 = cirq.QubitId()
cnot_param = cirq.Symbol('cnot_turns')
cnot_gate = xmon_gates.Exp11Gate(half_turns=cnot_param).on(q1, q2)
job_sweep = cirq.Points('cnot_turns', [0.5])
cnot = Job(cirq.Circuit([cirq.Moment([cnot_gate])]), job_sweep)
all_errors = DepolarizerChannel(probability=1.0)
p0 = cirq.Symbol(DepolarizerChannel._parameter_name + '0')
p1 = cirq.Symbol(DepolarizerChannel._parameter_name + '1')
error_sweep = cirq.Points(p0.name, [1.0]) + cirq.Points(p1.name, [1.0])
cnot_then_z = Job(
cirq.Circuit([
cirq.Moment([cnot_gate]),
cirq.Moment([xmon_gates.ExpZGate(half_turns=p0).on(q1),
xmon_gates.ExpZGate(half_turns=p1).on(q2)])
]),
job_sweep * error_sweep)
assert all_errors.transform_job(cnot) == cnot_then_z
