Add U2 and U3 gates with definitions identical to IBM QisKit

Author: Takishima

projectq/ops/_basics.py

@@ -1,4 +1,4 @@
-#   Copyright 2017 ProjectQ-Framework (www.projectq.ch)
+#   Copyright 2020 ProjectQ-Framework (www.projectq.ch)
 #
 #   Licensed under the Apache License, Version 2.0 (the "License");
 #   you may not use this file except in compliance with the License.
@@ -62,6 +62,22 @@ class NotInvertible(Exception):
     pass
 
 
+def _round_angle(angle, mod_pi):
+    rounded_angle = round(float(angle) % (mod_pi * math.pi), ANGLE_PRECISION)
+    if rounded_angle > mod_pi * math.pi - ANGLE_TOLERANCE:
+        rounded_angle = 0.
+    return rounded_angle
+
+
+def _angle_to_str(angle, symbols):
+    if symbols:
+        return ('{}{}'.format(round(angle / math.pi, 3),
+                              unicodedata.lookup("GREEK SMALL LETTER PI")))
+    else:
+        return "{}".format(angle)
+
+
+
 class BasicGate(object):
     """
     Base class of all gates. (Don't use it directly but derive from it)
@@ -340,10 +356,7 @@ def __init__(self, angle):
             angle (float): Angle of rotation (saved modulo 4 * pi)
         """
         BasicGate.__init__(self)
-        rounded_angle = round(float(angle) % (4. * math.pi), ANGLE_PRECISION)
-        if rounded_angle > 4 * math.pi - ANGLE_TOLERANCE:
-            rounded_angle = 0.
-        self.angle = rounded_angle
+        self.angle = _round_angle(angle, 4)
 
     def __str__(self):
         """
@@ -366,12 +379,8 @@ def to_string(self, symbols=False):
                             more user friendly display if True, full angle
                             written in radian otherwise.
         """
-        if symbols:
-            angle = ("(" + str(round(self.angle / math.pi, 3))
-                     + unicodedata.lookup("GREEK SMALL LETTER PI") + ")")
-        else:
-            angle = "(" + str(self.angle) + ")"
-        return str(self.__class__.__name__) + angle
+        return (str(self.__class__.__name__) + '(' + _angle_to_str(
+            self.angle, symbols) + ')')
 
     def tex_str(self):
         """
@@ -437,6 +446,127 @@ def is_identity(self):
         return self.angle == 0. or self.angle == 4 * math.pi
 
 
+class U3Gate(BasicGate):
+    """
+    Defines a base class for a general unitary single-qubit gate.
+
+    All three angles are continuous parameters. The inverse is the same gate
+    with the negated argument.  Rotation gates of the same class can be merged
+    by adding the angles.  The continuous parameter are modulo 4 * pi.
+    """
+    def __init__(self, theta, phi, lamda):
+        """
+        Initialize a general unitary single-qubit gate.
+
+        Args:
+            theta (float): Angle of rotation (saved modulo 4 * pi)
+            phi (float): Angle of rotation (saved modulo 4 * pi)
+            lamda (float): Angle of rotation (saved modulo 4 * pi)
+        """
+        BasicGate.__init__(self)
+        self.theta = _round_angle(theta, 4)
+        self.phi = _round_angle(phi, 4)
+        self.lamda = _round_angle(lamda, 4)
+
+    def __str__(self):
+        """
+        Return the string representation of a U3Gate.
+
+        Returns the class name and the angle as
+
+        .. code-block:: python
+
+            [CLASSNAME]([ANGLE])
+        """
+        return self.to_string()
+
+    def to_string(self, symbols=False):
+        """
+        Return the string representation of a U3Gate.
+
+        Args:
+            symbols (bool): uses the pi character and round the angle for a
+                            more user friendly display if True, full angle
+                            written in radian otherwise.
+        """
+        return (str(self.__class__.__name__) + '({},{},{})'.format(
+            _angle_to_str(self.theta, symbols),
+            _angle_to_str(self.phi, symbols),
+            _angle_to_str(self.lamda, symbols)))
+
+    def tex_str(self):
+        """
+        Return the Latex string representation of a BasicRotationGate.
+
+        Returns the class name and the angle as a subscript, i.e.
+
+        .. code-block:: latex
+
+            [CLASSNAME]$_[ANGLE]$
+        """
+        return str(self.__class__.__name__) + "$({}\\pi,{}\\pi,{}\\pi)$".format(
+            round(self.theta / math.pi, 3),
+            round(self.phi / math.pi, 3),
+            round(self.lamda / math.pi, 3))
+
+    def get_inverse(self):
+        """
+        Return the inverse of this rotation gate (negate the angle, return new
+        object).
+        """
+        if (self.theta, self.phi, self.lamda) == (0, 0, 0):
+            return self.__class__(0, 0, 0)
+        else:
+            return self.__class__(-self.theta + 4 * math.pi,
+                                  -self.phi + 4 * math.pi,
+                                  -self.lamda + 4 * math.pi)
+
+    def get_merged(self, other):
+        """
+        Return self merged with another gate.
+
+        Default implementation handles rotation gate of the same type, where
+        angles are simply added.
+
+        Args:
+            other: Rotation gate of same type.
+
+        Raises:
+            NotMergeable: For non-rotation gates or rotation gates of
+                different type.
+
+        Returns:
+            New object representing the merged gates.
+        """
+        if isinstance(other, self.__class__):
+            return self.__class__(self.theta + other.theta,
+                                  self.phi + other.phi,
+                                  self.lamda + other.lamda)
+        raise NotMergeable("Can't merge different types of rotation gates.")
+
+    def __eq__(self, other):
+        """ Return True if same class and same rotation angle. """
+        if isinstance(other, self.__class__):
+            return ((self.theta, self.phi, self.lamda)
+                    == (other.theta, other.phi, other.lamda))
+        else:
+            return False
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __hash__(self):
+        return hash(str(self))
+
+    def is_identity(self):
+        """
+        Return True if the gate is equivalent to an Identity gate
+        """
+        return ((self.theta == 0. or self.theta == 4 * math.pi)
+                and (self.phi == 0. or self.phi == 4 * math.pi)
+                and (self.lamda == 0. or self.lamda == 4 * math.pi))
+
+
 class BasicPhaseGate(BasicGate):
     """
     Defines a base class of a phase gate.
