def test_qasm_output_args_format():
a = cirq.NamedQubit('a')
b = cirq.NamedQubit('b')
m_a = cirq.measure(a, key='meas_a')
m_b = cirq.measure(b, key='meas_b')
args = cirq.QasmArgs(
precision=4,
version='2.0',
qubit_id_map={
a: 'aaa[0]',
b: 'bbb[0]'
},
meas_key_id_map={
'meas_a': 'm_a',
'meas_b': 'm_b'
},
)
assert args.format('_{0}_', a) == '_aaa[0]_'
assert args.format('_{0}_', b) == '_bbb[0]_'
assert args.format('_{0:meas}_', cirq.measurement_key(m_a)) == '_m_a_'
assert args.format('_{0:meas}_', cirq.measurement_key(m_b)) == '_m_b_'
assert args.format('_{0}_', 89.1234567) == '_89.1235_'
assert args.format('_{0}_', 1.23) == '_1.23_'
assert args.format('_{0:half_turns}_', 89.1234567) == '_pi*89.1235_'
assert args.format('_{0:half_turns}_', 1.23) == '_pi*1.23_'
assert args.format('_{0}_', 'other') == '_other_'
def test_measurement_key():
class ReturnsStr():
def _measurement_key_(self):
return 'door locker'
assert cirq.measurement_key(ReturnsStr()) == 'door locker'
assert cirq.measurement_key(ReturnsStr(), None) == 'door locker'
assert cirq.measurement_key(ReturnsStr(), NotImplemented) == 'door locker'
assert cirq.measurement_key(ReturnsStr(), 'a') == 'door locker'
def test_measurement_key_no_method():
class NoMethod():
pass
with pytest.raises(TypeError, match='no _measurement_key_'):
cirq.measurement_key(NoMethod())
assert cirq.measurement_key(NoMethod(), None) is None
assert cirq.measurement_key(NoMethod(), NotImplemented) is NotImplemented
assert cirq.measurement_key(NoMethod(), 'a') == 'a'
def test_measurement_key_not_implemented():
class ReturnsNotImplemented:
def _measurement_key_(self):
return NotImplemented
with pytest.raises(TypeError, match='NotImplemented'):
cirq.measurement_key(ReturnsNotImplemented())
assert cirq.measurement_key(ReturnsNotImplemented(), None) is None
assert cirq.measurement_key(ReturnsNotImplemented(),
NotImplemented) is NotImplemented
assert cirq.measurement_key(ReturnsNotImplemented(), 'a') == 'a'
def test_measurement_key():
class ReturnsStr:
def _measurement_key_name_(self):
return 'door locker'
class DeprecatedMagicMethod(cirq.SingleQubitGate):
def _measurement_key_(self):
return 'door locker'
assert cirq.is_measurement(ReturnsStr())
with cirq.testing.assert_deprecated(deadline="v0.13"):
assert cirq.measurement_key(ReturnsStr()) == 'door locker'
with cirq.testing.assert_deprecated(deadline="v0.13"):
assert cirq.measurement_key_name(
DeprecatedMagicMethod()) == 'door locker'
with cirq.testing.assert_deprecated(deadline="v0.13"):
assert (cirq.measurement_key_name(DeprecatedMagicMethod().on(
cirq.LineQubit(0))) == 'door locker')
assert cirq.measurement_key_name(ReturnsStr()) == 'door locker'
assert cirq.measurement_key_name(ReturnsStr(), None) == 'door locker'
assert cirq.measurement_key_name(ReturnsStr(),
NotImplemented) == 'door locker'
assert cirq.measurement_key_name(ReturnsStr(), 'a') == 'door locker'
def _write_quil(self, output_func: Callable[[str], None]) -> None:
"""Calls `output_func` for successive lines of QUIL output.
Args:
output_func: A function that accepts a string of QUIL. This will likely
write the QUIL to a file.
Returns:
None.
"""
if self._decompose_operation is None:
return super()._write_quil(output_func)
output_func("# Created using Cirq.\n\n")
if len(self.measurements) > 0:
measurements_declared: Set[str] = set()
for m in self.measurements:
key = cirq.measurement_key(m)
if key in measurements_declared:
continue
measurements_declared.add(key)
output_func(
f"DECLARE {self.measurement_id_map[key]} BIT[{len(m.qubits)}]\n"
)
output_func("\n")
for main_op in self.operations:
decomposed = self._decompose_operation(main_op)
for decomposed_op in decomposed:
output_func(cirq.quil(decomposed_op, formatter=self.formatter))
def test_matrix_mixture_remap_keys():
dp = cirq.depolarize(0.1)
mm = cirq.MixedUnitaryChannel.from_mixture(dp)
with pytest.raises(TypeError):
_ = cirq.measurement_key(mm)
assert cirq.with_measurement_key_mapping(mm, {'a': 'b'}) is NotImplemented
mm_x = cirq.MixedUnitaryChannel.from_mixture(dp, key='x')
assert cirq.with_measurement_key_mapping(mm_x, {'a': 'b'}) is mm_x
assert cirq.measurement_key(cirq.with_key_path(mm_x,
('path', ))) == 'path:x'
mm_a = cirq.MixedUnitaryChannel.from_mixture(dp, key='a')
mm_b = cirq.MixedUnitaryChannel.from_mixture(dp, key='b')
assert mm_a != mm_b
assert cirq.with_measurement_key_mapping(mm_a, {'a': 'b'}) == mm_b
def test_kraus_channel_remap_keys():
dp = cirq.depolarize(0.1)
kc = cirq.KrausChannel.from_channel(dp)
with pytest.raises(TypeError):
_ = cirq.measurement_key(kc)
assert cirq.with_measurement_key_mapping(kc, {'a': 'b'}) is NotImplemented
kc_x = cirq.KrausChannel.from_channel(dp, key='x')
assert cirq.with_measurement_key_mapping(kc_x, {'a': 'b'}) is kc_x
assert cirq.measurement_key(cirq.with_key_path(kc_x,
('path', ))) == 'path:x'
kc_a = cirq.KrausChannel.from_channel(dp, key='a')
kc_b = cirq.KrausChannel.from_channel(dp, key='b')
assert kc_a != kc_b
assert cirq.with_measurement_key_mapping(kc_a, {'a': 'b'}) == kc_b
def _verify_unique_measurement_keys(operations: Iterable[cirq.Operation]):
seen: Set[str] = set()
for op in operations:
if cirq.is_measurement(op):
key = cirq.measurement_key(op)
if key in seen:
raise ValueError(f'Measurement key {key} repeated')
seen.add(key)
def get_all_measurement_keys(circuit: cirq.Circuit) -> set:
all_measurement_keys = set()
for moment in circuit:
for op in moment:
if cirq.is_measurement(op):
all_measurement_keys.add(cirq.measurement_key(op))
return all_measurement_keys
def _simulate_measurement(self, op, state, indices, measurements):
meas = cirq.op_gate_of_type(op, cirq.MeasurementGate)
if meas:
invert_mask = meas.full_invert_mask()
bits = state.apply_measurement(indices)
corrected = [bit ^ (bit < 2 and mask)
for bit, mask in zip(bits, invert_mask)]
key = cirq.measurement_key(meas)
measurements[key].extend(corrected)
def _simulate_measurement(self, op, state, indices, measurements):
is_meas = isinstance(op.gate, cirq.MeasurementGate)
if is_meas:
invert_mask = op.gate.full_invert_mask()
bits = state.apply_measurement(indices)
corrected = [bit ^ (bit < 2 and mask)
for bit, mask in zip(bits, invert_mask)]
key = cirq.measurement_key(op.gate)
measurements[key].extend(corrected)
def test_measurement_without_key():
class MeasurementWithoutKey:
def _is_measurement_(self):
return True
with pytest.raises(TypeError, match='no measurement keys'):
_ = cirq.measurement_key(MeasurementWithoutKey())
assert cirq.is_measurement(MeasurementWithoutKey())
def _serialize_measurement_gate(self, gate: cirq.MeasurementGate,
targets: Sequence[int]) -> dict:
key = cirq.measurement_key(gate)
if chr(31) in key or chr(30) in key:
raise ValueError(
'Measurement gates for IonQ API cannot have a key with a ascii unit'
f'or record separator in it. Key was {key}')
return {
'gate': 'meas',
'key': key,
'targets': ','.join(str(t) for t in targets)
}
def test_measurement_key_no_method():
class NoMethod:
pass
with pytest.raises(TypeError, match='no measurement keys'):
cirq.measurement_key(NoMethod())
with pytest.raises(ValueError, match='multiple measurement keys'):
cirq.measurement_key(
cirq.Circuit(cirq.measure(cirq.LineQubit(0), key='a'),
cirq.measure(cirq.LineQubit(0), key='b')))
assert cirq.measurement_key(NoMethod(), None) is None
assert cirq.measurement_key(NoMethod(), NotImplemented) is NotImplemented
assert cirq.measurement_key(NoMethod(), 'a') == 'a'
assert cirq.measurement_key(cirq.X, None) is None
assert cirq.measurement_key(cirq.X(cirq.LineQubit(0)), None) is None
def test_matrix_mixture_from_mixture():
q0 = cirq.LineQubit(0)
dp = cirq.depolarize(0.1)
mm = cirq.MixedUnitaryChannel.from_mixture(dp, key='dp')
assert cirq.measurement_key(mm) == 'dp'
circuit = cirq.Circuit(mm.on(q0))
sim = cirq.Simulator(seed=0)
results = sim.simulate(circuit)
assert 'dp' in results.measurements
# The depolarizing channel is composed of four unitaries.
assert results.measurements['dp'] in range(4)
def test_kraus_channel_from_channel():
q0 = cirq.LineQubit(0)
dp = cirq.depolarize(0.1)
kc = cirq.KrausChannel.from_channel(dp, key='dp')
assert cirq.measurement_key(kc) == 'dp'
circuit = cirq.Circuit(kc.on(q0))
sim = cirq.Simulator(seed=0)
results = sim.simulate(circuit)
assert 'dp' in results.measurements
# The depolarizing channel has four Kraus operators.
assert results.measurements['dp'] in range(4)
def test_matrix_mixture_from_unitaries():
q0 = cirq.LineQubit(0)
mix = [
(0.5, np.array([[1, 0], [0, 1]])),
(0.5, np.array([[0, 1], [1, 0]])),
]
half_flip = cirq.MixedUnitaryChannel(mix, key='flip')
assert cirq.measurement_key(half_flip) == 'flip'
circuit = cirq.Circuit(half_flip.on(q0), cirq.measure(q0, key='m'))
sim = cirq.Simulator(seed=0)
results = sim.simulate(circuit)
assert 'flip' in results.measurements
assert results.measurements['flip'] == results.measurements['m']
def test_kraus_channel_from_kraus():
q0 = cirq.LineQubit(0)
# This is equivalent to an X-basis measurement.
ops = [
np.array([[1, 1], [1, 1]]) * 0.5,
np.array([[1, -1], [-1, 1]]) * 0.5,
]
x_meas = cirq.KrausChannel(ops, key='x_meas')
assert cirq.measurement_key(x_meas) == 'x_meas'
circuit = cirq.Circuit(cirq.H(q0), x_meas.on(q0))
sim = cirq.Simulator(seed=0)
results = sim.simulate(circuit)
assert 'x_meas' in results.measurements
assert results.measurements['x_meas'] == 0
def test_measurement_key():
a = cirq.NamedQubit('a')
assert cirq.measurement_key(cirq.measure(a, key='lock')) == 'lock'
def test_tagged_operation_forwards_protocols():
"""The results of all protocols applied to an operation with a tag should
be equivalent to the result without tags.
"""
q1 = cirq.GridQubit(1, 1)
q2 = cirq.GridQubit(1, 2)
h = cirq.H(q1)
tag = 'tag1'
tagged_h = cirq.H(q1).with_tags(tag)
np.testing.assert_equal(cirq.unitary(tagged_h), cirq.unitary(h))
assert cirq.has_unitary(tagged_h)
assert cirq.decompose(tagged_h) == cirq.decompose(h)
assert cirq.pauli_expansion(tagged_h) == cirq.pauli_expansion(h)
assert cirq.equal_up_to_global_phase(h, tagged_h)
assert np.isclose(cirq.channel(h), cirq.channel(tagged_h)).all()
assert cirq.measurement_key(cirq.measure(q1, key='blah').with_tags(tag)) == 'blah'
parameterized_op = cirq.XPowGate(exponent=sympy.Symbol('t'))(q1).with_tags(tag)
assert cirq.is_parameterized(parameterized_op)
resolver = cirq.study.ParamResolver({'t': 0.25})
assert cirq.resolve_parameters(parameterized_op, resolver) == cirq.XPowGate(exponent=0.25)(
q1
).with_tags(tag)
assert cirq.resolve_parameters_once(parameterized_op, resolver) == cirq.XPowGate(exponent=0.25)(
q1
).with_tags(tag)
y = cirq.Y(q1)
tagged_y = cirq.Y(q1).with_tags(tag)
assert tagged_y ** 0.5 == cirq.YPowGate(exponent=0.5)(q1)
assert tagged_y * 2 == (y * 2)
assert 3 * tagged_y == (3 * y)
assert cirq.phase_by(y, 0.125, 0) == cirq.phase_by(tagged_y, 0.125, 0)
controlled_y = tagged_y.controlled_by(q2)
assert controlled_y.qubits == (
q2,
q1,
)
assert isinstance(controlled_y, cirq.Operation)
assert not isinstance(controlled_y, cirq.TaggedOperation)
clifford_x = cirq.SingleQubitCliffordGate.X(q1)
tagged_x = cirq.SingleQubitCliffordGate.X(q1).with_tags(tag)
assert cirq.commutes(clifford_x, clifford_x)
assert cirq.commutes(tagged_x, clifford_x)
assert cirq.commutes(clifford_x, tagged_x)
assert cirq.commutes(tagged_x, tagged_x)
assert cirq.trace_distance_bound(y ** 0.001) == cirq.trace_distance_bound(
(y ** 0.001).with_tags(tag)
)
flip = cirq.bit_flip(0.5)(q1)
tagged_flip = cirq.bit_flip(0.5)(q1).with_tags(tag)
assert cirq.has_mixture(tagged_flip)
assert cirq.has_channel(tagged_flip)
flip_mixture = cirq.mixture(flip)
tagged_mixture = cirq.mixture(tagged_flip)
assert len(tagged_mixture) == 2
assert len(tagged_mixture[0]) == 2
assert len(tagged_mixture[1]) == 2
assert tagged_mixture[0][0] == flip_mixture[0][0]
assert np.isclose(tagged_mixture[0][1], flip_mixture[0][1]).all()
assert tagged_mixture[1][0] == flip_mixture[1][0]
assert np.isclose(tagged_mixture[1][1], flip_mixture[1][1]).all()
qubit_map = {q1: 'q1'}
qasm_args = cirq.QasmArgs(qubit_id_map=qubit_map)
assert cirq.qasm(h, args=qasm_args) == cirq.qasm(tagged_h, args=qasm_args)
cirq.testing.assert_has_consistent_apply_unitary(tagged_h)
