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,20 @@ 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
+            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
+
             # 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
@@ -224,9 +226,20 @@ def __ne__(self, other):
     def __str__(self):
         raise NotImplementedError('This gate does not implement __str__.')
 
+    def to_string(self,symbols):
+        """
+        String representation
+
+        achieve same function as str() but can be extended for configurable representation
+        """
+        return str(self)
+
     def __hash__(self):
         return hash(str(self))
 
+    def is_identity(self):
+        return False
+
 
 class MatrixGate(BasicGate):
     """
@@ -340,10 +353,23 @@ def __str__(self):
         Returns the class name and the angle as
 
         .. code-block:: python
-
+        
             [CLASSNAME]([ANGLE])
         """
-        return str(self.__class__.__name__) + "(" + str(self.angle) + ")"
+        return self.to_string()
+
+    def to_string(self,symbols=False):
+        """
+        Return the string representation of a BasicRotationGate.
+
+        Args:
+            symbols: uses the pi character and round the angle for a 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
 
     def tex_str(self):
         """
@@ -355,7 +381,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):
         """
@@ -401,6 +427,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==4*math.pi
+
 
 class BasicPhaseGate(BasicGate):
     """

projectq/ops/_basics_test.py

@@ -163,15 +163,16 @@ 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(math.pi)
+    assert str(basic_rotation_gate) == "BasicRotationGate(3.14159265359)"
+    assert basic_rotation_gate.to_string(symbols=True) == "BasicRotationGate(0.5π)"
+    assert basic_rotation_gate.to_string(symbols=False) == "BasicRotationGate(3.14159265359)"
 
 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 +194,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 basic_rotation_gate1.is_identity()
+    assert not basic_rotation_gate2.is_identity()
+    assert 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,15 @@ 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
@@ -297,6 +306,9 @@ def __ne__(self, other):
         return not self.__eq__(other)
 
     def __str__(self):
+        return self.to_string()
+
+    def to_string(self,symbols=False):
         """
         Get string representation of this Command object.
         """
@@ -314,4 +326,4 @@ def __str__(self):
                 qstring += ", "
             qstring = qstring[:-2] + " )"
         cstring = "C" * len(ctrlqubits)
-        return cstring + str(self.gate) + " | " + qstring
+        return cstring + self.gate.to_string(symbols) + " | " + qstring

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 not inverse_cmd2.gate.is_identity()
+    assert not cmd2.gate.is_identity()
+
 
 def test_command_order_qubits(main_engine):
     qubit0 = Qureg([Qubit(main_engine, 0)])
@@ -232,9 +244,21 @@ 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(1.570796326795‬) | ( Qureg[1], Qureg[0] )"
+    cmd2 = _command.Command(main_engine, Rx(0.5*math.pi), (qubit,))
+    assert str(cmd2) == "Rx(1.570796326795‬) | Qureg[0]"
+
+def test_command_to_string():
+    qubit = Qureg([Qubit(main_engine, 0)])
+    ctrl_qubit = Qureg([Qubit(main_engine, 1)])
+    cmd = _command.Command(main_engine, Rx(0.5*math.pi), (qubit,))
+    cmd.tags = ["TestTag"]
+    cmd.add_control_qubits(ctrl_qubit)
+    assert cmd.to_string(symbols=True) == "CRx(0.5π) | ( Qureg[1], Qureg[0] )"
+    assert cmd.to_string(symbols=False) == "CRx(1.570796326795‬) | ( Qureg[1], Qureg[0] )"
+    cmd2 = _command.Command(main_engine, Rx(0.5*math.pi), (qubit,))
+    assert cmd2.to_string(symbols=True) == "Rx(0.5π) | Qureg[0]"
+    assert cmd2.to_string(symbols=False)  == "Rx(1.570796326795‬) | Qureg[0]"

projectq/ops/_metagates.py

@@ -132,6 +132,22 @@ 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
+    """
+    return gate.is_identity()
 
 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 not non_identity_gate.is_identity()
+    assert not _metagates.is_identity(non_identity_gate)  
+    # Choose gate which is an identity gate:
+    identity_gate=Rx(0.)
+    assert identity_gate.is_identity()
+    assert _metagates.is_identity(identity_gate)
+
 
 def test_controlled_gate_init():
     one_control = _metagates.ControlledGate(Y, 1)