@@ -455,10 +585,7 @@ def __init__(self, angle):
             angle (float): Angle of rotation (saved modulo 2 * pi)
         """
         BasicGate.__init__(self)
-        rounded_angle = round(float(angle) % (2. * math.pi), ANGLE_PRECISION)
-        if rounded_angle > 2 * math.pi - ANGLE_TOLERANCE:
-            rounded_angle = 0.
-        self.angle = rounded_angle
+        self.angle = _round_angle(angle, 2)
 
     def __str__(self):
         """

projectq/ops/_basics_test.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-#   Copyright 2017 ProjectQ-Framework (www.projectq.ch)
+#   Copyright 2020 ProjectQ-Framework (www.projectq.ch)
 #
 #   Licensed under the Apache License, Version 2.0 (the "License");
 #   you may not use this file except in compliance with the License.
@@ -204,7 +204,7 @@ def test_basic_rotation_gate_is_identity():
     assert basic_rotation_gate5.is_identity()
 
 
-def test_basic_rotation_gate_comparison_and_hash():
+def test_u3_gate_comparison_and_hash():
     basic_rotation_gate1 = _basics.BasicRotationGate(0.5)
     basic_rotation_gate2 = _basics.BasicRotationGate(0.5)
     basic_rotation_gate3 = _basics.BasicRotationGate(0.5 + 4 * math.pi)
@@ -226,6 +226,100 @@ def test_basic_rotation_gate_comparison_and_hash():
     assert not basic_gate == basic_rotation_gate6
     assert basic_rotation_gate2 != _basics.BasicRotationGate(0.5 + 2 * math.pi)
 
