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)