def test_rot_gates_eq(): eq = cirq.testing.EqualsTester() gates = [ cirq.RotXGate, cirq.RotYGate, cirq.RotZGate, cirq.CNotGate, cirq.Rot11Gate ] for gate in gates: eq.add_equality_group(gate(half_turns=3.5), gate(half_turns=-0.5), gate(rads=-np.pi / 2), gate(degs=-90)) eq.make_equality_group(lambda: gate(half_turns=0)) eq.make_equality_group(lambda: gate(half_turns=0.5)) eq.add_equality_group(cirq.RotXGate(), cirq.RotXGate(half_turns=1), cirq.X) eq.add_equality_group(cirq.RotYGate(), cirq.RotYGate(half_turns=1), cirq.Y) eq.add_equality_group(cirq.RotZGate(), cirq.RotZGate(half_turns=1), cirq.Z) eq.add_equality_group( cirq.RotZGate(half_turns=1, global_shift_in_half_turns=-0.5), cirq.RotZGate(half_turns=5, global_shift_in_half_turns=-0.5)) eq.add_equality_group( cirq.RotZGate(half_turns=3, global_shift_in_half_turns=-0.5)) eq.add_equality_group( cirq.RotZGate(half_turns=1, global_shift_in_half_turns=-0.1)) eq.add_equality_group( cirq.RotZGate(half_turns=5, global_shift_in_half_turns=-0.1)) eq.add_equality_group(cirq.CNotGate(), cirq.CNotGate(half_turns=1), cirq.CNOT) eq.add_equality_group(cirq.Rot11Gate(), cirq.Rot11Gate(half_turns=1), cirq.CZ)
def operations(self, qubits: Sequence[cirq.QubitId]) -> cirq.OP_TREE: a, b = qubits yield cirq.RotXGate(half_turns=self.params['theta0']).on(a) yield cirq.RotXGate(half_turns=self.params['theta1']).on(b) yield cirq.CZ(a, b) yield cirq.RotXGate(half_turns=self.params['theta0']).on(a) yield cirq.RotXGate(half_turns=self.params['theta1']).on(b) yield cirq.MeasurementGate('all').on(a, b)
def test_x_matrix(): assert np.allclose(cirq.RotXGate(half_turns=1).matrix(), np.array([[0, 1], [1, 0]])) assert np.allclose(cirq.RotXGate(half_turns=0.5).matrix(), np.array([[1 + 1j, 1 - 1j], [1 - 1j, 1 + 1j]]) / 2) assert np.allclose(cirq.RotXGate(half_turns=0).matrix(), np.array([[1, 0], [0, 1]])) assert np.allclose(cirq.RotXGate(half_turns=-0.5).matrix(), np.array([[1 - 1j, 1 + 1j], [1 + 1j, 1 - 1j]]) / 2)
def test_arbitrary_xyz_repr(): cirq.testing.assert_equivalent_repr( cirq.RotXGate(half_turns=0.1, global_shift_in_half_turns=0.2)) cirq.testing.assert_equivalent_repr( cirq.RotYGate(half_turns=0.1, global_shift_in_half_turns=0.2)) cirq.testing.assert_equivalent_repr( cirq.RotZGate(half_turns=0.1, global_shift_in_half_turns=0.2))
def rot_x_layer(length, half_turns): """Yields X rotations by half_turns on a square grid of given length.""" rot = cirq.RotXGate(half_turns=half_turns) for i in range(length): for j in range(length): yield rot(cirq.GridQubit(i, j)) pass pass pass
def test_two_qubit_product_state_identity(half_turn=0.1, repetitions=1000, verbose=False): """Tests the VQSD algorithm for two qubit pure product states. State preperation is single qubit rotations. Diagonalizing unitary is the inverse of state prep. Tests to see if overlap is maximal. """ # get a VQSD circuit circ = VQSD(2) # define the rotations rot = cirq.RotXGate(half_turns=half_turn) rotdag = cirq.RotXGate(half_turns=-half_turn) # add the state preperation circ.state_prep_circ.append([rot(circ.qubits[x]) for x in [0, 1, 4, 5]]) # add the unitary circ.unitary_circ.append([rotdag(circ.qubits[x]) for x in [0, 1, 4, 5]]) # add the dip test circuit circ.dip_test() # verbose output if verbose: print("The total circuit is", circ.algorithm(), sep="\n") # get the HS distance distance = circ.obj_dip(repetitions=repetitions) # make sure we're close tolerance = 1 / repetitions assert distance < tolerance # print success message print("test_two_qubit_product_state_identity()".ljust(DOT_LEN, DOT), "passed!", sep="")
def _rot(self, qubit, params): """Helper function that returns an arbitrary rotation of the form R = Rz(params[2]) * Ry(params[1]) * Rx(params[0]) on the qubit, e.g. R |qubit>. Note that order is reversed when put into the circuit. The circuit is: |qubit>---Rx(params[0])---Ry(params[1])---Rz(params[2])--- """ rx = cirq.RotXGate(half_turns=params[0]) ry = cirq.RotYGate(half_turns=params[1]) rz = cirq.RotZGate(half_turns=params[2]) yield (rx(qubit), ry(qubit), rz(qubit))