Add FSIM, PHASEDFSIM, RZZ, RXX, RYY to stdgates.quil #325

[bramathon]

QVM: quil-lang/qvm#325
QuilC: quil-lang/quilc#930

DEFGATE FSIM(%theta, %phi):
    1, 0,               0,               0
    0, cos(%theta/2),   i*sin(%theta/2), 0
    0, i*sin(%theta/2), cos(%theta/2),   0
    0, 0,               0,               cis(%phi)

DEFGATE PHASEDFSIM(%theta, %zeta, %chi, %gamma, %phi):
    1, 0,                                       0,                                       0
    0, cis(-%gamma - %zeta)*cos(%theta/2),  i*cis(%chi - %gamma)*sin(%theta/2), 0
    0, i*cis(-%gamma - %chi)*sin(%theta/2), cis(%zeta - %gamma)*cos(%theta/2),  0
    0, 0,                                       0,                                       cis(%phi - 2*%gamma)

DEFGATE RZZ(%phi):
    cis(-%phi/2), 0,             0,             0
    0,              cis(%phi/2), 0,             0
    0,              0,             cis(%phi/2), 0
    0,              0,             0,             cis(-%phi/2)

DEFGATE RXX(%phi):
    cos(%phi/2),    0,              0,              -i*sin(%phi/2)
    0,              cos(%phi/2),    -i*sin(%phi/2), 0
    0,              -i*sin(%phi/2), cos(%phi/2),    0
    -i*sin(%phi/2), 0,              0,              cos(%phi/2)

DEFGATE RYY(%phi):
    cos(%phi/2),    0,              0,              i*sin(%phi/2)
    0,              cos(%phi/2),    -i*sin(%phi/2), 0
    0,              -i*sin(%phi/2), cos(%phi/2),    0
    i*sin(%phi/2), 0,              0,              cos(%phi/2)

[bramathon]

The definitions of RZZ, RXX and RYY are standard and followed exactly.

The definition of FSIM and PHASEDFSIM is a bit unusual. Here is how I arrived at it.

The XY and CPHASE gates can be written as the exponentiation of Pauli sums. Specifically, XY(𝜃) = exp(-i𝜋 (-𝜃/4𝜋) (X0 ⊗ Y1 + Y0 ⊗ X1)) and CPHASE(𝜙) is exp(-i𝜋 (-𝜙/4𝜋) * (Z0 ⊗ Z1 - Z0 - Z1)). Thus, FSIM(𝜃, 𝜙) = ISWAP(𝜃) CPHASE(𝜙).

The downside is that this differs slightly form other definitions. For example, Cirq uses the definition (note the signs on the off-diagonal terms, the lack of the 1/2 factor on theta and the sign of the conditional phase term).

DEFGATE FSIM(%theta, %phi):
    1, 0,               0,               0
    0, cos(%theta),   -i*sin(%theta), 0
    0, -i*sin(%theta), cos(%theta),   0
    0, 0,               0,               cis(-%phi)

Nonetheless, maintaining logical coherence within the gate set seems more important than matching with Cirq.

However,
The above exponentiation can be checked in python using this snippet.

import numpy as np
from pyquil.paulis import sZ, sX, sY, exponentiate_pauli_sum
from pyquil.simulation import matrices

# exponentiate_pauli_sum is exp(-i𝜋 * P_i)

def unitary_close(u, v):
    """Check that the unitaries are close."""
    assert u.shape == v.shape
    dim = u.shape[0]
    return np.isclose(np.abs(np.trace(u @ v.conj().T)) / dim, 1.0)

# CZ is exp(i * 𝜋/4 * Z0 ⊗ Z1 - Z0 - Z1)
CZ = exponentiate_pauli_sum(-0.25*(sZ(0) * sZ(1) - sZ(0) - sZ(1)))
assert unitary_close(matrices.CZ, CZ)

# ISWAP is exp(i * 𝜋/4 * X0 ⊗ X1 + Y0 ⊗ Y1)
ISWAP = exponentiate_pauli_sum(-0.25*(sX(0) * sX(1) + sY(0) * sY(1)))
assert unitary_close(matrices.ISWAP, ISWAP)

# CPHASE(phi) is exp((-phi/4𝜋) * -i * 𝜋 * Z0 ⊗ Z1 - Z0 - Z1)
phi = 0.3*np.pi
CPHASE = exponentiate_pauli_sum((-phi/(4*np.pi))*(sZ(0) * sZ(1) - sZ(0) - sZ(1)))
assert unitary_close(matrices.CPHASE(phi), CPHASE)

# XY(theta) is exp((-theta/4𝜋) * -i * 𝜋 * X0 ⊗ Y1 + Y0 ⊗ X1)
theta = 0.3*np.pi
XY = exponentiate_pauli_sum((-theta/(4*np.pi))*(sX(0) * sX(1) + sY(0) * sY(1)))
assert unitary_close(matrices.XY(theta), XY)

# FSIM(theta, phi) is exp((-i*𝜋) * (-theta/4𝜋) * (X0 ⊗ Y1 + Y0 ⊗ X1) + (-i*𝜋) * (-phi/4𝜋) * (Z0 ⊗ Z1))
phi = 0.2*np.pi
theta = 0.4*np.pi
FSIM = exponentiate_pauli_sum((-theta/(4*np.pi))*(sX(0) * sX(1) + sY(0) * sY(1)) + (-phi/(4*np.pi))*(sZ(0) * sZ(1) - sZ(0) - sZ(1)))
assert unitary_close(matrices.FSIM(theta, phi), FSIM)