def test_kak_decomposition_eq():
eq = cirq.testing.EqualsTester()
eq.make_equality_group(lambda: cirq.KakDecomposition(
global_phase=1,
single_qubit_operations_before=(cirq.unitary(cirq.X),
cirq.unitary(cirq.Y)),
interaction_coefficients=(0.3, 0.2, 0.1),
single_qubit_operations_after=(np.eye(2), cirq.unitary(cirq.Z)),
))
eq.add_equality_group(cirq.KakDecomposition(
global_phase=-1,
single_qubit_operations_before=(cirq.unitary(cirq.X),
cirq.unitary(cirq.Y)),
interaction_coefficients=(0.3, 0.2, 0.1),
single_qubit_operations_after=(np.eye(2), cirq.unitary(cirq.Z)),
))
eq.make_equality_group(lambda: cirq.KakDecomposition(
global_phase=1,
single_qubit_operations_before=(cirq.unitary(cirq.X),
cirq.unitary(cirq.H)),
interaction_coefficients=(0.3, 0.2, 0.1),
single_qubit_operations_after=(np.eye(2), cirq.unitary(cirq.Z)),
))
eq.make_equality_group(lambda: cirq.KakDecomposition(
global_phase=1,
single_qubit_operations_before=(cirq.unitary(cirq.X),
cirq.unitary(cirq.Y)),
interaction_coefficients=(0.5, 0.2, 0.1),
single_qubit_operations_after=(np.eye(2), cirq.unitary(cirq.Z)),
))
def test_kak_repr():
cirq.testing.assert_equivalent_repr(
cirq.KakDecomposition(
global_phase=1j,
single_qubit_operations_before=(cirq.unitary(cirq.X),
cirq.unitary(cirq.Y)),
interaction_coefficients=(0.3, 0.2, 0.1),
single_qubit_operations_after=(np.eye(2), cirq.unitary(cirq.Z)),
))
assert repr(
cirq.KakDecomposition(
global_phase=1,
single_qubit_operations_before=(cirq.unitary(cirq.X),
cirq.unitary(cirq.Y)),
interaction_coefficients=(0.5, 0.25, 0),
single_qubit_operations_after=(np.eye(2), cirq.unitary(cirq.Z)),
)) == """
cirq.KakDecomposition(
interaction_coefficients=(0.5, 0.25, 0),
single_qubit_operations_before=(
np.array([[0j, (1+0j)], [(1+0j), 0j]], dtype=np.complex128),
np.array([[0j, -1j], [1j, 0j]], dtype=np.complex128),
),
single_qubit_operations_after=(
np.array([[1.0, 0.0], [0.0, 1.0]], dtype=np.float64),
np.array([[(1+0j), 0j], [0j, (-1+0j)]], dtype=np.complex128),
),
global_phase=1)
""".strip()
def test_kak_canonicalize_vector(x, y, z):
i = np.eye(2)
m = cirq.unitary(
cirq.KakDecomposition(
global_phase=1,
single_qubit_operations_after=(i, i),
interaction_coefficients=(x, y, z),
single_qubit_operations_before=(i, i),
))
kak = cirq.kak_canonicalize_vector(x, y, z, atol=1e-10)
a1, a0 = kak.single_qubit_operations_after
x2, y2, z2 = kak.interaction_coefficients
b1, b0 = kak.single_qubit_operations_before
m2 = cirq.unitary(kak)
assert 0.0 <= x2 <= np.pi / 4
assert 0.0 <= y2 <= np.pi / 4
assert -np.pi / 4 < z2 <= np.pi / 4
assert abs(x2) >= abs(y2) >= abs(z2)
assert x2 < np.pi / 4 - 1e-10 or z2 >= 0
assert cirq.is_special_unitary(a1)
assert cirq.is_special_unitary(a0)
assert cirq.is_special_unitary(b1)
assert cirq.is_special_unitary(b0)
assert np.allclose(m, m2)
def test_kak_str():
v = cirq.KakDecomposition(
interaction_coefficients=(0.3 * np.pi / 4, 0.2 * np.pi / 4,
0.1 * np.pi / 4),
single_qubit_operations_before=(cirq.unitary(cirq.I),
cirq.unitary(cirq.X)),
single_qubit_operations_after=(cirq.unitary(cirq.Y),
cirq.unitary(cirq.Z)),
global_phase=1j)
assert str(v) == """KAK {
def random_locals(x, y, z, seed=None):
rng = np.random.RandomState(seed)
a0 = cirq.testing.random_unitary(2, random_state=rng)
a1 = cirq.testing.random_unitary(2, random_state=rng)
b0 = cirq.testing.random_unitary(2, random_state=rng)
b1 = cirq.testing.random_unitary(2, random_state=rng)
return cirq.unitary(
cirq.KakDecomposition(
interaction_coefficients=(x, y, z),
single_qubit_operations_before=(a0, a1),
single_qubit_operations_after=(b0, b1),
))
def test_kak_str():
v = cirq.KakDecomposition(
interaction_coefficients=(0.3 * np.pi / 4, 0.2 * np.pi / 4,
0.1 * np.pi / 4),
single_qubit_operations_before=(cirq.unitary(cirq.I),
cirq.unitary(cirq.X)),
single_qubit_operations_after=(cirq.unitary(cirq.Y),
cirq.unitary(cirq.Z)),
global_phase=1j,
)
assert (str(v) == """KAK {
xyz*(4/π): 0.3, 0.2, 0.1
before: (0*π around X) ⊗ (1*π around X)
after: (1*π around Y) ⊗ (1*π around Z)
}""")
def test_kak_vector_on_weyl_chamber_face():
# unitaries with KAK vectors from I to ISWAP
theta_swap = np.linspace(0, np.pi / 4, 10)
k_vecs = np.zeros((10, 3))
k_vecs[:, (0, 1)] = theta_swap[:, np.newaxis]
kwargs = dict(global_phase=1j,
single_qubit_operations_before=(X, Y),
single_qubit_operations_after=(Z, 1j * X))
unitaries = np.array([
cirq.unitary(
cirq.KakDecomposition(interaction_coefficients=(t, t, 0),
**kwargs)) for t in theta_swap
])
actual = cirq.kak_vector(unitaries)
np.testing.assert_almost_equal(actual, k_vecs)
def perturbations_unitary(u, amount=1e-10):
"""Returns several unitaries in the neighborhood of u to test for numerical
corner cases near critical values."""
kak = cirq.kak_decomposition(u)
yield u
for i in range(3):
for neg in (-1, 1):
perturb_xyz = list(kak.interaction_coefficients)
perturb_xyz[i] += neg * amount
yield cirq.unitary(
cirq.KakDecomposition(
global_phase=kak.global_phase,
single_qubit_operations_before=kak.single_qubit_operations_before,
single_qubit_operations_after=kak.single_qubit_operations_after,
interaction_coefficients=tuple(perturb_xyz),
)
)
def perturbations_weyl(x, y, z, amount=1e-10):
return perturbations_gate(
cirq.KakDecomposition(interaction_coefficients=(x, y, z), ),
amount,
)
