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)