Trapped ion decomposer setup and rotation gates improvement

docs/projectq.setups.decompositions.rst

@@ -10,16 +10,19 @@ The decomposition package is a collection of gate decomposition / replacement ru
     projectq.setups.decompositions.barrier
     projectq.setups.decompositions.carb1qubit2cnotrzandry
     projectq.setups.decompositions.cnot2cz
+    projectq.setups.decompositions.cnot2rxx
     projectq.setups.decompositions.cnu2toffoliandcu
     projectq.setups.decompositions.crz2cxandrz
     projectq.setups.decompositions.entangle
     projectq.setups.decompositions.globalphase
+    projectq.setups.decompositions.h2rx
     projectq.setups.decompositions.ph2r
     projectq.setups.decompositions.qft2crandhadamard
     projectq.setups.decompositions.qubitop2onequbit
     projectq.setups.decompositions.r2rzandph
     projectq.setups.decompositions.rx2rz
     projectq.setups.decompositions.ry2rz
+    projectq.setups.decompositions.rz2rx
     projectq.setups.decompositions.sqrtswap2cnot
     projectq.setups.decompositions.stateprep2cnot
     projectq.setups.decompositions.swap2cnot
@@ -62,6 +65,13 @@ projectq.setups.decompositions.cnot2cz module
     :members:
     :undoc-members:
 
+projectq.setups.decompositions.cnot2rxx module
+---------------------------------------------
+
+.. automodule:: projectq.setups.decompositions.cnot2rxx
+    :members:
+    :undoc-members:
+
 projectq.setups.decompositions.cnu2toffoliandcu module
 ------------------------------------------------------
 
@@ -90,7 +100,8 @@ projectq.setups.decompositions.globalphase module
     :members:
     :undoc-members:
 
-projectq.setups.decompositions.ph2r module
+
+projectq.setups.decompositions.h2rx module
 ------------------------------------------
 
 .. automodule:: projectq.setups.decompositions.ph2r
@@ -132,6 +143,13 @@ projectq.setups.decompositions.ry2rz module
     :members:
     :undoc-members:
 
+projectq.setups.decompositions.rz2rx module
+-------------------------------------------
+
+.. automodule:: projectq.setups.decompositions.rz2rx
+    :members:
+    :undoc-members:
+
 projectq.setups.decompositions.sqrtswap2cnot module
 ---------------------------------------------------
 

docs/projectq.setups.rst

@@ -86,6 +86,13 @@ restrictedgateset
     :special-members: __init__
     :undoc-members:
 
+trapped_ion_decomposer
+----------------------
+.. automodule:: projectq.setups.trapped_ion_decomposer
+    :members:
+    :special-members: __init__
+    :undoc-members:
+
 Module contents
 ---------------
 

projectq/cengines/_optimize.py