+@pytest.mark.parametrize("input_angle, modulo_angle",
+                         [(2.0, 2.0), (17., 4.4336293856408275),
+                          (-0.5 * math.pi, 3.5 * math.pi), (4 * math.pi, 0)])
+def test_u3_gate_init(input_angle, modulo_angle):
+    # Test internal representation
+    gate = _basics.U3Gate(input_angle, input_angle, input_angle)
+    assert gate.theta == pytest.approx(modulo_angle)
+    assert gate.phi == pytest.approx(modulo_angle)
+    assert gate.lamda == pytest.approx(modulo_angle)
+
+
+def test_u3_gate_str():
+    gate = _basics.U3Gate(math.pi, math.pi, math.pi)
+    assert (str(gate) == "U3Gate(3.14159265359,3.14159265359,3.14159265359)")
+    assert gate.to_string(symbols=True) == u"U3Gate(1.0π,1.0π,1.0π)"
+    assert (gate.to_string(symbols=False) ==
+            "U3Gate(3.14159265359,3.14159265359,3.14159265359)")
+
+
+def test_u3_tex_str():
+    gate = _basics.U3Gate(0.5 * math.pi, 0.5 * math.pi, 0.5 * math.pi)
+    assert gate.tex_str() == "U3Gate$(0.5\\pi,0.5\\pi,0.5\\pi)$"
+    gate = _basics.U3Gate(4 * math.pi - 1e-13,
+                          4 * math.pi - 1e-13,
+                          4 * math.pi - 1e-13)
+    assert gate.tex_str() == "U3Gate$(0.0\\pi,0.0\\pi,0.0\\pi)$"
+
+
+@pytest.mark.parametrize("input_angle, inverse_angle",
+                         [(2.0, -2.0 + 4 * math.pi), (-0.5, 0.5), (0.0, 0)])
+def test_u3_gate_get_inverse(input_angle, inverse_angle):
+    u3_gate = _basics.U3Gate(input_angle, input_angle, input_angle)
+    inverse = u3_gate.get_inverse()
+    assert isinstance(inverse, _basics.U3Gate)
+    assert inverse.theta == pytest.approx(inverse_angle)
+    assert inverse.phi == pytest.approx(inverse_angle)
+    assert inverse.lamda == pytest.approx(inverse_angle)
+
+
+def test_u3_gate_get_merged():
+    basic_gate = _basics.BasicGate()
+    u3_gate1 = _basics.U3Gate(0.5, 0.5, 0.5)
+    u3_gate2 = _basics.U3Gate(1.0, 1.0, 1.0)
+    u3_gate3 = _basics.U3Gate(1.5, 1.5, 1.5)
+    with pytest.raises(_basics.NotMergeable):
+        u3_gate1.get_merged(basic_gate)
+    merged_gate = u3_gate1.get_merged(u3_gate2)
+    assert merged_gate == u3_gate3
+
+
+def test_u3_gate_is_identity():
+    u3_gate1 = _basics.U3Gate(0., 0., 0.)
+    u3_gate2 = _basics.U3Gate(
+        1. * math.pi, 1. * math.pi, 1. * math.pi)
+    u3_gate3 = _basics.U3Gate(
+        2. * math.pi, 2. * math.pi, 2. * math.pi)
+    u3_gate4 = _basics.U3Gate(
+        3. * math.pi, 3. * math.pi, 3. * math.pi)
+    u3_gate5 = _basics.U3Gate(
+        4. * math.pi, 4. * math.pi, 4. * math.pi)
+    assert u3_gate1.is_identity()
+    assert not u3_gate2.is_identity()
+    assert not u3_gate3.is_identity()
+    assert not u3_gate4.is_identity()
+    assert u3_gate5.is_identity()
+
+
+def test_u3_gate_comparison_and_hash():
+    u3gate1 = _basics.U3Gate(0.5, 0.5, 0.5)
+    u3gate2 = _basics.U3Gate(0.5, 0.5, 0.5)
+    u3gate3 = _basics.U3Gate(
+        0.5 + 4 * math.pi, 0.5 + 4 * math.pi, 0.5 + 4 * math.pi)
+    assert u3gate1 == u3gate2
+    assert hash(u3gate1) == hash(u3gate2)
+    assert u3gate1 == u3gate3
+    assert hash(u3gate1) == hash(u3gate3)
+    u3gate4 = _basics.U3Gate(0.50000001, 0.50000001, 0.50000001)
+    # Test __ne__:
+    assert u3gate4 != u3gate1
+    # Test one gate close to 4*pi the other one close to 0
+    u3gate5 = _basics.U3Gate(1.e-13, 1.e-13, 1.e-13)
+    u3gate6 = _basics.U3Gate(4 * math.pi - 1.e-13,
+                             4 * math.pi - 1.e-13,
+                             4 * math.pi - 1.e-13)
+    assert u3gate5 == u3gate6
+    assert u3gate6 == u3gate5
+    assert hash(u3gate5) == hash(u3gate6)
+    # Test different types of gates
+    basic_gate = _basics.BasicGate()
+    assert not basic_gate == u3gate6
+    assert u3gate2 != _basics.U3Gate(0.5 + 2 * math.pi,
+                                     0.5 + 2 * math.pi,
+                                     0.5 + 2 * math.pi)
+
 
 @pytest.mark.parametrize("input_angle, modulo_angle",
                          [(2.0, 2.0), (17., 4.4336293856408275),

projectq/ops/_gates.py

@@ -1,4 +1,4 @@
-#   Copyright 2017 ProjectQ-Framework (www.projectq.ch)
+#   Copyright 2020 ProjectQ-Framework (www.projectq.ch)
 #
 #   Licensed under the Apache License, Version 2.0 (the "License");
 #   you may not use this file except in compliance with the License.
@@ -52,6 +52,7 @@
                       MatrixGate,
                       SelfInverseGate,
                       BasicRotationGate,
+                      U3Gate,
                       BasicPhaseGate,
                       ClassicalInstructionGate,
                       FastForwardingGate,
@@ -245,6 +246,18 @@ def matrix(self):
                           [0, cmath.exp(.5 * 1j * self.angle)]])
 
 
