def test_parameterizable():
a = cirq.Symbol('a')
cz = cirq.ControlledGate(cirq.RotYGate(half_turns=1))
cza = cirq.ControlledGate(cirq.RotYGate(half_turns=a))
assert cza.is_parameterized()
assert not cz.is_parameterized()
assert cza.with_parameters_resolved_by(cirq.ParamResolver({'a': 1})) == cz
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 test_parameterizable():
a = cirq.Symbol('a')
cz = cirq.ControlledGate(cirq.RotYGate(half_turns=1))
cza = cirq.ControlledGate(cirq.RotYGate(half_turns=a))
assert cirq.is_parameterized(cza)
assert not cirq.is_parameterized(cz)
assert cirq.resolve_parameters(cza, cirq.ParamResolver({'a': 1})) == cz
def test_y_matrix():
assert np.allclose(cirq.RotYGate(half_turns=1).matrix(),
np.array([[0, -1j], [1j, 0]]))
assert np.allclose(cirq.RotYGate(half_turns=0.5).matrix(),
np.array([[1 + 1j, -1 - 1j], [1 + 1j, 1 + 1j]]) / 2)
assert np.allclose(cirq.RotYGate(half_turns=0).matrix(),
np.array([[1, 0], [0, 1]]))
assert np.allclose(cirq.RotYGate(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(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))
def test_various_known_gate_types():
a = cirq.NamedQubit('a')
b = cirq.NamedQubit('b')
circuit = cirq.Circuit.from_ops(
cirq.google.ExpWGate(axis_half_turns=0).on(a),
cirq.google.ExpWGate(axis_half_turns=0.5).on(a),
cirq.X(a),
cirq.X(a)**0.25,
cirq.X(a)**-0.5,
cirq.Z(a),
cirq.Z(a)**0.5,
cirq.Y(a),
cirq.Y(a)**-0.25,
cirq.RotYGate(half_turns=cirq.Symbol('t')).on(a),
cirq.H(a),
cirq.measure(a),
cirq.measure(a, b, key='not-relevant'),
cirq.SWAP(a, b),
cirq.CNOT(a, b),
cirq.CNOT(b, a),
cirq.CZ(a, b),
)
assert circuit_to_quirk_url(circuit, escape_url=False) == """
http://algassert.com/quirk#circuit={"cols":[
["X"],
["Y"],
["X"],
["X^¼"],
["X^-½"],
["Z"],
["Z^½"],
["Y"],
["Y^-¼"],
["Y^t"],
["H"],
["Measure"],
["Measure","Measure"],
["Swap","Swap"],
["•","X"],
["X","•"],
["•","Z"]]}
""".replace('\n', '').replace(' ', '')