@@ -116,7 +116,7 @@ def _get_gate_indices(self, idx, i, IDs):
 
     def _optimize(self, idx, lim=None):
         """
-        Try to merge or even cancel successive gates using the get_merged and
+        Try to remove identity gates using the is_identity function, then merge or even cancel successive gates using the get_merged and
         get_inverse functions of the gate (see, e.g., BasicRotationGate).
 
         It does so for all qubit command lists.
@@ -130,6 +130,23 @@ def _optimize(self, idx, lim=None):
             new_gateloc = limit
 
         while i < limit - 1:
+            # can be dropped if the gate is equivalent to an identity gate
+            try:
+                if self._l[idx][i].is_identity():
+                    # determine index of this gate on all qubits
+                    qubitids = [qb.id for sublist in self._l[idx][i].all_qubits
+                                for qb in sublist]
+                    gid = self._get_gate_indices(idx, i, qubitids)
+                    for j in range(len(qubitids)):
+                        new_list = (self._l[qubitids[j]][0:gid[j]] +
+                                    self._l[qubitids[j]][gid[j] +1:])
+                        self._l[qubitids[j]] = new_list
+                    i = 0
+                    limit -= 1
+                    continue
+            except:
+                pass
+
             # can be dropped if two in a row are self-inverses
             inv = self._l[idx][i].get_inverse()
 

projectq/cengines/_optimize_test.py

@@ -127,3 +127,21 @@ def test_local_optimizer_mergeable_gates():
     # Expect allocate, one Rx gate, and flush gate
     assert len(backend.received_commands) == 3
     assert backend.received_commands[1].gate == Rx(10 * 0.5)
+
+def test_local_optimizer_identity_gates():
+    local_optimizer = _optimize.LocalOptimizer(m=4)
+    backend = DummyEngine(save_commands=True)
+    eng = MainEngine(backend=backend, engine_list=[local_optimizer])
+    # Test that it merges mergeable gates such as Rx
+    qb0 = eng.allocate_qubit()
+    for _ in range(10):
+        Rx(0.0) | qb0
+        Ry(0.0) | qb0
+        Rx(2*math.pi) | qb0
+        Ry(2*math.pi) | qb0
+    Rx(0.5) | qb0
+    assert len(backend.received_commands) == 0
+    eng.flush()
+    # Expect allocate, one Rx gate, and flush gate
+    assert len(backend.received_commands) == 3
+    assert backend.received_commands[1].gate == Rx(0.5)

projectq/cengines/_replacer/_replacer.py

@@ -175,7 +175,6 @@ def _process_command(self, cmd):
 
             # use decomposition chooser to determine the best decomposition
             chosen_decomp = self._decomp_chooser(cmd, decomp_list)
-
             # the decomposed command must have the same tags
             # (plus the ones it gets from meta-statements inside the
             # decomposition rule).

projectq/ops/__init__.py

@@ -25,6 +25,7 @@
 from ._command import apply_command, Command
 from ._metagates import (DaggeredGate,
                          get_inverse,
+                         is_identity,
                          ControlledGate,
                          C,
                          Tensor,

projectq/ops/_basics.py

@@ -40,6 +40,8 @@
 from ._command import Command, apply_command
 
 
+import unicodedata
+
 ANGLE_PRECISION = 12
 ANGLE_TOLERANCE = 10 ** -ANGLE_PRECISION
 RTOL = 1e-10
@@ -227,6 +229,9 @@ def __str__(self):
     def __hash__(self):
         return hash(str(self))
 
+    def is_identity(self):
+        return False
+
 
 class MatrixGate(BasicGate):
     """
@@ -317,19 +322,19 @@ class BasicRotationGate(BasicGate):
     A rotation gate has a continuous parameter (the angle), labeled 'angle' /
     self.angle. Its 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 is modulo 4 * pi, self.angle is in the interval
-    [0, 4 * pi).
+    The continuous parameter is modulo 2 * pi, self.angle is in the interval
+    [0, 2 * pi).
     """
     def __init__(self, angle):
         """
         Initialize a basic rotation gate.
 
         Args:
-            angle (float): Angle of rotation (saved modulo 4 * pi)
+            angle (float): Angle of rotation (saved modulo 2 * pi)
         """
         BasicGate.__init__(self)
-        rounded_angle = round(float(angle) % (4. * math.pi), ANGLE_PRECISION)
-        if rounded_angle > 4 * math.pi - ANGLE_TOLERANCE:
+        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
 
@@ -343,7 +348,7 @@ def __str__(self):
 
             [CLASSNAME]([ANGLE])
         """
-        return str(self.__class__.__name__) + "(" + str(self.angle) + ")"
+        return str(self.__class__.__name__) + "(" + str(round(self.angle/math.pi,3)) +unicodedata.lookup("GREEK SMALL LETTER PI")+ ")"
 
     def tex_str(self):
         """
@@ -355,7 +360,7 @@ def tex_str(self):
 
             [CLASSNAME]$_[ANGLE]$
         """
