def test_matrix_gate_pow():
t = sympy.Symbol('t')
assert cirq.pow(cirq.MatrixGate(1j * np.eye(1)), t, default=None) is None
assert cirq.pow(cirq.MatrixGate(1j * np.eye(1)), 2) == cirq.MatrixGate(-np.eye(1))
m = cirq.MatrixGate(np.diag([1, 1j, -1]), qid_shape=(3,))
assert m ** 3 == cirq.MatrixGate(np.diag([1, -1j, -1]), qid_shape=(3,))
def test_pow_inverse():
assert cirq.inverse(CRestricted, None) is None
assert cirq.inverse(SCRestricted, None) is None
assert cirq.pow(CRestricted, 1.5, None) is None
assert cirq.pow(SCRestricted, 1.5, None) is None
assert cirq.pow(CY, 1.5) == cirq.ControlledGate(cirq.Y**1.5)
assert cirq.inverse(CY) == CY**-1 == CY
assert cirq.inverse(SCY) == SCY**-1 == SCY
def test_pow_inverse():
assert cirq.inverse(CRestricted, None) is None
assert cirq.inverse(SCRestricted, None) is None
assert cirq.pow(CRestricted, 1.5, None) is None
assert cirq.pow(SCRestricted, 1.5, None) is None
assert cirq.pow(CY, 1.5) == cirq.ControlledGate(cirq.Y**1.5)
assert cirq.inverse(CY) == CY**-1 == CY
assert cirq.inverse(SCY) == SCY**-1 == SCY
assert cirq.inverse(C0Restricted, None) is None
assert cirq.inverse(SC0Restricted, None) is None
assert cirq.pow(C0Restricted, 1.5, None) is None
assert cirq.pow(SC0Restricted, 1.5, None) is None
assert cirq.pow(C0Y, 1.5) == cirq.ControlledGate(cirq.Y**1.5,
control_values=[0])
assert cirq.inverse(C0Y) == C0Y**-1 == C0Y
assert cirq.inverse(SC0Y) == SC0Y**-1 == SC0Y
assert cirq.inverse(C2Restricted, None) is None
assert cirq.inverse(SC2Restricted, None) is None
assert cirq.pow(C2Restricted, 1.5, None) is None
assert cirq.pow(SC2Restricted, 1.5, None) is None
assert cirq.pow(C2Y, 1.5) == cirq.ControlledGate(cirq.Y**1.5,
control_values=[2],
control_qid_shape=(3,))
assert cirq.inverse(C2Y) == C2Y**-1 == C2Y
assert cirq.inverse(SC2Y) == SC2Y**-1 == SC2Y
def test_extrapolate():
h = CExpZinGate(2)
assert cirq.pow(h, 1.5) is not None
assert cirq.inverse(h, None) is not None
p = CExpZinGate(0.1)
assert cirq.pow(p, 1.5) is not None
assert cirq.inverse(p) is not None
s = CExpZinGate(sympy.Symbol('a'))
assert cirq.pow(s, 1.5) == CExpZinGate(sympy.Symbol('a') * 1.5)
assert cirq.inverse(s) == CExpZinGate(-sympy.Symbol('a'))
def test_runtime_types_of_rot_gates():
for gate_type in [
cirq.Rot11Gate, cirq.RotXGate, cirq.RotYGate, cirq.RotZGate
]:
p = gate_type(half_turns=cirq.Symbol('a'))
assert cirq.unitary(p, None) is None
assert cirq.pow(p, 2, None) is None
assert cirq.inverse(p, None) is None
c = gate_type(half_turns=0.5)
assert cirq.unitary(c, None) is not None
assert cirq.pow(c, 2) is not None
assert cirq.inverse(c) is not None
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_parameterize(resolve_fn, global_shift):
parameterized_gate = cirq.PhasedXPowGate(exponent=sympy.Symbol('a'),
phase_exponent=sympy.Symbol('b'),
global_shift=global_shift)
assert cirq.pow(parameterized_gate,
5) == cirq.PhasedXPowGate(exponent=sympy.Symbol('a') * 5,
phase_exponent=sympy.Symbol('b'),
global_shift=global_shift)
assert cirq.unitary(parameterized_gate, default=None) is None
assert cirq.is_parameterized(parameterized_gate)
q = cirq.NamedQubit("q")
parameterized_decomposed_circuit = cirq.Circuit(
cirq.decompose(parameterized_gate(q)))
for resolver in cirq.Linspace('a', 0, 2, 10) * cirq.Linspace(
'b', 0, 2, 10):
resolved_gate = resolve_fn(parameterized_gate, resolver)
assert resolved_gate == cirq.PhasedXPowGate(
exponent=resolver.value_of('a'),
phase_exponent=resolver.value_of('b'),
global_shift=global_shift,
)
np.testing.assert_allclose(
cirq.unitary(resolved_gate(q)),
cirq.unitary(resolve_fn(parameterized_decomposed_circuit,
resolver)),
atol=1e-8,
)
unparameterized_gate = cirq.PhasedXPowGate(exponent=0.1,
phase_exponent=0.2,
global_shift=global_shift)
assert not cirq.is_parameterized(unparameterized_gate)
assert cirq.is_parameterized(unparameterized_gate**sympy.Symbol('a'))
assert cirq.is_parameterized(unparameterized_gate**(sympy.Symbol('a') + 1))
def test_diagonal_exponent(n):
diagonal_angles = _candidate_angles[: 2 ** n]
diagonal_gate = cirq.DiagonalGate(diagonal_angles)
sqrt_diagonal_gate = diagonal_gate ** 0.5
expected_angles = [prime / 2 for prime in diagonal_angles]
np.testing.assert_allclose(expected_angles, sqrt_diagonal_gate._diag_angles_radians, atol=1e-8)
assert cirq.pow(cirq.DiagonalGate(diagonal_angles), "test", None) is None
def test_diagonal_exponent():
diagonal_angles = [2, 3, 5, 7]
diagonal_gate = cirq.TwoQubitDiagonalGate(diagonal_angles)
sqrt_diagonal_gate = diagonal_gate ** 0.5
expected_angles = [prime / 2 for prime in diagonal_angles]
assert cirq.approx_eq(sqrt_diagonal_gate, cirq.TwoQubitDiagonalGate(expected_angles))
assert cirq.pow(cirq.TwoQubitDiagonalGate(diagonal_angles), "test", None) is None
def test_diagonal_exponent():
diagonal_angles = [2, 3, 5, 7, 11, 13, 17, 19]
diagonal_gate = cirq.ThreeQubitDiagonalGate(diagonal_angles)
sqrt_diagonal_gate = diagonal_gate**0.5
expected_angles = [prime / 2 for prime in diagonal_angles]
np.testing.assert_allclose(expected_angles, sqrt_diagonal_gate._diag_angles_radians, atol=1e-8)
assert cirq.pow(cirq.ThreeQubitDiagonalGate(diagonal_angles), "test", None) is None
def test_parameterize():
parameterized_gate = cirq.PhasedXPowGate(exponent=cirq.Symbol('a'),
phase_exponent=cirq.Symbol('b'))
assert cirq.pow(parameterized_gate, 5, default=None) is None
assert cirq.decompose_once_with_qubits(parameterized_gate,
[cirq.LineQubit(0)],
NotImplemented) is NotImplemented
assert cirq.unitary(parameterized_gate, default=None) is None
assert cirq.is_parameterized(parameterized_gate)
resolver = cirq.ParamResolver({'a': 0.1, 'b': 0.2})
resolved_gate = cirq.resolve_parameters(parameterized_gate, resolver)
assert resolved_gate == cirq.PhasedXPowGate(exponent=0.1,
phase_exponent=0.2)
def test_parameterize(resolve_fn):
parameterized_gate = cirq.PhasedXPowGate(exponent=sympy.Symbol('a'),
phase_exponent=sympy.Symbol('b'))
assert cirq.pow(parameterized_gate,
5) == cirq.PhasedXPowGate(exponent=sympy.Symbol('a') * 5,
phase_exponent=sympy.Symbol('b'))
assert (cirq.decompose_once_with_qubits(
parameterized_gate, [cirq.LineQubit(0)], NotImplemented) is
NotImplemented)
assert cirq.unitary(parameterized_gate, default=None) is None
assert cirq.is_parameterized(parameterized_gate)
resolver = cirq.ParamResolver({'a': 0.1, 'b': 0.2})
resolved_gate = resolve_fn(parameterized_gate, resolver)
assert resolved_gate == cirq.PhasedXPowGate(exponent=0.1,
phase_exponent=0.2)
unparameterized_gate = cirq.PhasedXPowGate(exponent=0.1,
phase_exponent=0.2)
assert not cirq.is_parameterized(unparameterized_gate)
assert cirq.is_parameterized(unparameterized_gate**sympy.Symbol('a'))
assert cirq.is_parameterized(unparameterized_gate**(sympy.Symbol('a') + 1))
def test_pow_with_result(val, exponent, out):
assert (cirq.pow(val, exponent) == cirq.pow(val, exponent, default=None) ==
val**exponent == out)
def test_pow_error():
with pytest.raises(TypeError, match="returned NotImplemented"):
_ = cirq.pow(ReturnsNotImplemented(), 3)
with pytest.raises(TypeError, match="no __pow__ method"):
_ = cirq.pow(NoMethod(), 3)
def test_powerless(val):
assert cirq.pow(val, 5, None) is None
assert cirq.pow(val, 2, NotImplemented) is NotImplemented
# Don't assume X**1 == X if X doesn't define __pow__.
assert cirq.pow(val, 1, None) is None
def test_matrix_gate_pow():
t = sympy.Symbol('t')
assert cirq.pow(cirq.MatrixGate(1j * np.eye(1)), t, default=None) is None
assert cirq.pow(cirq.MatrixGate(1j * np.eye(1)),
2) == cirq.MatrixGate(-np.eye(1))
