def test_measure_init(num_qubits):
assert cirq.MeasurementGate(num_qubits).num_qubits() == num_qubits
assert cirq.MeasurementGate(num_qubits, key='a').key == 'a'
assert cirq.MeasurementGate(num_qubits,
key='a').mkey == cirq.MeasurementKey('a')
assert cirq.MeasurementGate(num_qubits,
key=cirq.MeasurementKey('a')).key == 'a'
assert cirq.MeasurementGate(
num_qubits,
key=cirq.MeasurementKey('a')) == cirq.MeasurementGate(num_qubits,
key='a')
assert cirq.MeasurementGate(num_qubits,
invert_mask=(True, )).invert_mask == (True, )
assert cirq.qid_shape(
cirq.MeasurementGate(num_qubits)) == (2, ) * num_qubits
assert cirq.qid_shape(cirq.MeasurementGate(3, qid_shape=(1, 2,
3))) == (1, 2, 3)
assert cirq.qid_shape(cirq.MeasurementGate(qid_shape=(1, 2, 3))) == (1, 2,
3)
with pytest.raises(ValueError, match='len.* >'):
cirq.MeasurementGate(5, invert_mask=(True, ) * 6)
with pytest.raises(ValueError, match='len.* !='):
cirq.MeasurementGate(5, qid_shape=(1, 2))
with pytest.raises(ValueError, match='Specify either'):
cirq.MeasurementGate()
def test_empty_init():
with pytest.raises(TypeError, match='required positional argument'):
_ = cirq.MeasurementKey()
with pytest.raises(ValueError, match='valid string'):
_ = cirq.MeasurementKey(None)
with pytest.raises(ValueError, match='valid string'):
_ = cirq.MeasurementKey(4.2)
# Initialization of empty string should be allowed
_ = cirq.MeasurementKey('')
def test_json_dict():
mkey = cirq.MeasurementKey('key')
assert mkey._json_dict_() == {
'cirq_type': 'MeasurementKey',
'name': 'key',
}
mkey = cirq.MeasurementKey('nested:key')
assert mkey._json_dict_() == {
'cirq_type': 'MeasurementKey',
'name': 'nested:key',
}
def test_repr():
mkey = cirq.MeasurementKey('key_string')
assert repr(mkey) == f'cirq.MeasurementKey(name=\'key_string\')'
qubits = (cirq.LineQubit(0), cirq.LineQubit(1))
qubit_key = cirq.MeasurementKey(qubits=qubits)
assert (
repr(qubit_key) ==
f'cirq.MeasurementKey(qubits=(\'cirq.LineQubit(0)\', \'cirq.LineQubit(1)\'))'
)
mkey = cirq.MeasurementKey.parse_serialized('nested:key')
assert repr(
mkey) == f'cirq.MeasurementKey(path=(\'nested\',), name=\'key\')'
def test_setters_deprecated():
gate = cirq.PauliMeasurementGate(cirq.DensePauliString("Z", coefficient=+1), key='m')
with cirq.testing.assert_deprecated('mutators', deadline='v0.15'):
gate.key = 'n'
assert gate.key == 'n'
assert gate.mkey == cirq.MeasurementKey('n')
with cirq.testing.assert_deprecated('mutators', deadline='v0.15'):
gate.key = cirq.MeasurementKey('o')
assert gate.key == 'o'
assert gate.mkey == cirq.MeasurementKey('o')
with cirq.testing.assert_deprecated('mutators', deadline='v0.15'):
gate.mkey = cirq.MeasurementKey('p')
assert gate.key == 'p'
assert gate.mkey == cirq.MeasurementKey('p')
def test_repeat_until_error():
q = cirq.LineQubit(0)
with pytest.raises(ValueError, match='Cannot use repetitions with repeat_until'):
cirq.CircuitOperation(
cirq.FrozenCircuit(),
use_repetition_ids=True,
repeat_until=cirq.KeyCondition(cirq.MeasurementKey('a')),
)
with pytest.raises(ValueError, match='Infinite loop'):
cirq.CircuitOperation(
cirq.FrozenCircuit(cirq.measure(q, key='m')),
use_repetition_ids=False,
repeat_until=cirq.KeyCondition(cirq.MeasurementKey('a')),
)
def test_eq_and_hash():
class SomeRandomClass:
def __init__(self, some_str):
self.some_str = some_str
def __str__(self):
return self.some_str # coverage: ignore
mkey = cirq.MeasurementKey('key')
assert mkey == 'key'
assert hash(mkey) == hash('key')
nested_key = cirq.MeasurementKey('nested:key')
assert nested_key == 'nested:key'
non_str_or_measurement_key = SomeRandomClass('key')
assert mkey != non_str_or_measurement_key
def test_repr():
mkey = cirq.MeasurementKey('key_string')
assert repr(mkey) == f"cirq.MeasurementKey(name='key_string')"
assert eval(repr(mkey)) == mkey
mkey = cirq.MeasurementKey.parse_serialized('nested:key')
assert repr(mkey) == f"cirq.MeasurementKey(path=('nested',), name='key')"
assert eval(repr(mkey)) == mkey
def test_scope_extern_wrapping_with_non_repeating_subcircuits():
def wrap(*ops):
return cirq.CircuitOperation(cirq.FrozenCircuit(*ops))
def wrap_frozen(*ops):
return cirq.FrozenCircuit(wrap(*ops))
q = cirq.LineQubit(0)
inner = wrap_frozen(wrap(cirq.measure(q, key='a')),
wrap(cirq.X(q).with_classical_controls('b')))
middle = wrap_frozen(
wrap(cirq.measure(q, key=cirq.MeasurementKey('b'))),
wrap(cirq.CircuitOperation(inner, repetitions=2)),
)
outer_subcircuit = cirq.CircuitOperation(middle, repetitions=2)
circuit = outer_subcircuit.mapped_circuit(deep=True)
internal_control_keys = [
str(condition) for op in circuit.all_operations()
for condition in cirq.control_keys(op)
]
assert internal_control_keys == ['0:b', '0:b', '1:b', '1:b']
assert not cirq.control_keys(outer_subcircuit)
assert not cirq.control_keys(circuit)
cirq.testing.assert_has_diagram(
circuit,
"""
0: ─────M───M('0:0:a')───X───M('0:1:a')───X───M───M('1:0:a')───X───M('1:1:a')───X───
║ ║ ║ ║ ║ ║
0:b: ═══@════════════════^════════════════^═══╬════════════════╬════════════════╬═══
║ ║ ║
1:b: ═════════════════════════════════════════@════════════════^════════════════^═══
""",
use_unicode_characters=True,
)
assert circuit == cirq.Circuit(cirq.decompose(outer_subcircuit))
def test_init(observable, key):
g = cirq.PauliMeasurementGate(observable, key)
assert g.num_qubits() == len(observable)
assert g.key == 'a'
assert g.mkey == cirq.MeasurementKey('a')
assert g._observable == cirq.DensePauliString(observable)
assert cirq.qid_shape(g) == (2,) * len(observable)
def test_measure_qubits():
a = cirq.NamedQubit('a')
b = cirq.NamedQubit('b')
# Empty application.
with pytest.raises(ValueError, match='empty set of qubits'):
_ = cirq.measure()
assert cirq.measure(a) == cirq.MeasurementGate(num_qubits=1, key='').on(a)
assert cirq.measure(a) != cirq.measure(a, key='a')
assert cirq.measure(a) != cirq.MeasurementGate(num_qubits=1, key='').on(b)
assert cirq.measure(a) != cirq.MeasurementGate(num_qubits=1, key='a').on(a)
assert cirq.measure(a) == cirq.MeasurementGate(
num_qubits=1, key=cirq.MeasurementKey(qubits=(a,))
).on(a)
assert cirq.measurement_key(cirq.measure(a)) == 'a'
assert cirq.measure(a, b) == cirq.MeasurementGate(num_qubits=2, key='').on(a, b)
assert cirq.measurement_key(cirq.measure(a, b)) == 'a,b'
assert cirq.measure(b, a) == cirq.MeasurementGate(num_qubits=2, key='').on(b, a)
assert cirq.measurement_key(cirq.measure(b, a)) == 'b,a'
assert cirq.measure(a, key='b') == cirq.MeasurementGate(num_qubits=1, key='b').on(a)
assert cirq.measure(a, key='b') != cirq.MeasurementGate(num_qubits=1, key='b').on(b)
assert cirq.measure(a, invert_mask=(True,)) == cirq.MeasurementGate(
num_qubits=1, invert_mask=(True,)
).on(a)
assert cirq.measure(*cirq.LineQid.for_qid_shape((1, 2, 3)), key='a') == cirq.MeasurementGate(
num_qubits=3, key='a', qid_shape=(1, 2, 3)
).on(*cirq.LineQid.for_qid_shape((1, 2, 3)))
with pytest.raises(ValueError, match='ndarray'):
_ = cirq.measure(np.ndarray([1, 0]))
with pytest.raises(ValueError, match='Qid'):
_ = cirq.measure("bork")
def test_nested_key():
with pytest.raises(ValueError, match=': is not allowed.*use `MeasurementKey.parse_serialized'):
_ = cirq.MeasurementKey('nested:key')
nested_key = cirq.MeasurementKey.parse_serialized('nested:key')
assert nested_key.name == 'key'
assert nested_key.path == ('nested',)
def test_condition_types():
q0 = cirq.LineQubit(0)
sympy_cond = sympy_parser.parse_expr('a >= 2')
op = cirq.X(q0).with_classical_controls(cirq.MeasurementKey('a'), 'b',
'a > b', sympy_cond)
assert set(map(str,
op.classical_controls)) == {'a', 'b', 'a > b', 'a >= 2'}
def test_sympy_scope_simulation():
q0, q1, q2, q3, q_ignored, q_result = cirq.LineQubit.range(6)
condition = sympy_parser.parse_expr('a & b | c & d')
# We set up condition (a & b | c & d) plus an ignored measurement key, and run through the
# combinations of possible values of those (by doing X(q_i)**bits[i] on each), then verify
# that the final measurement into m_result is True iff that condition was met.
for i in range(32):
bits = cirq.big_endian_int_to_bits(i, bit_count=5)
inner = cirq.Circuit(
cirq.X(q0)**bits[0],
cirq.measure(q0, key='a'),
cirq.X(q_result).with_classical_controls(condition),
cirq.measure(q_result, key='m_result'),
)
middle = cirq.Circuit(
cirq.X(q1)**bits[1],
cirq.measure(q1, key='b'),
cirq.X(q_ignored)**bits[4],
cirq.measure(q_ignored, key=cirq.MeasurementKey('c', ('0', ))),
cirq.CircuitOperation(inner.freeze(), repetition_ids=['0']),
)
circuit = cirq.Circuit(
cirq.X(q2)**bits[2],
cirq.measure(q2, key='c'),
cirq.X(q3)**bits[3],
cirq.measure(q3, key='d'),
cirq.CircuitOperation(middle.freeze(), repetition_ids=['0']),
)
result = cirq.CliffordSimulator().run(circuit)
assert result.measurements['0:0:m_result'][0][0] == (
bits[0] and bits[1] or bits[2] and bits[3] # bits[4] irrelevant
)
def test_control_key_enumerable_deprecated():
class Deprecated:
def _control_keys_(self):
return [cirq.MeasurementKey('key')]
with cirq.testing.assert_deprecated('frozenset', deadline='v0.16'):
assert cirq.control_keys(Deprecated()) == {cirq.MeasurementKey('key')}
def test_act_on_stabilizer_ch_form():
a, b = [cirq.LineQubit(3), cirq.LineQubit(1)]
m = cirq.measure(a,
b,
key='out',
invert_mask=(True, ),
confusion_map={(1, ): np.array([[0, 1], [1, 0]])})
# The below assertion does not fail since it ignores non-unitary operations
cirq.testing.assert_all_implemented_act_on_effects_match_unitary(m)
args = cirq.StabilizerChFormSimulationState(qubits=cirq.LineQubit.range(5),
prng=np.random.RandomState(),
initial_state=0)
cirq.act_on(m, args)
assert args.log_of_measurement_results == {'out': [1, 1]}
args = cirq.StabilizerChFormSimulationState(qubits=cirq.LineQubit.range(5),
prng=np.random.RandomState(),
initial_state=8)
cirq.act_on(m, args)
assert args.log_of_measurement_results == {'out': [1, 0]}
args = cirq.StabilizerChFormSimulationState(qubits=cirq.LineQubit.range(5),
prng=np.random.RandomState(),
initial_state=10)
cirq.act_on(m, args)
datastore = cast(cirq.ClassicalDataDictionaryStore, args.classical_data)
out = cirq.MeasurementKey('out')
assert args.log_of_measurement_results == {'out': [0, 0]}
assert datastore.records[out] == [(0, 0)]
cirq.act_on(m, args)
assert args.log_of_measurement_results == {'out': [0, 0]}
assert datastore.records[out] == [(0, 0), (0, 0)]
def test_nested_key():
with pytest.raises(
ValueError,
match=': is not allowed.*use `MeasurementKey.parse_serialized'):
_ = cirq.MeasurementKey('nested:key')
nested_key = cirq.MeasurementKey.parse_serialized('nested:key')
assert nested_key.name == 'key'
assert nested_key.path == ('nested', )
qubits = (cirq.LineQubit(0), cirq.LineQubit(1))
nested_qubit_key = cirq.MeasurementKey(qubits=qubits, path=('nested', ))
assert nested_qubit_key.name == ''
assert nested_qubit_key.path == ('nested', )
assert nested_qubit_key.qubits == qubits
def test_parameterized_repeat_side_effects_when_not_using_rep_ids():
q = cirq.LineQubit(0)
op = cirq.CircuitOperation(
cirq.FrozenCircuit(
cirq.X(q).with_classical_controls('c'), cirq.measure(q, key='m')),
repetitions=sympy.Symbol('a'),
use_repetition_ids=False,
)
assert cirq.control_keys(op) == {cirq.MeasurementKey('c')}
assert cirq.parameter_names(op.with_params({'a': 1})) == {'a'}
assert set(map(str, cirq.measurement_key_objs(op))) == {'m'}
assert cirq.measurement_key_names(op) == {'m'}
assert cirq.measurement_key_names(
cirq.with_measurement_key_mapping(op, {'m': 'm2'})) == {'m2'}
with pytest.raises(
ValueError,
match='Cannot unroll circuit due to nondeterministic repetitions'):
op.mapped_circuit()
with pytest.raises(
ValueError,
match='Cannot unroll circuit due to nondeterministic repetitions'):
cirq.decompose(op)
with pytest.raises(ValueError,
match='repetition ids with parameterized repetitions'):
op.with_repetition_ids(['x', 'y'])
with pytest.raises(ValueError,
match='repetition ids with parameterized repetitions'):
op.repeat(repetition_ids=['x', 'y'])
def test_setters_deprecated():
gate = cirq.MeasurementGate(1, key='m', invert_mask=(False, ))
with cirq.testing.assert_deprecated('mutators', deadline='v0.15'):
gate.key = 'n'
assert gate.key == 'n'
assert gate.mkey == cirq.MeasurementKey('n')
with cirq.testing.assert_deprecated('mutators', deadline='v0.15'):
gate.key = cirq.MeasurementKey('o')
assert gate.key == 'o'
assert gate.mkey == cirq.MeasurementKey('o')
with cirq.testing.assert_deprecated('mutators', deadline='v0.15'):
gate.mkey = cirq.MeasurementKey('p')
assert gate.key == 'p'
assert gate.mkey == cirq.MeasurementKey('p')
with cirq.testing.assert_deprecated('mutators', deadline='v0.15'):
gate.invert_mask = (True, )
assert gate.invert_mask == (True, )
def test_eval_repr():
# Basic safeguard against repr-inequality.
op = cirq.GateOperation(
gate=cirq.MeasurementGate(1, cirq.MeasurementKey(path=(),
name='q0_1_0'), ()),
qubits=[cirq.GridQubit(0, 1)],
)
cirq.testing.assert_equivalent_repr(op)
def test_measurement_eq():
eq = cirq.testing.EqualsTester()
eq.make_equality_group(
lambda: cirq.PauliMeasurementGate([cirq.X, cirq.Y], 'a'),
lambda: cirq.PauliMeasurementGate([cirq.X, cirq.Y], cirq.MeasurementKey('a')),
)
eq.add_equality_group(cirq.PauliMeasurementGate([cirq.X, cirq.Y], 'b'))
eq.add_equality_group(cirq.PauliMeasurementGate([cirq.Y, cirq.X], 'a'))
def test_simulation_state_initializer():
s = ccq.mps_simulator.MPSState(
qubits=(cirq.LineQubit(0), ),
prng=np.random.RandomState(0),
classical_data=cirq.ClassicalDataDictionaryStore(
_records={cirq.MeasurementKey('test'): [(4, )]}),
)
assert s.qubits == (cirq.LineQubit(0), )
assert s.log_of_measurement_results == {'test': [4]}
def test_measure_init(num_qubits):
assert cirq.MeasurementGate(num_qubits, 'a').num_qubits() == num_qubits
assert cirq.MeasurementGate(num_qubits, key='a').key == 'a'
assert cirq.MeasurementGate(num_qubits,
key='a').mkey == cirq.MeasurementKey('a')
assert cirq.MeasurementGate(num_qubits,
key=cirq.MeasurementKey('a')).key == 'a'
assert cirq.MeasurementGate(
num_qubits,
key=cirq.MeasurementKey('a')) == cirq.MeasurementGate(num_qubits,
key='a')
assert cirq.MeasurementGate(num_qubits, 'a',
invert_mask=(True, )).invert_mask == (True, )
assert cirq.qid_shape(cirq.MeasurementGate(num_qubits,
'a')) == (2, ) * num_qubits
cmap = {(0, ): np.array([[0, 1], [1, 0]])}
assert cirq.MeasurementGate(num_qubits, 'a',
confusion_map=cmap).confusion_map == cmap
def test_with_measurement_key_mapping():
mkey = cirq.MeasurementKey('key')
mkey2 = cirq.with_measurement_key_mapping(mkey, {'key': 'new_key'})
assert mkey2.name == 'new_key'
mkey3 = mkey2.with_key_path_prefix('a')
mkey3 = cirq.with_measurement_key_mapping(mkey3, {'new_key': 'newer_key'})
assert mkey3.name == 'newer_key'
assert mkey3.path == ('a', )
def test_measurement_key_obj(gate):
assert isinstance(cirq.measurement_key_obj(gate), cirq.MeasurementKey)
assert cirq.measurement_key_obj(gate) == cirq.MeasurementKey(
name='door locker')
assert cirq.measurement_key_obj(gate) == 'door locker'
assert cirq.measurement_key_obj(gate, None) == 'door locker'
assert cirq.measurement_key_obj(gate, NotImplemented) == 'door locker'
assert cirq.measurement_key_obj(gate, 'a') == 'door locker'
def test_repeated_measurement_unset(sim):
q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit(
cirq.measure(q0, key='a'),
cirq.X(q0),
cirq.measure(q0, key='a'),
cirq.X(q1).with_classical_controls(
cirq.KeyCondition(cirq.MeasurementKey('a'), index=-2)),
cirq.measure(q1, key='b'),
cirq.X(q1).with_classical_controls(
cirq.KeyCondition(cirq.MeasurementKey('a'), index=-1)),
cirq.measure(q1, key='c'),
)
result = sim.run(circuit)
assert result.records['a'][0][0][0] == 0
assert result.records['a'][0][1][0] == 1
assert result.records['b'][0][0][0] == 0
assert result.records['c'][0][0][0] == 1
def test_with_key_path():
mkey = cirq.MeasurementKey('key')
mkey2 = cirq.with_key_path(mkey, ('a', ))
assert mkey2.name == mkey.name
assert mkey2.path == ('a', )
assert mkey2 == mkey.with_key_path_prefix('a')
mkey3 = mkey2.with_key_path_prefix('b')
assert mkey3.name == mkey.name
assert mkey3.path == ('b', 'a')
def test_scope_extern_mismatch():
q = cirq.LineQubit(0)
inner = cirq.Circuit(
cirq.measure(q, key='a'),
cirq.X(q).with_classical_controls('b'),
)
middle = cirq.Circuit(
cirq.measure(q, key=cirq.MeasurementKey('b', ('0', ))),
cirq.CircuitOperation(inner.freeze(), repetitions=2),
)
outer_subcircuit = cirq.CircuitOperation(middle.freeze(), repetitions=2)
circuit = outer_subcircuit.mapped_circuit(deep=True)
internal_control_keys = [
str(condition) for op in circuit.all_operations()
for condition in cirq.control_keys(op)
]
assert internal_control_keys == ['b', 'b', 'b', 'b']
assert cirq.control_keys(outer_subcircuit) == {cirq.MeasurementKey('b')}
assert cirq.control_keys(circuit) == {cirq.MeasurementKey('b')}
cirq.testing.assert_has_diagram(
cirq.Circuit(outer_subcircuit),
"""
[ [ 0: ───M('a')───X─── ] ]
[ 0: ───M('0:b')───[ ║ ]──────────── ]
0: ───[ [ b: ════════════^═══ ](loops=2) ]────────────
[ ║ ]
[ b: ══════════════╩══════════════════════════════════ ](loops=2)
║
b: ═══╩═══════════════════════════════════════════════════════════════════
""",
use_unicode_characters=True,
)
cirq.testing.assert_has_diagram(
circuit,
"""
0: ───M('0:0:b')───M('0:0:a')───X───M('0:1:a')───X───M('1:0:b')───M('1:0:a')───X───M('1:1:a')───X───
║ ║ ║ ║
b: ═════════════════════════════^════════════════^═════════════════════════════^════════════════^═══
""",
use_unicode_characters=True,
)
assert circuit == cirq.Circuit(cirq.decompose(outer_subcircuit))
def test_measurement_keys():
a = cirq.NamedQubit('a')
b = cirq.NamedQubit('b')
m = cirq.Moment(cirq.X(a), cirq.X(b))
assert cirq.measurement_key_names(m) == set()
assert not cirq.is_measurement(m)
m2 = cirq.Moment(cirq.measure(a, b, key='foo'))
assert cirq.measurement_key_objs(m2) == {cirq.MeasurementKey('foo')}
assert cirq.measurement_key_names(m2) == {'foo'}
assert cirq.is_measurement(m2)
def test_control_key():
class Named:
def _control_keys_(self):
return frozenset([cirq.MeasurementKey('key')])
class NoImpl:
def _control_keys_(self):
return NotImplemented
assert cirq.control_keys(Named()) == {cirq.MeasurementKey('key')}
assert not cirq.control_keys(NoImpl())
assert not cirq.control_keys(5)