-        return str(self.__class__.__name__) + "$_{" + str(self.angle) + "}$"
+        return str(self.__class__.__name__) + "$_{" + str(round(self.angle/math.pi,3)) + "\pi}$"
 
     def get_inverse(self):
         """
@@ -365,7 +370,7 @@ def get_inverse(self):
         if self.angle == 0:
             return self.__class__(0)
         else:
-            return self.__class__(-self.angle + 4 * math.pi)
+            return self.__class__(-self.angle + 2 * math.pi)
 
     def get_merged(self, other):
         """
@@ -401,6 +406,12 @@ def __ne__(self, 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.angle == 0. or self.angle==2*math.pi
+
 
 class BasicPhaseGate(BasicGate):
     """

projectq/ops/_basics_test.py

@@ -163,15 +163,15 @@ def test_basic_rotation_gate_init(input_angle, modulo_angle):
 
 
 def test_basic_rotation_gate_str():
-    basic_rotation_gate = _basics.BasicRotationGate(0.5)
-    assert str(basic_rotation_gate) == "BasicRotationGate(0.5)"
+    basic_rotation_gate = _basics.BasicRotationGate(0.5*math.pi)
+    assert str(basic_rotation_gate) == "BasicRotationGate(0.5π)"
 
 
 def test_basic_rotation_tex_str():
-    basic_rotation_gate = _basics.BasicRotationGate(0.5)
-    assert basic_rotation_gate.tex_str() == "BasicRotationGate$_{0.5}$"
+    basic_rotation_gate = _basics.BasicRotationGate(0.5*math.pi)
+    assert basic_rotation_gate.tex_str() == "BasicRotationGate$_{0.5\pi}$"
     basic_rotation_gate = _basics.BasicRotationGate(4 * math.pi - 1e-13)
-    assert basic_rotation_gate.tex_str() == "BasicRotationGate$_{0.0}$"
+    assert basic_rotation_gate.tex_str() == "BasicRotationGate$_{0.0\pi}$"
 
 
 @pytest.mark.parametrize("input_angle, inverse_angle",
@@ -193,6 +193,14 @@ def test_basic_rotation_gate_get_merged():
     merged_gate = basic_rotation_gate1.get_merged(basic_rotation_gate2)
     assert merged_gate == basic_rotation_gate3
 
+def test_basic_rotation_gate_is_identity():
+    basic_gate = _basics.BasicGate()
+    basic_rotation_gate1 = _basics.BasicRotationGate(0.)
+    basic_rotation_gate2 = _basics.BasicRotationGate(1.0*math.pi)
+    basic_rotation_gate3 = _basics.BasicRotationGate(2.*math.pi)
+    assert 1 == basic_rotation_gate1.is_identity()
+    assert 0 == basic_rotation_gate2.is_identity()
+    assert 1 == basic_rotation_gate3.is_identity()
 
 def test_basic_rotation_gate_comparison_and_hash():
     basic_rotation_gate1 = _basics.BasicRotationGate(0.5)

projectq/ops/_command.py

@@ -149,6 +149,14 @@ def get_inverse(self):
                        list(self.control_qubits),
                        deepcopy(self.tags))
 
+    def is_identity(self):
+        """
+        Evaluate if the gate called in the command object is an identity gate.
+
+        Returns: True if the gate is equivalent to an Identity gate, False otherwise
+        """
+        return projectq.ops.is_identity(self.gate)
+
     def get_merged(self, other):
         """
         Merge this command with another one and return the merged command

projectq/ops/_command_test.py

@@ -132,6 +132,18 @@ def test_command_get_merged(main_engine):
     with pytest.raises(NotMergeable):
         cmd.get_merged(cmd4)
 
+def test_command_is_identity(main_engine):
+    qubit = main_engine.allocate_qubit()
+    qubit2 = main_engine.allocate_qubit()
+    cmd = _command.Command(main_engine, Rx(0.), (qubit,))
+    cmd2= _command.Command(main_engine, Rx(0.5), (qubit2,))
+    inverse_cmd = cmd.get_inverse()
+    inverse_cmd2 = cmd2.get_inverse()
+    assert inverse_cmd.gate.is_identity()
+    assert cmd.gate.is_identity()
+    assert inverse_cmd2.gate.is_identity()==False
+    assert cmd2.gate.is_identity()==False
+
 
 def test_command_order_qubits(main_engine):
     qubit0 = Qureg([Qubit(main_engine, 0)])
@@ -232,9 +244,9 @@ def test_command_comparison(main_engine):
 def test_command_str():
     qubit = Qureg([Qubit(main_engine, 0)])
     ctrl_qubit = Qureg([Qubit(main_engine, 1)])
-    cmd = _command.Command(main_engine, Rx(0.5), (qubit,))
+    cmd = _command.Command(main_engine, Rx(0.5*math.pi), (qubit,))
     cmd.tags = ["TestTag"]
     cmd.add_control_qubits(ctrl_qubit)
-    assert str(cmd) == "CRx(0.5) | ( Qureg[1], Qureg[0] )"
-    cmd2 = _command.Command(main_engine, Rx(0.5), (qubit,))
-    assert str(cmd2) == "Rx(0.5) | Qureg[0]"
+    assert str(cmd) == "CRx(0.5π) | ( Qureg[1], Qureg[0] )"
+    cmd2 = _command.Command(main_engine, Rx(0.5*math.pi), (qubit,))
+    assert str(cmd2) == "Rx(0.5π) | Qureg[0]"

projectq/ops/_metagates.py

@@ -132,6 +132,25 @@ def get_inverse(gate):
     except NotInvertible:
         return DaggeredGate(gate)
 
+def is_identity(gate):
+    """
+    Return True if the gate is an identity gate.
+
+    Tries to call gate.is_identity and, upon failure, returns False
+
+    Args:
+        gate: Gate of which to get the inverse
+
+    Example:
+        .. code-block:: python
+
+            get_inverse(Rx(2*math.pi)) # returns True
+            get_inverse(Rx(math.pi)) # returns False
+    """
+    try:
+        return gate.is_identity()
+    except :
+        return False
 
 class ControlledGate(BasicGate):
     """

projectq/ops/_metagates_test.py

@@ -122,6 +122,16 @@ def test_get_inverse():
     inv2 = _metagates.get_inverse(invertible_gate)
     assert inv2 == Y
 
+def test_is_identity():
+    # Choose gate which is not an identity gate:
+    non_identity_gate=Rx(0.5)
+    assert non_identity_gate.is_identity()==False
+    assert _metagates.is_identity(non_identity_gate) ==False   
+    # Choose gate which is an identity gate:
+    identity_gate=Rx(0.)
+    assert identity_gate.is_identity()==True
+    assert _metagates.is_identity(identity_gate) == True
+
 
 def test_controlled_gate_init():
     one_control = _metagates.ControlledGate(Y, 1)

projectq/setups/decompositions/__init__.py

@@ -17,15 +17,18 @@
                carb1qubit2cnotrzandry,
                crz2cxandrz,
                cnot2cz,
+               cnot2rxx,
                cnu2toffoliandcu,
                entangle,
                globalphase,
+               h2rx,
                ph2r,
                qubitop2onequbit,
                qft2crandhadamard,
                r2rzandph,
                rx2rz,
                ry2rz,
+               rz2rx,
                sqrtswap2cnot,
                stateprep2cnot,
                swap2cnot,
@@ -42,15 +45,18 @@
                    carb1qubit2cnotrzandry,
                    crz2cxandrz,
                    cnot2cz,
+                   cnot2rxx,
                    cnu2toffoliandcu,
                    entangle,
                    globalphase,
+                   h2rx,
                    ph2r,
                    qubitop2onequbit,
                    qft2crandhadamard,
                    r2rzandph,
                    rx2rz,
                    ry2rz,
+                   rz2rx,
                    sqrtswap2cnot,
                    stateprep2cnot,
                    swap2cnot,