Ejemplo n.º 1
0
def test_gate_from_info():
    assert (_rotations._ROTATION_GATE_FROM_INFO["X"](cmath.pi / 4) == gates.Rx(
        cmath.pi / 4))
    assert (_rotations._ROTATION_GATE_FROM_INFO["Y"](cmath.pi / 2) == gates.Ry(
        cmath.pi / 2))
    assert (_rotations._ROTATION_GATE_FROM_INFO["Z"](cmath.pi) == gates.Rz(
        cmath.pi))
    return
Ejemplo n.º 2
0
    def visit_R(self, node, params):
        # type parameter
        t = params[0]
        typ = round(float(t))
        # other params
        angle = params[2]
        q = params[4]

        # different angle convention
        angle = -angle

        # differentiate with type
        if typ == 1:
            return (ops.Rx(angle), (q, ))
        elif typ == 2:
            return (ops.Ry(angle), (q, ))
        elif typ == 3:
            return (ops.Rz(angle), (q, ))
        else:
            raise InvalidRotationGateError
Ejemplo n.º 3
0
def test_gate_to_info():
    gate = gates.Rx(cmath.pi / 4)
    info = _rotations._ROTATION_GATE_TO_INFO[type(gate)](gate)
    assert (info[:2] == [[(0, "X")], "pi4"])
    assert (abs(info[2] - (cmath.pi / 4)) < _PRECISION)

    gate = gates.Ry(cmath.pi / 2)
    info = _rotations._ROTATION_GATE_TO_INFO[type(gate)](gate)
    assert (info[:2] == [[(0, "Y")], "pi2"])
    assert (abs(info[2] - (cmath.pi / 2)) < _PRECISION)

    gate = gates.Rz(cmath.pi)
    info = _rotations._ROTATION_GATE_TO_INFO[type(gate)](gate)
    assert (info[:2] == [[(0, "Z")], "pi"])
    assert (abs(info[2] - (cmath.pi)) < _PRECISION)

    gate = gates.TimeEvolution(-cmath.pi / 8, gates.QubitOperator("X0 X1 Y2"))
    info = _rotations._ROTATION_GATE_TO_INFO[type(gate)](gate)
    assert (info[:2] == [[(0, "X"), (1, "X"), (2, "Y")], "pi4"])
    assert (abs(info[2] - (cmath.pi / 4)) < _PRECISION)
    return
Ejemplo n.º 4
0
def test_Ry(benchmark, nbit):
    run_bench(benchmark, ops.Ry(0.5), 2, nbit)
Ejemplo n.º 5
0
_ROTATION_GATE_TO_INFO = {
	gates.XGate: lambda gate: [[(0,"X")], "pi", cmath.pi],
	gates.YGate: lambda gate: [[(0,"Y")], "pi", cmath.pi],
	gates.ZGate: lambda gate: [[(0,"Z")], "pi", cmath.pi],
	gates.SGate: lambda gate: [[(0,"Z")], "pi2", cmath.pi/2],
	gates.TGate: lambda gate: [[(0,"Z")], "pi4", cmath.pi/4],
	gates.Rx: lambda gate: [[(0,"X")]] + determine_rotation(gate),
	gates.Ry: lambda gate: [[(0,"Y")]] + determine_rotation(gate),
	gates.Rz: lambda gate: [[(0,"Z")]] + determine_rotation(gate),
	gates.TimeEvolution: lambda gate: time_evolution_info(gate),
}

_ROTATION_GATE_FROM_INFO = {
	"X" : lambda angle: gates.Rx(angle),
	"Y" : lambda angle: gates.Ry(angle),
	"Z" : lambda angle: gates.Rz(angle)
}



#
# This lookup table implemets the following commutation relations relation
# (1) P * P'(phi) = P'(phi) * P
# (2) P'(phi) * P = P * P'(-phi)
# (3) P(pi/2) * P'(phi) = (i P P')(phi) * P(pi/2)
# (4) P'(phi) * P(pi/2) = P(pi/2) * (i P P')(-phi)
# 
# Here, P and P' are bases for one of the Pauli-rotations (Rx, Ry, Rz).
# The angle pi/2 indicates S gates, phi is arbitrary and if the angle is omitted,
# a standard Pauli operator (angle = pi) is used.