def test_repeated_keys():
q0, q1, q2 = cirq.LineQubit.range(3)
c = cirq.Circuit(
cirq.measure(q0, key='a'),
cirq.measure(q1, q2, key='b'),
cirq.measure(q0, key='a'),
cirq.measure(q1, q2, key='b'),
cirq.measure(q1, q2, key='b'),
)
result = cirq.ZerosSampler().run(c, repetitions=10)
assert result.records['a'].shape == (10, 2, 1)
assert result.records['b'].shape == (10, 3, 2)
c2 = cirq.Circuit(cirq.measure(q0, key='a'), cirq.measure(q1, q2, key='a'))
with pytest.raises(ValueError, match="Different qid shapes for repeated measurement"):
cirq.ZerosSampler().run(c2, repetitions=10)
def test_estimate_parallel_readout_errors_zero_batch():
qubits = cirq.LineQubit.range(10)
with pytest.raises(ValueError, match='non-zero trials_per_batch'):
_ = cirq.estimate_parallel_single_qubit_readout_errors(
cirq.ZerosSampler(),
qubits=qubits,
repetitions=1000,
trials=10,
trials_per_batch=0)
def test_estimate_parallel_readout_errors_bad_bit_string():
qubits = cirq.LineQubit.range(4)
with pytest.raises(ValueError, match='but was None'):
_ = cirq.estimate_parallel_single_qubit_readout_errors(
cirq.ZerosSampler(),
qubits=qubits,
repetitions=1000,
trials=35,
trials_per_batch=10,
bit_strings=[[1] * 4],
)
with pytest.raises(ValueError, match='0 or 1'):
_ = cirq.estimate_parallel_single_qubit_readout_errors(
cirq.ZerosSampler(),
qubits=qubits,
repetitions=1000,
trials=2,
bit_strings=np.array([[12, 47, 2, -4], [0.1, 7, 0, 0]]),
)
def test_estimate_parallel_readout_errors_all_zeros():
qubits = cirq.LineQubit.range(10)
sampler = cirq.ZerosSampler()
repetitions = 1000
result = cirq.estimate_parallel_single_qubit_readout_errors(
sampler, qubits=qubits, repetitions=repetitions)
assert result.zero_state_errors == {q: 0 for q in qubits}
assert result.one_state_errors == {q: 1 for q in qubits}
assert result.repetitions == repetitions
assert isinstance(result.timestamp, float)
def test_estimate_parallel_readout_errors_batching():
qubits = cirq.LineQubit.range(5)
sampler = cirq.ZerosSampler()
repetitions = 1000
result = cirq.estimate_parallel_single_qubit_readout_errors(
sampler, qubits=qubits, repetitions=repetitions, trials=35, trials_per_batch=10
)
assert result.zero_state_errors == {q: 0.0 for q in qubits}
assert result.one_state_errors == {q: 1.0 for q in qubits}
assert result.repetitions == repetitions
assert isinstance(result.timestamp, float)
def test_run_calibration(monkeypatch):
monkeypatch.setattr('cirq.experiments.xeb_fitting.scipy.optimize.minimize', _minimize_patch)
monkeypatch.setattr(
'cirq_google.calibration.xeb_wrapper.xebf.benchmark_2q_xeb_fidelities', _benchmark_patch
)
qubit_indices = [
(0, 5),
(0, 6),
(1, 6),
(2, 6),
]
qubits = [cirq.GridQubit(*idx) for idx in qubit_indices]
sampler = cirq.ZerosSampler()
circuits = [
random_rotations_between_grid_interaction_layers_circuit(
qubits,
depth=depth,
two_qubit_op_factory=lambda a, b, _: SQRT_ISWAP.on(a, b),
pattern=cirq.experiments.GRID_ALIGNED_PATTERN,
seed=10,
)
for depth in [5, 10]
]
options = LocalXEBPhasedFSimCalibrationOptions(
fsim_options=XEBPhasedFSimCharacterizationOptions(
characterize_zeta=True,
characterize_gamma=True,
characterize_chi=True,
characterize_theta=False,
characterize_phi=False,
theta_default=np.pi / 4,
),
n_processes=1,
)
characterization_requests = []
for circuit in circuits:
_, characterization_requests = cg.prepare_characterization_for_moments(
circuit, options=options, initial=characterization_requests
)
assert len(characterization_requests) == 2
for cr in characterization_requests:
assert isinstance(cr, LocalXEBPhasedFSimCalibrationRequest)
characterizations = [
run_local_xeb_calibration(request, sampler) for request in characterization_requests
]
final_params = dict()
for c in characterizations:
final_params.update(c.parameters)
assert len(final_params) == 3 # pairs
def test_validate_device():
device = OnlyMeasurementsDevice()
sampler = cirq.ZerosSampler(device)
a, b, c = [cirq.NamedQubit(s) for s in ['a', 'b', 'c']]
circuit = cirq.Circuit(cirq.measure(a), cirq.measure(b, c))
_ = sampler.run_sweep(circuit, None, 3)
circuit = cirq.Circuit(cirq.measure(a), cirq.X(b))
with pytest.raises(ValueError, match=r'X\(b\) is not a measurement'):
_ = sampler.run_sweep(circuit, None, 3)
def test_sample_with_gate_set():
gate_set = SerializableGateSet('test', SINGLE_QUBIT_SERIALIZERS,
SINGLE_QUBIT_DESERIALIZERS)
sampler = cirq.ZerosSampler(gate_set=gate_set)
a, b = cirq.LineQubit.range(2)
circuit1 = cirq.Circuit([cirq.X(a)])
circuit2 = cirq.Circuit([cirq.CX(a, b)])
sampler.sample(circuit1)
with pytest.raises(AssertionError, match='Unsupported operation'):
sampler.sample(circuit2)
def test_sampler_run_batch_default_params_and_repetitions():
sampler = cirq.ZerosSampler()
a = cirq.LineQubit(0)
circuit1 = cirq.Circuit(cirq.X(a), cirq.measure(a, key='m'))
circuit2 = cirq.Circuit(cirq.Y(a), cirq.measure(a, key='m'))
results = sampler.run_batch([circuit1, circuit2])
assert len(results) == 2
for result_list in results:
assert len(result_list) == 1
result = result_list[0]
assert result.repetitions == 1
assert result.params.param_dict == {}
assert result.measurements == {'m': np.array([[0]], dtype='uint8')}
def test_sampler_run_batch_bad_input_lengths():
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])
with pytest.raises(ValueError, match='2 and 1'):
_ = sampler.run_batch([circuit1, circuit2], params_list=[params1])
with pytest.raises(ValueError, match='2 and 3'):
_ = sampler.run_batch(
[circuit1, circuit2], params_list=[params1, params2], repetitions=[1, 2, 3]
)
def test_run_sweep():
a, b, c = [cirq.NamedQubit(s) for s in ['a', 'b', 'c']]
circuit = cirq.Circuit([cirq.measure(a)], [cirq.measure(b, c)])
sampler = cirq.ZerosSampler()
result = sampler.run_sweep(circuit, None, 3)
assert len(result) == 1
assert result[0].measurements.keys() == {'a', 'b,c'}
assert result[0].measurements['a'].shape == (3, 1)
assert np.all(result[0].measurements['a'] == 0)
assert result[0].measurements['b,c'].shape == (3, 2)
assert np.all(result[0].measurements['b,c'] == 0)
def get_sampler(self, ) -> 'cirq.Sampler':
"""Return a local `cirq.Sampler` based on the `noise_strength` attribute.
If `self.noise_strength` is `0` return a noiseless state-vector simulator.
If it's set to `float('inf')` the simulator will be `cirq.ZerosSampler`.
Otherwise, we return a density matrix simulator with a depolarizing model with
`noise_strength` probability of noise.
"""
if self.noise_strength == 0:
return cirq.Simulator()
if self.noise_strength == float('inf'):
return cirq.ZerosSampler()
return cirq.DensityMatrixSimulator(noise=cirq.ConstantQubitNoiseModel(
cirq.depolarize(p=self.noise_strength)))
def test_estimate_parallel_readout_errors_missing_qubits():
qubits = cirq.LineQubit.range(4)
result = cirq.estimate_parallel_single_qubit_readout_errors(
cirq.ZerosSampler(),
qubits=qubits,
repetitions=2000,
trials=1,
bit_strings=np.array([[0] * 4]),
)
assert result.zero_state_errors == {q: 0 for q in qubits}
# Trial did not include a one-state
assert all(np.isnan(result.one_state_errors[q]) for q in qubits)
assert result.repetitions == 2000
assert isinstance(result.timestamp, float)
def test_sample():
# Create a circuit whose measurements are always zeros, and check that
# results of ZeroSampler on this circuit are identical to results of
# actual simulation.
qs = cirq.LineQubit.range(6)
c = cirq.Circuit([cirq.CNOT(qs[0], qs[1]), cirq.X(qs[2]), cirq.X(qs[2])])
c += cirq.Z(qs[3])**sympy.Symbol('p')
c += [cirq.measure(q) for q in qs[0:3]]
c += cirq.measure(qs[4], qs[5])
# Z to even power is an identity.
params = cirq.Points(sympy.Symbol('p'), [0, 2, 4, 6])
result1 = cirq.ZerosSampler().sample(c, repetitions=10, params=params)
result2 = cirq.Simulator().sample(c, repetitions=10, params=params)
assert np.all(result1 == result2)
def test_run_calibration(monkeypatch, fsim_options, x0_should_be):
def _minimize_patch_2(*args, **kwargs):
return _minimize_patch(*args, **kwargs, x0_should_be=x0_should_be)
monkeypatch.setattr('scipy.optimize.minimize', _minimize_patch_2)
monkeypatch.setattr(
'cirq_google.calibration.xeb_wrapper.xebf.benchmark_2q_xeb_fidelities',
_benchmark_patch)
qubit_indices = [(0, 5), (0, 6), (1, 6), (2, 6)]
qubits = [cirq.GridQubit(*idx) for idx in qubit_indices]
sampler = cirq.ZerosSampler()
circuits = [
random_rotations_between_grid_interaction_layers_circuit(
qubits,
depth=depth,
two_qubit_op_factory=lambda a, b, _:
(cirq.SQRT_ISWAP_INV.on(a, b)),
pattern=cirq.experiments.GRID_ALIGNED_PATTERN,
seed=10,
) for depth in [5, 10]
]
options = LocalXEBPhasedFSimCalibrationOptions(fsim_options=fsim_options,
n_processes=1)
characterization_requests = []
for circuit in circuits:
_, characterization_requests = cg.prepare_characterization_for_moments(
circuit, options=options, initial=characterization_requests)
assert len(characterization_requests) == 2
for cr in characterization_requests:
assert isinstance(cr, LocalXEBPhasedFSimCalibrationRequest)
characterizations = [
run_local_xeb_calibration(request, sampler)
for request in characterization_requests
]
final_params = dict()
for c in characterizations:
final_params.update(c.parameters)
assert len(final_params) == 3 # pairs
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 get_sampler(self) -> cirq.Sampler:
return cirq.ZerosSampler()