+class U3(U3Gate):
+    @property
+    def matrix(self):
+        return np.matrix([[cmath.exp(-.5j * (self.phi + self.lamda)) + math.cos(.5* self.theta),
+                           -cmath.exp(-.5j * (self.phi - self.lamda)) + math.sin(.5* self.theta)],
+                          [cmath.exp(.5j * (self.phi - self.lamda)) + math.sin(.5* self.theta),
+                           cmath.exp(.5j * (self.phi + self.lamda)) + math.cos(.5* self.theta)]])
+
+class U2(U3):
+    def __init__(self, phi, lamda):
+        super().__init__(math.pi/2, phi, lamda)
+
 class Rxx(BasicRotationGate):
     """ RotationXX gate class """
     @property

projectq/ops/_gates_test.py

@@ -1,4 +1,4 @@
-#   Copyright 2017 ProjectQ-Framework (www.projectq.ch)
+#   Copyright 2020 ProjectQ-Framework (www.projectq.ch)
 #
 #   Licensed under the Apache License, Version 2.0 (the "License");
 #   you may not use this file except in compliance with the License.
@@ -156,6 +156,30 @@ def test_rz(angle):
     assert np.allclose(gate.matrix, expected_matrix)
 
 
+@pytest.mark.parametrize("angle", [0, 0.2, 2.1, 4.1, 2 * math.pi,
+                                   4 * math.pi])
+def test_u3(angle):
+    gate = _gates.U3(angle, angle, angle)
+    expected_matrix = np.matrix([[cmath.exp(-1j * angle) + math.cos(.5 * angle),
+                           -1 + math.sin(.5 * angle)],
+                          [1 + math.sin(.5 * angle),
+                           cmath.exp(1j * angle) + math.cos(.5 * angle)]])
+    assert gate.matrix.shape == expected_matrix.shape
+    assert np.allclose(gate.matrix, expected_matrix)
+
+
+@pytest.mark.parametrize("angle", [0, 0.2, 2.1, 4.1, 2 * math.pi,
+                                   4 * math.pi])
+def test_u2(angle):
+    gate = _gates.U2(angle, angle)
+    expected_matrix = np.matrix([[cmath.exp(-1j * angle) + math.cos(.25 * math.pi),
+                           -1 + math.sin(.25 * math.pi)],
+                          [1 + math.sin(.25 * math.pi),
+                           cmath.exp(1j * angle) + math.cos(.25 * math.pi)]])
+    assert gate.matrix.shape == expected_matrix.shape
+    assert np.allclose(gate.matrix, expected_matrix)
+
+
 @pytest.mark.parametrize("angle", [0, 0.2, 2.1, 4.1, 2 * math.pi,
                                    4 * math.pi])
 def test_rxx(angle):