def test_runtime_types_of_rot_gates(): for gate_type in [lambda p: cirq.CZPowGate(exponent=p), lambda p: cirq.XPowGate(exponent=p), lambda p: cirq.YPowGate(exponent=p), lambda p: cirq.ZPowGate(exponent=p)]: p = gate_type(sympy.Symbol('a')) assert cirq.unitary(p, None) is None assert cirq.pow(p, 2, None) == gate_type(2 * sympy.Symbol('a')) assert cirq.inverse(p, None) == gate_type(-sympy.Symbol('a')) c = gate_type(0.5) assert cirq.unitary(c, None) is not None assert cirq.pow(c, 2) == gate_type(1) assert cirq.inverse(c) == gate_type(-0.5)
def test_find_circuit_structure_violations(): q0, q1 = cirq.LineQubit.range(2) circuit = cirq.Circuit([ cirq.Moment([cirq.PhasedXPowGate(phase_exponent=0).on(q0)]), cirq.Moment([ cirq.PhasedXPowGate(phase_exponent=0.5).on(q0), cirq.ZPowGate(exponent=1).on(q1) ]), cirq.Moment([cg.SYC(q0, q1)]), cirq.measure(q0, q1, key='z'), cirq.CNOT(q0, q1) ]) violations = find_circuit_structure_violations(circuit) np.testing.assert_array_equal(violations, [1, 4]) assert violations.tolist() == [1, 4]
def test_simplify_circuit_merge_one_qubit_gates(self, qubits): q0 = qubits[0] c = cirq.Circuit() c.append([ cirq.XPowGate(exponent=0.1)(q0), cirq.YPowGate(exponent=0.2)(q0), cirq.ZPowGate(exponent=0.3)(q0), ]) new = simplify_circuit(c) # the one-qubit gates have been merged assert len(new) == 2 assert isinstance(new[0].operations[0].gate, cirq.PhasedXPowGate) assert isinstance(new[1].operations[0].gate, cirq.ZPowGate)
def test_import_non_line_qubits_error(self): qubit_a = cirq.GridQubit(0, 1) qubit_b = cirq.GridQubit(0, 2) circ = cirq.Circuit( cirq.PhasedXPowGate(exponent=0.47, phase_exponent=0.11).on(qubit_a), cirq.CZPowGate(exponent=1.0).on(qubit_a, qubit_b), cirq.ZPowGate(exponent=0.42).on(qubit_b) ) with self.assertRaisesRegex( ValueError, r'import is supported for circuits on LineQubits only \[found qubit' r' type\(s\): GridQubit\]'): cirq_converter.import_from_cirq(circ)
def test_validate_well_structured_inhomo(): q0, q1 = cirq.LineQubit.range(2) circuit = cirq.Circuit([ cirq.Moment([cirq.PhasedXPowGate(phase_exponent=0).on(q0)]), cirq.Moment([ cirq.PhasedXPowGate(phase_exponent=0.5).on(q0), cirq.ZPowGate(exponent=1).on(q1) ]), cirq.Moment([cg.SYC(q0, q1)]), cirq.measure(q0, q1, key='z'), ]) with pytest.raises(BadlyStructuredCircuitError) as e: validate_well_structured(circuit) assert e.match('Inhomogeneous')
def test_parameterizable(resolve_fn): a = sympy.Symbol('a') qubits = cirq.LineQubit.range(3) cz = cirq.ControlledOperation(qubits[:1], cirq.Z(qubits[1])) cza = cirq.ControlledOperation(qubits[:1], cirq.ZPowGate(exponent=a)(qubits[1])) assert cirq.is_parameterized(cza) assert not cirq.is_parameterized(cz) assert resolve_fn(cza, cirq.ParamResolver({'a': 1})) == cz cchan = cirq.ControlledOperation( [qubits[0]], cirq.RandomGateChannel(sub_gate=cirq.PhaseDampingChannel(0.1), probability=a)(qubits[1]), ) with pytest.raises(ValueError, match='Cannot control channel'): resolve_fn(cchan, cirq.ParamResolver({'a': 0.1}))
def operations(self, qubits: Sequence[cirq.Qid]) -> cirq.OP_TREE: """Produce the operations of the ansatz circuit.""" # TODO implement asymmetric ansatz param_set = set(self.params()) for i in range(self.iterations): # Apply one- and two-body interactions with a swap network that # reverses the order of the modes def one_and_two_body_interaction(p, q, a, b) -> cirq.OP_TREE: t_symbol = LetterWithSubscripts('T', p, q, i) w_symbol = LetterWithSubscripts('W', p, q, i) v_symbol = LetterWithSubscripts('V', p, q, i) if t_symbol in param_set: yield cirq.ISwapPowGate(exponent=-t_symbol).on(a, b) if w_symbol in param_set: yield cirq.PhasedISwapPowGate(exponent=w_symbol).on(a, b) if v_symbol in param_set: yield cirq.CZPowGate(exponent=v_symbol).on(a, b) yield swap_network( qubits, one_and_two_body_interaction, fermionic=True) qubits = qubits[::-1] # Apply one-body potential for p in range(len(qubits)): u_symbol = LetterWithSubscripts('U', p, i) if u_symbol in param_set: yield cirq.ZPowGate(exponent=u_symbol).on(qubits[p]) # Apply one- and two-body interactions again. This time, reorder # them so that the entire iteration is symmetric def one_and_two_body_interaction_reversed_order(p, q, a, b ) -> cirq.OP_TREE: t_symbol = LetterWithSubscripts('T', p, q, i) w_symbol = LetterWithSubscripts('W', p, q, i) v_symbol = LetterWithSubscripts('V', p, q, i) if v_symbol in param_set: yield cirq.CZPowGate(exponent=v_symbol).on(a, b) if w_symbol in param_set: yield cirq.PhasedISwapPowGate(exponent=w_symbol).on(a, b) if t_symbol in param_set: yield cirq.ISwapPowGate(exponent=-t_symbol).on(a, b) yield swap_network( qubits, one_and_two_body_interaction_reversed_order, fermionic=True, offset=True) qubits = qubits[::-1]
def test_deserialize_exp_z_parameterized(): serialized_op = { 'gate': { 'id': 'exp_z' }, 'args': { 'half_turns': { 'symbol': 'x' } }, 'qubits': [{ 'id': '1_2' }] } q = cirq.GridQubit(1, 2) expected = cirq.ZPowGate(exponent=sympy.Symbol('x'))(q) assert cg.XMON.deserialize_op_dict(serialized_op) == expected
def qft_cirq(n): q = cirq.GridQubit.rect(1, n) gates = [] for j in range(n): for k in range(j): gates.append( cirq.ZPowGate(exponent=math.pi / float(2**(j - k))).controlled()(q[j], q[k])) gates.append(cirq.H(q[j])) for i in range(n): gates.append(cirq.measure(q[i], key='c' + str(i))) circ = cirq.Circuit(gates) return circ
def encode_classical_datapoint(vector, qubits=None): vec_norm = vector / np.linalg.norm(vector) n = max(1, int(np.ceil(np.log2(len(vec_norm))))) if qubits is None: qubits = cirq.LineQubit.range(n) N = 2 ** n while len(vec_norm) < N: vec_norm = np.append(vec_norm, 0) magnitudes = list(map(np.abs, vec_norm)) phases = list(map(np.angle, vec_norm)) M = get_uniformly_controlled_rotation_matrix(n - 1) rotation_cnots = get_cnot_control_positions(n - 1) reversed_prog = cirq.Circuit() for step in range(n): reversed_step_prog = cirq.Circuit() z_thetas, y_thetas, phases, magnitudes = \ get_rotation_parameters(phases, magnitudes) converted_z_thetas = np.dot(M, z_thetas) converted_y_thetas = np.dot(M, y_thetas) phase_prog = get_reversed_unification_program(converted_z_thetas, rotation_cnots, qubits[0], qubits[step + 1:], 'phase') prob_prog = get_reversed_unification_program(converted_y_thetas, rotation_cnots, qubits[0], qubits[step + 1:], 'magnitude') if step < n - 1: reversed_step_prog.append(cirq.SWAP(qubits[0], qubits[step + 1])) M = M[0:int(len(M) / 2), 0:int(len(M) / 2)] * 2 rotation_cnots = rotation_cnots[:int(len(rotation_cnots) / 2)] rotation_cnots[-1] -= 1 reversed_step_prog.append(prob_prog) reversed_step_prog.append(phase_prog) reversed_prog.append(reversed_step_prog) reversed_prog.append(cirq.H(i) for i in qubits) reversed_prog.append([cirq.rz(-2 * phases[0])(qubits[0]), cirq.ZPowGate(exponent=2 * phases[0]/np.pi)(qubits[0])]) return reversed_prog
def test_ixyz_circuit_diagram(): q = cirq.NamedQubit('q') ix = cirq.XPowGate(exponent=1, global_shift=0.5) iy = cirq.YPowGate(exponent=1, global_shift=0.5) iz = cirq.ZPowGate(exponent=1, global_shift=0.5) cirq.testing.assert_has_diagram( cirq.Circuit( ix(q), ix(q)**-1, ix(q)**-0.99999, ix(q)**-1.00001, ix(q)**3, ix(q)**4.5, ix(q)**4.500001, ), """ q: ───X───X───X───X───X───X^0.5───X^0.5─── """, ) cirq.testing.assert_has_diagram( cirq.Circuit( iy(q), iy(q)**-1, iy(q)**3, iy(q)**4.5, iy(q)**4.500001, ), """ q: ───Y───Y───Y───Y^0.5───Y^0.5─── """, ) cirq.testing.assert_has_diagram( cirq.Circuit( iz(q), iz(q)**-1, iz(q)**3, iz(q)**4.5, iz(q)**4.500001, ), """ q: ───Z───Z───Z───S───S─── """, )
def test_equivalent_circuit(): qreg = cirq.LineQubit.range(4) oldc = cirq.Circuit() newc = cirq.Circuit() gates = [cirq.XPowGate()**(1/2), cirq.YPowGate()**(1/3), cirq.ZPowGate()**-1] for gate in gates: for qubit in qreg: oldc.append(gate.on(qubit)) newc.append(cirq.ops.ParallelGateOperation(gate, qreg)) cirq.testing.assert_has_diagram(newc, oldc.to_text_diagram()) cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(oldc, newc, atol= 1e-6)
def test_wrong_dims(): x3 = cirq.XPowGate(dimension=3) with pytest.raises(ValueError, match='Wrong shape'): _ = x3.on(cirq.LineQubit(0)) with pytest.raises(ValueError, match='Wrong shape'): _ = x3.on(cirq.LineQid(0, dimension=4)) z3 = cirq.ZPowGate(dimension=3) with pytest.raises(ValueError, match='Wrong shape'): _ = z3.on(cirq.LineQubit(0)) with pytest.raises(ValueError, match='Wrong shape'): _ = z3.on(cirq.LineQid(0, dimension=4)) with pytest.raises(ValueError, match='Wrong shape'): _ = cirq.X.on(cirq.LineQid(0, dimension=3)) with pytest.raises(ValueError, match='Wrong shape'): _ = cirq.Z.on(cirq.LineQid(0, dimension=3))
def unitary_design_block(circuit: cirq.Circuit, n: int) -> cirq.Circuit: """ random Haar measure approximation :param circuit: cirq.Circuit, empty circuit :param n: # of qubit :return: """ for i in range(n): theta = np.random.choice([0, 2 / 3, 4 / 3]) circuit.append(cirq.ZPowGate(exponent=theta)(q(i))) for i in range(n - 1): for j in range(i + 1, n): if np.random.choice([0, 1]) < 0.5: circuit.append(cirq.CZ(q(i), q(j))) for i in range(n): circuit.append(cirq.H(q(i))) return circuit
def test_z_init(): z = cirq.ZPowGate(exponent=5) assert z.exponent == 5 # Canonicalizes exponent for equality, but keeps the inner details. assert cirq.Z**0.5 != cirq.Z**-0.5 assert (cirq.Z**-1)**0.5 == cirq.Z**-0.5 assert cirq.Z**-1 == cirq.Z assert cirq.Z.controlled(num_controls=2) == cirq.ControlledGate( cirq.Z, num_controls=2) assert cirq.Z.controlled(num_controls=1) == cirq.CZ assert cirq.Z.controlled(control_values=((1, ), )) == cirq.CZ assert cirq.Z.controlled(control_qid_shape=(2, )) == cirq.CZ assert cirq.Z.controlled(num_controls=1, control_qid_shape=(3, )) == cirq.ControlledGate( cirq.Z, num_controls=1, control_qid_shape=(3, )) assert z.controlled() == cirq.CZPowGate(exponent=5)
def test_deserialize_exp_z(half_turns): serialized_op = { 'gate': { 'id': 'exp_z' }, 'args': { 'half_turns': { 'arg_value': { 'float_value': half_turns } } }, 'qubits': [{ 'id': '1_2' }] } q = cirq.GridQubit(1, 2) expected = cirq.ZPowGate(exponent=half_turns)(q) assert cg.XMON.deserialize_op_dict(serialized_op) == expected
def export_to_cirq(obj): """Imports a gate, operation or circuit from Cirq. Args: obj: the object to be exported to Cirq. Returns: the exported Cirq object (an instance of cirq.Circuit, cirq.GateOperation, or a subclass of cirq.Gate). Raises: TypeError: if export is not supported for the given type. ValueError: if the object cannot be exported successfully. """ if isinstance(obj, circuit.PhasedXGate): return cirq.PhasedXPowGate(exponent=obj.get_rotation_angle() / np.pi, phase_exponent=obj.get_phase_angle() / np.pi) elif isinstance(obj, circuit.RotZGate): return cirq.ZPowGate(exponent=obj.get_rotation_angle() / np.pi) elif isinstance(obj, circuit.ControlledZGate): return cirq.CZPowGate(exponent=1.0) elif isinstance(obj, circuit.MatrixGate): num_qubits = obj.get_num_qubits() operator = obj.get_operator() if num_qubits == 1: return cirq.SingleQubitMatrixGate(operator) elif num_qubits == 2: return cirq.TwoQubitMatrixGate(operator) else: raise ValueError('MatrixGate for %d qubits not supported (Cirq has' ' matrix gates only up to 2 qubits)' % num_qubits) elif isinstance(obj, circuit.Operation): return cirq.GateOperation( export_to_cirq(obj.get_gate()), [cirq.LineQubit(qubit) for qubit in obj.get_qubits()]) elif isinstance(obj, circuit.Circuit): return cirq.Circuit(export_to_cirq(operation) for operation in obj) else: raise TypeError('unknown type: %s' % type(obj).__name__)
def test_exponentiate_single_value_as_exponent(): q = cirq.LineQubit(0) assert cirq.approx_eq(math.e**(-0.25j * math.pi * cirq.X(q)), cirq.Rx(0.25 * math.pi).on(q)) assert cirq.approx_eq(math.e**(-0.25j * math.pi * cirq.Y(q)), cirq.Ry(0.25 * math.pi).on(q)) assert cirq.approx_eq(math.e**(-0.25j * math.pi * cirq.Z(q)), cirq.Rz(0.25 * math.pi).on(q)) assert cirq.approx_eq(np.exp(-0.3j * math.pi * cirq.X(q)), cirq.Rx(0.3 * math.pi).on(q)) assert cirq.approx_eq(cirq.X(q)**0.5, cirq.XPowGate(exponent=0.5).on(q)) assert cirq.approx_eq(cirq.Y(q)**0.5, cirq.YPowGate(exponent=0.5).on(q)) assert cirq.approx_eq(cirq.Z(q)**0.5, cirq.ZPowGate(exponent=0.5).on(q))
def test_deserialize_z_parameterized(): serialized_op = op_proto({ 'gate': { 'id': 'z' }, 'args': { 'half_turns': { 'symbol': 'a' }, 'type': { 'arg_value': { 'string_value': cgc.VIRTUAL_Z } }, }, 'qubits': [{ 'id': '1_2' }], }) q = cirq.GridQubit(1, 2) expected = cirq.ZPowGate(exponent=sympy.Symbol('a'))(q) assert SINGLE_QUBIT_GATE_SET.deserialize_op(serialized_op) == expected
def test_deserialize_z_parameterized(): serialized_op = { 'gate': { 'id': 'z' }, 'args': { 'half_turns': { 'symbol': 'a' }, 'type': { 'arg_value': { 'string_value': 'virtual_propagates_forward' } } }, 'qubits': [{ 'id': '1_2' }] } q = cirq.GridQubit(1, 2) expected = cirq.ZPowGate(exponent=sympy.Symbol('a'))(q) assert SINGLE_QUBIT_GATE_SET.deserialize_op_dict(serialized_op) == expected
def test_deserialize_exp_z_parameterized(): serialized_op = op_proto({ 'gate': { 'id': 'z' }, 'args': { 'half_turns': { 'symbol': 'x' }, 'type': { 'arg_value': { 'string_value': 'virtual_propagates_forward' } }, }, 'qubits': [{ 'id': '1_2' }], }) q = cirq.GridQubit(1, 2) expected = cirq.ZPowGate(exponent=sympy.Symbol('x'))(q) assert cg.XMON.deserialize_op(serialized_op) == expected
def test_equivalent_unitaries(): """This test covers the factor of pi change. However, it will be skipped if pyquil is unavailable for import. References: https://docs.pytest.org/en/latest/skipping.html#skipping-on-a-missing-import-dependency """ pyquil = pytest.importorskip("pyquil") pyquil_simulation_tools = pytest.importorskip("pyquil.simulation.tools") q0, q1 = _make_qubits(2) operations = [ cirq.XPowGate(exponent=0.5, global_shift=-0.5)(q0), cirq.YPowGate(exponent=0.5, global_shift=-0.5)(q0), cirq.ZPowGate(exponent=0.5, global_shift=-0.5)(q0), cirq.CZPowGate(exponent=0.5)(q0, q1), cirq.ISwapPowGate(exponent=0.5)(q0, q1), ] output = cirq.QuilOutput(operations, (q0, q1)) program = pyquil.Program(str(output)) pyquil_unitary = pyquil_simulation_tools.program_unitary(program, n_qubits=2) # Qubit ordering differs between pyQuil and Cirq. cirq_unitary = cirq.Circuit(cirq.SWAP(q0, q1), operations, cirq.SWAP(q0, q1)).unitary() assert np.allclose(pyquil_unitary, cirq_unitary)
def test_str(): assert str(cirq.X) == 'X' assert str(cirq.X**0.5) == 'X**0.5' assert str(cirq.Rx(np.pi)) == 'Rx(π)' assert str(cirq.Rx(0.5 * np.pi)) == 'Rx(0.5π)' assert str(cirq.XPowGate( global_shift=-0.25)) == 'XPowGate(exponent=1.0, global_shift=-0.25)' assert str(cirq.Z) == 'Z' assert str(cirq.Z**0.5) == 'S' assert str(cirq.Z**0.125) == 'Z**0.125' assert str(cirq.Rz(np.pi)) == 'Rz(π)' assert str(cirq.Rz(1.4 * np.pi)) == 'Rz(1.4π)' assert str(cirq.ZPowGate( global_shift=0.25)) == 'ZPowGate(exponent=1.0, global_shift=0.25)' assert str(cirq.S) == 'S' assert str(cirq.S**-1) == 'S**-1' assert str(cirq.T) == 'T' assert str(cirq.T**-1) == 'T**-1' assert str(cirq.Y) == 'Y' assert str(cirq.Y**0.5) == 'Y**0.5' assert str(cirq.Ry(np.pi)) == 'Ry(π)' assert str(cirq.Ry(3.14 * np.pi)) == 'Ry(3.14π)' assert str(cirq.YPowGate( exponent=2, global_shift=-0.25)) == 'YPowGate(exponent=2, global_shift=-0.25)' assert str(cirq.CX) == 'CNOT' assert str(cirq.CNOT**0.5) == 'CNOT**0.5' assert str(cirq.SWAP) == 'SWAP' assert str(cirq.SWAP**0.5) == 'SWAP**0.5' assert str(cirq.ISWAP) == 'ISWAP' assert str(cirq.ISWAP**0.5) == 'ISWAP**0.5'
def gate_to_cirq(gate1): """Converts list of gate sequences to its cirq analogue Args: gate1: Sequence of gate to be transcribed Returns: -- Raises: RuntimeError: Gate value passed cannot be implemented by cirq library """ if gate1[0] == 'X': return cirq.X elif gate1[0] == 'Ry': return cirq.ry(-gate1[1]) elif gate1[0] == 'Rz': return cirq.rz(-gate1[1]) elif gate1[0] == 'R1': return cirq.ZPowGate(exponent=gate1[1] / np.pi) else: raise RuntimeError("Can't implement: %s" % gate1)
def test_deserialize_z(half_turns): serialized_op = { 'gate': { 'id': 'z' }, 'args': { 'half_turns': { 'arg_value': { 'float_value': half_turns } }, 'type': { 'arg_value': { 'string_value': 'virtual_propagates_forward' } } }, 'qubits': [{ 'id': '1_2' }] } q = cirq.GridQubit(1, 2) expected = cirq.ZPowGate(exponent=half_turns)(q) assert SINGLE_QUBIT_GATE_SET.deserialize_op_dict(serialized_op) == expected
def test_deserialize_exp_z(half_turns): serialized_op = op_proto({ 'gate': { 'id': 'z' }, 'args': { 'half_turns': { 'arg_value': { 'float_value': half_turns } }, 'type': { 'arg_value': { 'string_value': 'virtual_propagates_forward' } }, }, 'qubits': [{ 'id': '1_2' }], }) q = cirq.GridQubit(1, 2) expected = cirq.ZPowGate(exponent=half_turns)(q) assert cg.XMON.deserialize_op(serialized_op) == expected
def test_equals(): eq = cirq.testing.EqualsTester() eq.add_equality_group(cirq.X, cirq.ops.pauli_gates.X, cirq.XPowGate()) eq.add_equality_group(cirq.Y, cirq.ops.pauli_gates.Y, cirq.YPowGate()) eq.add_equality_group(cirq.Z, cirq.ops.pauli_gates.Z, cirq.ZPowGate())
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
class NonGateOperation(cirq.Operation): def qubits(self): pass def with_qubits(self, *new_qubits): pass assert not cirq.op_gate_isinstance(NonGateOperation(), cirq.XPowGate) assert not cirq.op_gate_isinstance(NonGateOperation(), NonGateOperation) @pytest.mark.parametrize('gate1,gate2,eq_up_to_global_phase', [ (cirq.rz(0.3 * np.pi), cirq.Z**0.3, True), (cirq.rz(0.3), cirq.Z**0.3, False), (cirq.ZZPowGate(global_shift=0.5), cirq.ZZ, True), (cirq.ZPowGate(global_shift=0.5)**sympy.Symbol('e'), cirq.Z, False), (cirq.Z**sympy.Symbol('e'), cirq.Z**sympy.Symbol('f'), False), ]) def test_equal_up_to_global_phase_on_gates(gate1, gate2, eq_up_to_global_phase): num_qubits1, num_qubits2 = (cirq.num_qubits(g) for g in (gate1, gate2)) qubits = cirq.LineQubit.range(max(num_qubits1, num_qubits2) + 1) op1, op2 = gate1(*qubits[:num_qubits1]), gate2(*qubits[:num_qubits2]) assert cirq.equal_up_to_global_phase(op1, op2) == eq_up_to_global_phase op2_on_diff_qubits = gate2(*qubits[1:num_qubits2 + 1]) assert not cirq.equal_up_to_global_phase(op1, op2_on_diff_qubits) def test_equal_up_to_global_phase_on_diff_types(): op = cirq.X(cirq.LineQubit(0)) assert not cirq.equal_up_to_global_phase(op, 3)
def test_cirq_qsim_global_shift(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.CXPowGate(exponent=1, global_shift=0.7)(q0, q1), cirq.CZPowGate(exponent=1, global_shift=0.9)(q2, q3), ]), cirq.Moment([ cirq.XPowGate(exponent=1, global_shift=1.1)(q0), cirq.YPowGate(exponent=1, global_shift=1)(q1), cirq.ZPowGate(exponent=1, global_shift=0.9)(q2), cirq.HPowGate(exponent=1, global_shift=0.8)(q3), ]), cirq.Moment([ cirq.XXPowGate(exponent=1, global_shift=0.2)(q0, q1), cirq.YYPowGate(exponent=1, global_shift=0.3)(q2, q3), ]), cirq.Moment([ cirq.ZPowGate(exponent=0.25, global_shift=0.4)(q0), cirq.ZPowGate(exponent=0.5, global_shift=0.5)(q1), cirq.YPowGate(exponent=1, global_shift=0.2)(q2), cirq.ZPowGate(exponent=1, global_shift=0.3)(q3), ]), cirq.Moment([ cirq.ZZPowGate(exponent=1, global_shift=0.2)(q0, q1), cirq.SwapPowGate(exponent=1, global_shift=0.3)(q2, q3), ]), cirq.Moment([ cirq.XPowGate(exponent=1, global_shift=0)(q0), cirq.YPowGate(exponent=1, global_shift=0)(q1), cirq.ZPowGate(exponent=1, global_shift=0)(q2), cirq.HPowGate(exponent=1, global_shift=0)(q3), ]), cirq.Moment([ cirq.ISwapPowGate(exponent=1, global_shift=0.3)(q0, q1), cirq.ZZPowGate(exponent=1, global_shift=0.5)(q2, q3), ]), cirq.Moment([ cirq.ZPowGate(exponent=0.5, global_shift=0)(q0), cirq.ZPowGate(exponent=0.25, global_shift=0)(q1), cirq.XPowGate(exponent=0.9, global_shift=0)(q2), cirq.YPowGate(exponent=0.8, global_shift=0)(q3), ]), cirq.Moment([ cirq.CZPowGate(exponent=0.3, global_shift=0)(q0, q1), cirq.CXPowGate(exponent=0.4, global_shift=0)(q2, q3), ]), cirq.Moment([ cirq.ZPowGate(exponent=1.3, global_shift=0)(q0), cirq.HPowGate(exponent=0.8, global_shift=0)(q1), cirq.XPowGate(exponent=0.9, global_shift=0)(q2), cirq.YPowGate(exponent=0.4, global_shift=0)(q3), ]), cirq.Moment([ cirq.XXPowGate(exponent=0.8, global_shift=0)(q0, q1), cirq.YYPowGate(exponent=0.6, global_shift=0)(q2, q3), ]), cirq.Moment([ cirq.HPowGate(exponent=0.7, global_shift=0)(q0), cirq.ZPowGate(exponent=0.2, global_shift=0)(q1), cirq.YPowGate(exponent=0.3, global_shift=0)(q2), cirq.XPowGate(exponent=0.7, global_shift=0)(q3), ]), cirq.Moment([ cirq.ZZPowGate(exponent=0.1, global_shift=0)(q0, q1), cirq.SwapPowGate(exponent=0.6, global_shift=0)(q2, q3), ]), cirq.Moment([ cirq.XPowGate(exponent=0.4, global_shift=0)(q0), cirq.YPowGate(exponent=0.3, global_shift=0)(q1), cirq.ZPowGate(exponent=0.2, global_shift=0)(q2), cirq.HPowGate(exponent=0.1, global_shift=0)(q3), ]), cirq.Moment([ cirq.ISwapPowGate(exponent=1.3, global_shift=0)(q0, q1), cirq.CXPowGate(exponent=0.5, global_shift=0)(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())