def test_eq(): eq = cirq.testing.EqualsTester() eq.make_equality_group(lambda: cirq.PhasedXZGate( x_exponent=0.25, z_exponent=0.5, axis_phase_exponent=0.75)) # Sensitive to each parameter. eq.add_equality_group( cirq.PhasedXZGate(x_exponent=0, z_exponent=0.5, axis_phase_exponent=0.75)) eq.add_equality_group( cirq.PhasedXZGate(x_exponent=0.25, z_exponent=0, axis_phase_exponent=0.75)) eq.add_equality_group( cirq.PhasedXZGate(x_exponent=0.25, z_exponent=0.5, axis_phase_exponent=0)) # Different from other gates. eq.add_equality_group( cirq.PhasedXPowGate(exponent=0.25, phase_exponent=0.75)) eq.add_equality_group(cirq.X) eq.add_equality_group( cirq.PhasedXZGate(x_exponent=1, z_exponent=0, axis_phase_exponent=0))
def matrix_to_sycamore_operations( target_qubits: List[cirq.GridQubit], matrix: np.ndarray) -> Tuple[cirq.OP_TREE, List[cirq.GridQubit]]: """A method to convert a unitary matrix to a list of Sycamore operations. This method will return a list of `cirq.Operation`s using the qubits and (optionally) ancilla qubits to implement the unitary matrix `matrix` on the target qubits `qubits`. The operations are also supported by `cirq.google.gate_sets.SYC_GATESET`. Args: target_qubits: list of qubits the returned operations will act on. The qubit order defined by the list is assumed to be used by the operations to implement `matrix`. matrix: a matrix that is guaranteed to be unitary and of size (2**len(qs), 2**len(qs)). Returns: A tuple of operations and ancilla qubits allocated. Operations: In case the matrix is supported, a list of operations `ops` is returned. `ops` acts on `qs` qubits and for which `cirq.unitary(ops)` is equal to `matrix` up to certain tolerance. In case the matrix is not supported, it might return NotImplemented to reduce the noise in the judge output. Ancilla qubits: In case ancilla qubits are allocated a list of ancilla qubits. Otherwise an empty list. . """ return [ cirq.PhasedXZGate(x_exponent=0, z_exponent=0, axis_phase_exponent=0)(target_qubits[0]), cirq.PhasedXZGate(x_exponent=0, z_exponent=0, axis_phase_exponent=0)(target_qubits[0]) ], []
def test_protocols(): a = random.random() b = random.random() c = random.random() g = cirq.PhasedXZGate(x_exponent=a, z_exponent=b, axis_phase_exponent=c) cirq.testing.assert_implements_consistent_protocols(g) # Symbolic. t = sympy.Symbol('t') g = cirq.PhasedXZGate(x_exponent=t, z_exponent=b, axis_phase_exponent=c) cirq.testing.assert_implements_consistent_protocols(g) g = cirq.PhasedXZGate(x_exponent=a, z_exponent=t, axis_phase_exponent=c) cirq.testing.assert_implements_consistent_protocols(g) g = cirq.PhasedXZGate(x_exponent=a, z_exponent=b, axis_phase_exponent=t) cirq.testing.assert_implements_consistent_protocols(g)
def test_single_phased_xz_stays(): gate = cirq.PhasedXZGate(axis_phase_exponent=0.2, x_exponent=0.3, z_exponent=0.4) q = cirq.NamedQubit('q') assert_optimizes(before=cirq.Circuit(gate(q)), expected=cirq.Circuit(gate(q)))
def test_cirq_to_circuit_0_7() -> None: q0 = cq.LineQubit(0) q1 = cq.LineQubit(1) gate = cirq_to_circuit(cq.Circuit(cq.rx(0.5).on(q0)))[0] assert isinstance(gate, qf.XPow) assert gate.param("t") == 0.5 / pi gate = cirq_to_circuit(cq.Circuit(cq.ry(0.5).on(q0)))[0] assert isinstance(gate, qf.YPow) assert gate.param("t") == 0.5 / pi gate = cirq_to_circuit(cq.Circuit(cq.rz(0.5).on(q0)))[0] assert isinstance(gate, qf.ZPow) assert gate.param("t") == 0.5 / pi # gate = cirq_to_circuit(cq.Circuit(cq.IdentityGate(2).on(q0, q1)))[0] op = (cq.PhasedISwapPowGate()**0.5).on(q0, q1) circ = cirq_to_circuit(cq.Circuit(op)) assert qf.gates_close(circ.asgate(), qf.Givens(0.5 * pi / 2, 0, 1)) op = cq.PhasedXZGate(x_exponent=0.125, z_exponent=0.25, axis_phase_exponent=0.375).on(q0) circ = cirq_to_circuit(cq.Circuit(op)) assert len(circ) == 3
def test_serialize_deserialize_arbitrary_xyz(x_exponent, z_exponent, axis_phase_exponent): gate = cirq.PhasedXZGate(x_exponent=x_exponent, z_exponent=z_exponent, axis_phase_exponent=axis_phase_exponent) op = gate.on(cirq.GridQubit(1, 2)) expected = op_proto({ 'gate': { 'id': 'xyz' }, 'args': { 'x_exponent': { 'arg_value': { 'float_value': x_exponent } }, 'z_exponent': { 'arg_value': { 'float_value': z_exponent } }, 'axis_phase_exponent': { 'arg_value': { 'float_value': axis_phase_exponent } }, }, 'qubits': [{ 'id': '1_2' }], }) assert _single_qubit_gate_set().serialize_op(op) == expected deserialized_op = _single_qubit_gate_set().deserialize_op(expected) cirq.testing.assert_allclose_up_to_global_phase( cirq.unitary(deserialized_op), cirq.unitary(op), atol=1e-7)
def test_init_properties(): g = cirq.PhasedXZGate(x_exponent=0.125, z_exponent=0.25, axis_phase_exponent=0.375) assert g.x_exponent == 0.125 assert g.z_exponent == 0.25 assert g.axis_phase_exponent == 0.375
def test_noisy_moment_one_qubit(): q0, q1 = cirq.LineQubit.range(2) model = ThermalNoiseModel( qubits={q0, q1}, gate_durations_ns={cirq.PhasedXZGate: 25.0, cirq.CZPowGate: 25.0}, heat_rate_GHz={q0: 1e-5, q1: 2e-5}, cool_rate_GHz={q0: 1e-4, q1: 2e-4}, dephase_rate_GHz={q0: 3e-4, q1: 4e-4}, require_physical_tag=False, ) gate = cirq.PhasedXZGate(x_exponent=1, z_exponent=0.5, axis_phase_exponent=0.25) moment = cirq.Moment(gate.on(q0)) noisy_moment = model.noisy_moment(moment, system_qubits=[q0, q1]) assert noisy_moment[0] == moment # Noise applies to both qubits, even if only one is acted upon. assert len(noisy_moment[1]) == 2 noisy_choi = cirq.kraus_to_choi(cirq.kraus(noisy_moment[1].operations[0])) assert np.allclose( noisy_choi, [ [9.99750343e-01, 0, 0, 9.91164267e-01], [0, 2.49656565e-03, 0, 0], [0, 0, 2.49656565e-04, 0], [9.91164267e-01, 0, 0, 9.97503434e-01], ], )
def test_circuit_operation_inspection(): q0, q1 = cirq.LineQubit.range(2) gate = cirq.PhasedXZGate(axis_phase_exponent=0.2, x_exponent=0.3, z_exponent=0.4) cop = cirq.CircuitOperation(cirq.FrozenCircuit(gate(q0))) assert cgoc.ConvertToSycamoreGates()._is_native_sycamore_op(cop) cop2 = cirq.CircuitOperation(cirq.FrozenCircuit(cirq.SWAP(q0, q1))) assert not cgoc.ConvertToSycamoreGates()._is_native_sycamore_op(cop2)
def test_parameterized(): a = random.random() b = random.random() c = random.random() g = cirq.PhasedXZGate(x_exponent=a, z_exponent=b, axis_phase_exponent=c) assert not cirq.is_parameterized(g) t = sympy.Symbol('t') gt = cirq.PhasedXZGate(x_exponent=t, z_exponent=b, axis_phase_exponent=c) assert cirq.is_parameterized(gt) assert cirq.resolve_parameters(gt, {'t': a}) == g gt = cirq.PhasedXZGate(x_exponent=a, z_exponent=t, axis_phase_exponent=c) assert cirq.is_parameterized(gt) assert cirq.resolve_parameters(gt, {'t': b}) == g gt = cirq.PhasedXZGate(x_exponent=a, z_exponent=b, axis_phase_exponent=t) assert cirq.is_parameterized(gt) assert cirq.resolve_parameters(gt, {'t': c}) == g
def test_parameterized(resolve_fn): a = random.random() b = random.random() c = random.random() g = cirq.PhasedXZGate(x_exponent=a, z_exponent=b, axis_phase_exponent=c) assert not cirq.is_parameterized(g) t = sympy.Symbol('t') gt = cirq.PhasedXZGate(x_exponent=t, z_exponent=b, axis_phase_exponent=c) assert cirq.is_parameterized(gt) assert resolve_fn(gt, {'t': a}) == g gt = cirq.PhasedXZGate(x_exponent=a, z_exponent=t, axis_phase_exponent=c) assert cirq.is_parameterized(gt) assert resolve_fn(gt, {'t': b}) == g gt = cirq.PhasedXZGate(x_exponent=a, z_exponent=b, axis_phase_exponent=t) assert cirq.is_parameterized(gt) assert resolve_fn(gt, {'t': c}) == g resolver = {'t': 0.5j} with pytest.raises(ValueError, match='Complex exponent'): resolve_fn( cirq.PhasedXZGate(x_exponent=t, z_exponent=b, axis_phase_exponent=c), resolver) with pytest.raises(ValueError, match='Complex exponent'): resolve_fn( cirq.PhasedXZGate(x_exponent=a, z_exponent=t, axis_phase_exponent=c), resolver) with pytest.raises(ValueError, match='Complex exponent'): resolve_fn( cirq.PhasedXZGate(x_exponent=a, z_exponent=b, axis_phase_exponent=t), resolver)
def test_gate_approx_eq_error(self): """Confirms that bad inputs cause an error to be raised.""" # junk with self.assertRaisesRegex(TypeError, expected_regex="`gate_true` not a cirq"): _ = util.gate_approx_eq("junk", cirq.I) with self.assertRaisesRegex(TypeError, expected_regex="`gate_deser` not a cirq"): _ = util.gate_approx_eq(cirq.I, "junk") # Unsupported gates with self.assertRaisesRegex( ValueError, expected_regex="`gate_true` not a valid TFQ gate"): _ = util.gate_approx_eq( cirq.PhasedXZGate(x_exponent=1, z_exponent=1, axis_phase_exponent=1), cirq.I) with self.assertRaisesRegex( ValueError, expected_regex="`gate_deser` not a valid TFQ gate"): _ = util.gate_approx_eq( cirq.I, cirq.PhasedXZGate(x_exponent=1, z_exponent=1, axis_phase_exponent=1)) # Unsupported gates inside a controlled gate with self.assertRaisesRegex( ValueError, expected_regex="`gate_true` not a valid TFQ gate"): _ = util.gate_approx_eq( cirq.ops.ControlledGate( cirq.PhasedXZGate(x_exponent=1, z_exponent=1, axis_phase_exponent=1), 2, [1, 0], [2, 2]), cirq.ops.ControlledGate(cirq.X, 2, [1, 0], [2, 2])) with self.assertRaisesRegex( ValueError, expected_regex="`gate_deser` not a valid TFQ gate"): _ = util.gate_approx_eq( cirq.ops.ControlledGate(cirq.X, 2, [1, 0], [2, 2]), cirq.ops.ControlledGate( cirq.PhasedXZGate(x_exponent=1, z_exponent=1, axis_phase_exponent=1), 2, [1, 0], [2, 2]))
def test_single_qubit_gate_phased_xz(): q = cirq.LineQubit(0) gate = cirq.PhasedXZGate(axis_phase_exponent=0.2, x_exponent=0.3, z_exponent=0.4) circuit = cirq.Circuit(gate(q)) converted_circuit = circuit.copy() cgoc.ConvertToSycamoreGates().optimize_circuit(converted_circuit) ops = list(converted_circuit.all_operations()) assert len(ops) == 1 assert ops[0].gate == gate
def test_single_qubit_gate_phased_xz(): q = cirq.LineQubit(0) gate = cirq.PhasedXZGate(axis_phase_exponent=0.2, x_exponent=0.3, z_exponent=0.4) circuit = cirq.Circuit(gate(q)) converted_circuit = circuit.copy() with cirq.testing.assert_deprecated("Use cirq.optimize_for_target_gateset", deadline='v1.0'): cgoc.ConvertToSycamoreGates().optimize_circuit(converted_circuit) ops = list(converted_circuit.all_operations()) assert len(ops) == 1 assert ops[0].gate == gate
def test_single_qubit_gate_phased_xz(): q = cirq.LineQubit(0) gate = cirq.PhasedXZGate(axis_phase_exponent=0.2, x_exponent=0.3, z_exponent=0.4) circuit = cirq.Circuit(gate(q)) compiled_circuit = cirq.optimize_for_target_gateset( circuit, gateset=cirq_google.SycamoreTargetGateset() ) ops = list(compiled_circuit.all_operations()) assert len(ops) == 1 assert ops[0].gate == gate
def test_inverse(): a = random.random() b = random.random() c = random.random() q = cirq.LineQubit(0) g = cirq.PhasedXZGate(x_exponent=a, z_exponent=b, axis_phase_exponent=c).on(q) cirq.testing.assert_allclose_up_to_global_phase( cirq.unitary(g ** -1), np.transpose(np.conjugate(cirq.unitary(g))), atol=1e-8 )
def test_circuit_operation_inspection(): q0, q1 = cirq.LineQubit.range(2) gate = cirq.PhasedXZGate(axis_phase_exponent=0.2, x_exponent=0.3, z_exponent=0.4) cop = cirq.CircuitOperation(cirq.FrozenCircuit(gate(q0))) with cirq.testing.assert_deprecated("Use cirq.optimize_for_target_gateset", deadline='v1.0'): assert cgoc.ConvertToSycamoreGates()._is_native_sycamore_op(cop) cop2 = cirq.CircuitOperation(cirq.FrozenCircuit(cirq.SWAP(q0, q1))) with cirq.testing.assert_deprecated("Use cirq.optimize_for_target_gateset", deadline='v1.0'): assert not cgoc.ConvertToSycamoreGates()._is_native_sycamore_op(cop2)
def test_str_diagram(): g = cirq.PhasedXZGate(x_exponent=0.5, z_exponent=0.25, axis_phase_exponent=0.125) assert str(g) == "PhXZ(a=0.125,x=0.5,z=0.25)" cirq.testing.assert_has_diagram( cirq.Circuit(g.on(cirq.LineQubit(0))), """ 0: ───PhXZ(a=0.125,x=0.5,z=0.25)─── """, )
def test_two_qubit_compilation_merges_runs_of_single_qubit_gates(): q = cirq.LineQubit.range(2) c = cirq.Circuit(cirq.CNOT(*q), cirq.X(q[0]), cirq.Y(q[0]), cirq.CNOT(*q)) cirq.testing.assert_same_circuits( cirq.optimize_for_target_gateset(c, gateset=DummyCXTargetGateset()), cirq.Circuit( cirq.CNOT(*q), cirq.PhasedXZGate(axis_phase_exponent=-0.5, x_exponent=0, z_exponent=-1).on(q[0]), cirq.CNOT(*q), ), )
def test_eject_phased_xz(): a = cirq.NamedQubit('a') b = cirq.NamedQubit('b') c = cirq.Circuit( cirq.PhasedXZGate(x_exponent=1, z_exponent=0.5, axis_phase_exponent=0.5).on(a), cirq.CZ(a, b) ** 0.25, ) c_expected = cirq.Circuit( cirq.CZ(a, b) ** -0.25, cirq.PhasedXPowGate(phase_exponent=0.75).on(a), cirq.T(b) ) cirq.testing.assert_same_circuits( cirq.eject_z(cirq.eject_phased_paulis(cirq.eject_z(c))), c_expected ) cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(c, c_expected, 1e-8)
def test_serialize_deserialize_arbitrary_xyz( x_exponent, z_exponent, axis_phase_exponent, ): gateset = cg.serializable_gate_set.SerializableGateSet( gate_set_name='test_xyz', serializers=([cgc.PHASED_X_Z_SERIALIZER]), deserializers=([cgc.PHASED_X_Z_DESERIALIZER])) gate = cirq.PhasedXZGate( x_exponent=x_exponent, z_exponent=z_exponent, axis_phase_exponent=axis_phase_exponent, ) op = gate.on(cirq.GridQubit(1, 2)) expected = { 'gate': { 'id': 'xyz' }, 'args': { 'x_exponent': { 'arg_value': { 'float_value': x_exponent } }, 'z_exponent': { 'arg_value': { 'float_value': z_exponent } }, 'axis_phase_exponent': { 'arg_value': { 'float_value': axis_phase_exponent } } }, 'qubits': [{ 'id': '1_2' }] } assert gateset.serialize_op_dict(op) == expected deserialized_op = gateset.deserialize_op_dict(expected) cirq.testing.assert_allclose_up_to_global_phase( cirq.unitary(deserialized_op), cirq.unitary(op), atol=1e-7, )
def test_serialize_deserialize_arbitrary_xyz( x_exponent, z_exponent, axis_phase_exponent, ): gate = cirq.PhasedXZGate( x_exponent=x_exponent, z_exponent=z_exponent, axis_phase_exponent=axis_phase_exponent, ) op = gate.on(cirq.GridQubit(1, 2)) expected = { 'gate': { 'id': 'xyz' }, 'args': { 'x_exponent': { 'arg_value': { 'float_value': x_exponent } }, 'z_exponent': { 'arg_value': { 'float_value': z_exponent } }, 'axis_phase_exponent': { 'arg_value': { 'float_value': axis_phase_exponent } } }, 'qubits': [{ 'id': '1_2' }] } assert SINGLE_QUBIT_GATE_SET.serialize_op_dict(op) == expected deserialized_op = SINGLE_QUBIT_GATE_SET.deserialize_op_dict(expected) cirq.testing.assert_allclose_up_to_global_phase( cirq.unitary(deserialized_op), cirq.unitary(op), atol=1e-7, )
def test_removes_zs(): a = cirq.NamedQubit('a') b = cirq.NamedQubit('b') assert_removes_all_z_gates(cirq.Circuit(cirq.Z(a), cirq.measure(a))) assert_removes_all_z_gates(cirq.Circuit(cirq.Z(a), cirq.measure(a, b))) assert_removes_all_z_gates( cirq.Circuit(cirq.Z(a), cirq.Z(a), cirq.measure(a))) assert_removes_all_z_gates( cirq.Circuit(cirq.Z(a), cirq.measure(a, key='k'))) assert_removes_all_z_gates( cirq.Circuit(cirq.Z(a), cirq.X(a), cirq.measure(a))) assert_removes_all_z_gates( cirq.Circuit(cirq.Z(a), cirq.X(a), cirq.X(a), cirq.measure(a))) assert_removes_all_z_gates( cirq.Circuit(cirq.Z(a), cirq.Z(b), cirq.CZ(a, b), cirq.CZ(a, b), cirq.measure(a, b))) assert_removes_all_z_gates( cirq.Circuit( cirq.PhasedXZGate(axis_phase_exponent=0, x_exponent=0, z_exponent=1).on(a), cirq.measure(a), )) assert_removes_all_z_gates( cirq.Circuit( cirq.Z(a)**sympy.Symbol('a'), cirq.Z(b)**(sympy.Symbol('a') + 1), cirq.CZ(a, b), cirq.CZ(a, b), cirq.measure(a, b), ), eject_parameterized=True, )
def _sq_layer(qubits: List[cirq.Qid], parameterized: bool, symbol_start: int) -> (cirq.Moment, int): """Creates a layer of single-qubit gates. If parameteried is true, this will add symbols to the qubits in order to test parameter resolution. """ m = cirq.Moment() current_sym = symbol_start for q in qubits: if parameterized: symbol = f's_{current_sym}' current_sym += 1 m = m.with_operation(cirq.X(q)**sympy.Symbol(symbol)) else: m = m.with_operation( cirq.PhasedXZGate(x_exponent=random.random(), z_exponent=random.random(), axis_phase_exponent=random.random())(q)) return (m, current_sym)
def _deserialize_gate_op( self, operation_proto: v2.program_pb2.Operation, *, arg_function_language: str = '', constants: Optional[List[v2.program_pb2.Constant]] = None, deserialized_constants: Optional[List[Any]] = None, ) -> cirq.Operation: """Deserialize an Operation from a cirq_google.api.v2.Operation. Args: operation_proto: A dictionary representing a cirq.google.api.v2.Operation proto. arg_function_language: The `arg_function_language` field from `Program.Language`. constants: The list of Constant protos referenced by constant table indices in `proto`. deserialized_constants: The deserialized contents of `constants`. cirq_google.api.v2.Operation proto. Returns: The deserialized Operation. """ if deserialized_constants is not None: qubits = [ deserialized_constants[q] for q in operation_proto.qubit_constant_index ] else: qubits = [] for q in operation_proto.qubits: # Preserve previous functionality in case # constants table was not used qubits.append(v2.qubit_from_proto_id(q.id)) which_gate_type = operation_proto.WhichOneof('gate_value') if which_gate_type == 'xpowgate': op = cirq.XPowGate(exponent=arg_func_langs.float_arg_from_proto( operation_proto.xpowgate.exponent, arg_function_language=arg_function_language, required_arg_name=None, ))(*qubits) elif which_gate_type == 'ypowgate': op = cirq.YPowGate(exponent=arg_func_langs.float_arg_from_proto( operation_proto.ypowgate.exponent, arg_function_language=arg_function_language, required_arg_name=None, ))(*qubits) elif which_gate_type == 'zpowgate': op = cirq.ZPowGate(exponent=arg_func_langs.float_arg_from_proto( operation_proto.zpowgate.exponent, arg_function_language=arg_function_language, required_arg_name=None, ))(*qubits) if operation_proto.zpowgate.is_physical_z: op = op.with_tags(PhysicalZTag()) elif which_gate_type == 'phasedxpowgate': exponent = arg_func_langs.float_arg_from_proto( operation_proto.phasedxpowgate.exponent, arg_function_language=arg_function_language, required_arg_name=None, ) phase_exponent = arg_func_langs.float_arg_from_proto( operation_proto.phasedxpowgate.phase_exponent, arg_function_language=arg_function_language, required_arg_name=None, ) op = cirq.PhasedXPowGate(exponent=exponent, phase_exponent=phase_exponent)(*qubits) elif which_gate_type == 'phasedxzgate': x_exponent = arg_func_langs.float_arg_from_proto( operation_proto.phasedxzgate.x_exponent, arg_function_language=arg_function_language, required_arg_name=None, ) z_exponent = arg_func_langs.float_arg_from_proto( operation_proto.phasedxzgate.z_exponent, arg_function_language=arg_function_language, required_arg_name=None, ) axis_phase_exponent = arg_func_langs.float_arg_from_proto( operation_proto.phasedxzgate.axis_phase_exponent, arg_function_language=arg_function_language, required_arg_name=None, ) op = cirq.PhasedXZGate( x_exponent=x_exponent, z_exponent=z_exponent, axis_phase_exponent=axis_phase_exponent, )(*qubits) elif which_gate_type == 'czpowgate': op = cirq.CZPowGate(exponent=arg_func_langs.float_arg_from_proto( operation_proto.czpowgate.exponent, arg_function_language=arg_function_language, required_arg_name=None, ))(*qubits) elif which_gate_type == 'iswappowgate': op = cirq.ISwapPowGate( exponent=arg_func_langs.float_arg_from_proto( operation_proto.iswappowgate.exponent, arg_function_language=arg_function_language, required_arg_name=None, ))(*qubits) elif which_gate_type == 'fsimgate': theta = arg_func_langs.float_arg_from_proto( operation_proto.fsimgate.theta, arg_function_language=arg_function_language, required_arg_name=None, ) phi = arg_func_langs.float_arg_from_proto( operation_proto.fsimgate.phi, arg_function_language=arg_function_language, required_arg_name=None, ) if isinstance(theta, (float, sympy.Basic)) and isinstance( phi, (float, sympy.Basic)): op = cirq.FSimGate(theta=theta, phi=phi)(*qubits) else: raise ValueError( 'theta and phi must be specified for FSimGate') elif which_gate_type == 'measurementgate': key = arg_func_langs.arg_from_proto( operation_proto.measurementgate.key, arg_function_language=arg_function_language, required_arg_name=None, ) invert_mask = arg_func_langs.arg_from_proto( operation_proto.measurementgate.invert_mask, arg_function_language=arg_function_language, required_arg_name=None, ) if isinstance(invert_mask, list) and isinstance(key, str): op = cirq.MeasurementGate( num_qubits=len(qubits), key=key, invert_mask=tuple(invert_mask))(*qubits) else: raise ValueError( f'Incorrect types for measurement gate {invert_mask} {key}' ) elif which_gate_type == 'waitgate': total_nanos = arg_func_langs.float_arg_from_proto( operation_proto.waitgate.duration_nanos, arg_function_language=arg_function_language, required_arg_name=None, ) op = cirq.WaitGate(duration=cirq.Duration(nanos=total_nanos))( *qubits) else: raise ValueError( f'Unsupported serialized gate with type "{which_gate_type}".' f'\n\noperation_proto:\n{operation_proto}') which = operation_proto.WhichOneof('token') if which == 'token_constant_index': if not constants: raise ValueError('Proto has references to constants table ' 'but none was passed in, value =' f'{operation_proto}') op = op.with_tags( CalibrationTag(constants[ operation_proto.token_constant_index].string_value)) elif which == 'token_value': op = op.with_tags(CalibrationTag(operation_proto.token_value)) return op
def test_cirq_qsim_all_supported_gates(self): q0 = cirq.GridQubit(1, 1) q1 = cirq.GridQubit(1, 0) q2 = cirq.GridQubit(0, 1) q3 = cirq.GridQubit(0, 0) circuit = cirq.Circuit( cirq.Moment([ cirq.H(q0), cirq.H(q1), cirq.H(q2), cirq.H(q3), ]), cirq.Moment([ cirq.T(q0), cirq.T(q1), cirq.T(q2), cirq.T(q3), ]), cirq.Moment([ cirq.CZPowGate(exponent=0.7, global_shift=0.2)(q0, q1), cirq.CXPowGate(exponent=1.2, global_shift=0.4)(q2, q3), ]), cirq.Moment([ cirq.XPowGate(exponent=0.3, global_shift=1.1)(q0), cirq.YPowGate(exponent=0.4, global_shift=1)(q1), cirq.ZPowGate(exponent=0.5, global_shift=0.9)(q2), cirq.HPowGate(exponent=0.6, global_shift=0.8)(q3), ]), cirq.Moment([ cirq.CX(q0, q2), cirq.CZ(q1, q3), ]), cirq.Moment([ cirq.X(q0), cirq.Y(q1), cirq.Z(q2), cirq.S(q3), ]), cirq.Moment([ cirq.XXPowGate(exponent=0.4, global_shift=0.7)(q0, q1), cirq.YYPowGate(exponent=0.8, global_shift=0.5)(q2, q3), ]), cirq.Moment([cirq.I(q0), cirq.I(q1), cirq.IdentityGate(2)(q2, q3)]), cirq.Moment([ cirq.rx(0.7)(q0), cirq.ry(0.2)(q1), cirq.rz(0.4)(q2), cirq.PhasedXPowGate(phase_exponent=0.8, exponent=0.6, global_shift=0.3)(q3), ]), cirq.Moment([ cirq.ZZPowGate(exponent=0.3, global_shift=1.3)(q0, q2), cirq.ISwapPowGate(exponent=0.6, global_shift=1.2)(q1, q3), ]), cirq.Moment([ cirq.XPowGate(exponent=0.1, global_shift=0.9)(q0), cirq.YPowGate(exponent=0.2, global_shift=1)(q1), cirq.ZPowGate(exponent=0.3, global_shift=1.1)(q2), cirq.HPowGate(exponent=0.4, global_shift=1.2)(q3), ]), cirq.Moment([ cirq.SwapPowGate(exponent=0.2, global_shift=0.9)(q0, q1), cirq.PhasedISwapPowGate(phase_exponent=0.8, exponent=0.6)(q2, q3), ]), cirq.Moment([ cirq.PhasedXZGate(x_exponent=0.2, z_exponent=0.3, axis_phase_exponent=1.4)(q0), cirq.T(q1), cirq.H(q2), cirq.S(q3), ]), cirq.Moment([ cirq.SWAP(q0, q2), cirq.XX(q1, q3), ]), cirq.Moment([ cirq.rx(0.8)(q0), cirq.ry(0.9)(q1), cirq.rz(1.2)(q2), cirq.T(q3), ]), cirq.Moment([ cirq.YY(q0, q1), cirq.ISWAP(q2, q3), ]), cirq.Moment([ cirq.T(q0), cirq.Z(q1), cirq.Y(q2), cirq.X(q3), ]), cirq.Moment([ cirq.FSimGate(0.3, 1.7)(q0, q2), cirq.ZZ(q1, q3), ]), cirq.Moment([ cirq.ry(1.3)(q0), cirq.rz(0.4)(q1), cirq.rx(0.7)(q2), cirq.S(q3), ]), cirq.Moment([ cirq.MatrixGate( np.array([[0, -0.5 - 0.5j, -0.5 - 0.5j, 0], [0.5 - 0.5j, 0, 0, -0.5 + 0.5j], [0.5 - 0.5j, 0, 0, 0.5 - 0.5j], [0, -0.5 - 0.5j, 0.5 + 0.5j, 0]]))(q0, q1), cirq.MatrixGate( np.array([[0.5 - 0.5j, 0, 0, -0.5 + 0.5j], [0, 0.5 - 0.5j, -0.5 + 0.5j, 0], [0, -0.5 + 0.5j, -0.5 + 0.5j, 0], [0.5 - 0.5j, 0, 0, 0.5 - 0.5j]]))(q2, q3), ]), cirq.Moment([ cirq.MatrixGate(np.array([[1, 0], [0, 1j]]))(q0), cirq.MatrixGate(np.array([[0, -1j], [1j, 0]]))(q1), cirq.MatrixGate(np.array([[0, 1], [1, 0]]))(q2), cirq.MatrixGate(np.array([[1, 0], [0, -1]]))(q3), ]), cirq.Moment([ cirq.riswap(0.7)(q0, q1), cirq.givens(1.2)(q2, q3), ]), cirq.Moment([ cirq.H(q0), cirq.H(q1), cirq.H(q2), cirq.H(q3), ]), ) simulator = cirq.Simulator() cirq_result = simulator.simulate(circuit) qsim_simulator = qsimcirq.QSimSimulator() qsim_result = qsim_simulator.simulate(circuit) assert cirq.linalg.allclose_up_to_global_phase( qsim_result.state_vector(), cirq_result.state_vector())
cirq.PhasedXPowGate(phase_exponent=0.125, exponent=0.5)(Q0), op_proto({ 'phasedxpowgate': { 'phase_exponent': { 'float_value': 0.125 }, 'exponent': { 'float_value': 0.5 }, }, 'qubit_constant_index': [0], }), ), ( cirq.PhasedXZGate(x_exponent=0.125, z_exponent=0.5, axis_phase_exponent=0.25)(Q0), op_proto({ 'phasedxzgate': { 'x_exponent': { 'float_value': 0.125 }, 'z_exponent': { 'float_value': 0.5 }, 'axis_phase_exponent': { 'float_value': 0.25 }, }, 'qubit_constant_index': [0], }),
cirq.Z, cirq.ZPowGate(exponent=-0.23), ] finally_decomposed_1q_gates = [] native_2q_gates = [ ig.IsingGate(exponent=0.45), ig.XYGate(exponent=0.38), ] non_native_1q_gates = [ cirq.H, cirq.HPowGate(exponent=-0.55), cirq.PhasedXZGate(x_exponent=0.2, z_exponent=-0.5, axis_phase_exponent=0.75), ] non_native_2q_gates = [ cirq.ISwapPowGate(exponent=0.27), cirq.ISWAP, cirq.SWAP, cirq.CNOT, cirq.CXPowGate(exponent=-2.2), cirq.CZ, cirq.CZPowGate(exponent=1.6), ] class TestOperationValidation:
gpe_op_id_1 = cirq.OpIdentifier(cirq.PhasedXZGate, q1) assert props_v2.gate_pauli_errors[gpe_op_id_0] == expected_vals['gate_pauli_errors'] assert props_v2.gate_pauli_errors[gpe_op_id_1] == expected_vals['gate_pauli_errors'] fsim_op_id_0 = cirq.OpIdentifier(cirq.CZPowGate, q0, q1) fsim_op_id_1 = cirq.OpIdentifier(cirq.CZPowGate, q1, q0) assert props_v2.fsim_errors[fsim_op_id_0] == expected_vals['fsim_errors'] assert props_v2.fsim_errors[fsim_op_id_1] == expected_vals['fsim_errors'] @pytest.mark.parametrize( 'op', [ (cirq.Z(cirq.LineQubit(0)) ** 0.3).with_tags(cirq_google.PhysicalZTag), cirq.PhasedXZGate(x_exponent=0.8, z_exponent=0.2, axis_phase_exponent=0.1).on( cirq.LineQubit(0) ), ], ) def test_single_qubit_gates(op): q0 = cirq.LineQubit(0) props = sample_noise_properties([q0], []) model = NoiseModelFromGoogleNoiseProperties(props) circuit = cirq.Circuit(op) noisy_circuit = circuit.with_noise(model) assert len(noisy_circuit.moments) == 3 assert len(noisy_circuit.moments[0].operations) == 1 assert noisy_circuit.moments[0].operations[0] == op.with_tags(PHYSICAL_GATE_TAG) # Depolarizing noise assert len(noisy_circuit.moments[1].operations) == 1
def phxz(a, x, z): return cirq.PhasedXZGate( axis_phase_exponent=a, x_exponent=x, z_exponent=z, )