Merge pull request #14 from tqsd/controlled_two_qubit_gate

Adding three qubit custom controlled gate

Author: benjione

eqsn/gates.py

@@ -1,9 +1,9 @@
 import multiprocessing
 import logging
 import numpy as np
-from eqsn.qubit_thread import SINGLE_GATE, MERGE_SEND, MERGE_ACCEPT, MEASURE,\
-                MEASURE_NON_DESTRUCTIVE, GIVE_STATEVECTOR, DOUBLE_GATE, \
-                CONTROLLED_GATE, NEW_QUBIT, ADD_MERGED_QUBITS_TO_DICT
+from eqsn.qubit_thread import SINGLE_GATE, MERGE_SEND, MERGE_ACCEPT, MEASURE, \
+    MEASURE_NON_DESTRUCTIVE, GIVE_STATEVECTOR, DOUBLE_GATE, \
+    CONTROLLED_GATE, NEW_QUBIT, ADD_MERGED_QUBITS_TO_DICT, CONTROLLED_TWO_GATE
 from eqsn.shared_dict import SharedDict
 from eqsn.worker_process import WorkerProcess
 from eqsn.process_picker import ProcessPicker
@@ -139,7 +139,7 @@ def K_gate(self, q_id):
         Args:
             q_id(String): ID of the Qubit to apply the gate to.
         """
-        x = 0.5 * np.array([[1+1j, 1-1j], [-1+1j, -1-1j]], dtype=np.csingle)
+        x = 0.5 * np.array([[1 + 1j, 1 - 1j], [-1 + 1j, -1 - 1j]], dtype=np.csingle)
         q = self.shared_dict.get_queues_for_ids([q_id])[0]
         q.put([SINGLE_GATE, x, q_id])
 
@@ -205,15 +205,15 @@ def merge_qubits(self, q_id1, q_id2):
             q_id1 (String): Id of the Qubit merged into q_id2.
             q_id2 (String): Id of the Qubit merged with q_id1.
         """
-        l = self.shared_dict.get_queues_for_ids([q_id1, q_id2])
-        if len(l) == 1:
+        queues = self.shared_dict.get_queues_for_ids([q_id1, q_id2])
+        if len(queues) == 1:
             return  # Already merged
         else:
             # Block the dictionary, that noone can send commands to the qubits,
             logging.debug("Merge Qubits %s and %s.", q_id1, q_id2)
             self.shared_dict.block_shared_dict()
-            q1 = l[0]
-            q2 = l[1]
+            q1 = queues[0]
+            q2 = queues[1]
             merge_q = self.manager.Queue()
             qubits_q = self.manager.Queue()
             q1.put([MERGE_SEND, q_id1, merge_q, qubits_q])
@@ -283,6 +283,22 @@ def custom_two_qubit_gate(self, q_id1, q_id2, gate):
         q = self.shared_dict.get_queues_for_ids([q_id1])[0]
         q.put([DOUBLE_GATE, gate, q_id1, q_id2])
 
+    def custom_two_qubit_control_gate(self, q_id1, q_id2, q_id3, gate):
+        """
+        Applies a two Qubit gate to two Qubits.
+
+        Args:
+            q_id1 (String): ID of the first Qubit of the gate.
+            q_id2 (String): ID of the second Qubit of the gate.
+            q_id3 (String): ID of the third Qubit of the gate.
+            gate(np.ndarray): 4x4 unitary matrix gate.
+        """
+        self.merge_qubits(q_id1, q_id2)
+        self.merge_qubits(q_id1, q_id3)
+
+        q = self.shared_dict.get_queues_for_ids([q_id1])[0]
+        q.put([CONTROLLED_TWO_GATE, gate, q_id1, q_id2, q_id3])
+
     def custom_controlled_gate(self, applied_to_id, controlled_by_id, gate):
         """
         Applies a custom controlled gate to a Qubit.

eqsn/process_picker.py

@@ -11,7 +11,7 @@ def get_instance(amount_processes, process_queue_list):
         a new object o the class is created.
 
         Args:
-            cpu_count(int): The amount of CPU cores.
+            amount_processes (int): The amount of processes.
             process_queue_list(List): A List of all Processes.
         """
         if ProcessPicker.__instance is None:

eqsn/qubit_thread.py

@@ -2,7 +2,6 @@
 import logging
 from copy import deepcopy as dp
 import random
-import sys
 
 NONE = 0
 SINGLE_GATE = 1
@@ -15,6 +14,7 @@
 ADD_MERGED_QUBITS_TO_DICT = 9
 GIVE_STATEVECTOR = 10
 DOUBLE_GATE = 11
+CONTROLLED_TWO_GATE = 12
 
 
 class QubitThread(object):
@@ -71,30 +71,36 @@ def give_statevector(self, channel):
         Sends the Qubit IDs and their state vectors over a channel.
 
         Args:
-            channel(Queue): Channel to return the requested data to.
+            channel (Queue): Channel to return the requested data to.
         """
         channel.put((dp(self.qubits), dp(self.qubit)))
 
     def apply_controlled_gate(self, mat, q_id1, q_id2):
         """
         Applies a controlled gate to q_id1
+
+        Args:
+            mat (np.ndarray): The matrix to apply
+            q_id1 (str): The target qubit id
+            q_id2 (str): The control qubit id
         """
         first_mat = 1
         second_mat = 1
         nr1 = self.qubits.index(q_id1)
         nr2 = self.qubits.index(q_id2)
+
         min_nr = min(nr1, nr2)
         max_nr = max(nr1, nr2)
-        if min_nr == nr1:
-            # first_mat = mat
-            pass
+
         total_amount = len(self.qubits)
         before = min_nr
         after = total_amount - max_nr - 1
         mid = total_amount - before - after - 2
+
         if before > 0:
             first_mat = np.eye(2 ** before)
             second_mat = np.eye(2 ** before)
+
         # Apply first part of Matrix
         if min_nr == nr1:
             first_mat = np.kron(first_mat, np.eye(2))
@@ -106,6 +112,7 @@ def apply_controlled_gate(self, mat, q_id1, q_id2):
         if mid > 0:
             first_mat = np.kron(first_mat, np.eye(2 ** mid))
             second_mat = np.kron(second_mat, np.eye(2 ** mid))
+
         # Apply second part of Matrix
         if min_nr == nr1:
             first_mat = np.kron(first_mat, np.array([[1, 0], [0, 0]]))
@@ -117,6 +124,7 @@ def apply_controlled_gate(self, mat, q_id1, q_id2):
         if after > 0:
             first_mat = np.kron(first_mat, np.eye(2 ** after))
             second_mat = np.kron(second_mat, np.eye(2 ** after))
+
         apply_mat = first_mat + second_mat
         self.qubit = np.dot(apply_mat, self.qubit)
 
@@ -134,7 +142,7 @@ def merge_accept(self, channel):
         self.qubit = np.kron(self.qubit, vector)
         logging.debug("Qubit Thread merged, new qubits are %r", self.qubits)
 
-    def merge_send(self, channel, chanel2):
+    def merge_send(self, channel, channel2):
         """
         Send own process data to another process and suicide.
 
@@ -145,20 +153,21 @@ def merge_send(self, channel, chanel2):
         """
         channel.put(dp(self.qubits))
         channel.put(dp(self.qubit))
-        chanel2.put(dp(self.qubits))
+        channel2.put(dp(self.qubits))
         return
 
     def swap_qubits(self, q_id1, q_id2):
         """
         Swaps the position of qubit q_id1 with q_id2
-        in the statevector.
+        in the state vector.
 
         q_id1(String): Qubit id of one of the qubits to swap.
         q_id2(String): Qubit id of the other qubit to swap.
         """
-        def cnot(q_id1, q_id2):
+
+        def cnot(_q_id1, _q_id2):
             mat = np.asarray([[0, 1], [1, 0]])
-            self.apply_controlled_gate(mat, q_id1, q_id2)
+            self.apply_controlled_gate(mat, _q_id1, _q_id2)
 
         # Check if they are the same ids
         if q_id1 == q_id2:
@@ -173,9 +182,28 @@ def cnot(q_id1, q_id2):
         i2 = self.qubits.index(q_id2)
         self.qubits[i1], self.qubits[i2] = self.qubits[i2], self.qubits[i1]
 
+    def apply_controlled_two_qubit_gate(self, mat, q_id1, q_id2, q_id3):
+        """
+        Applies a 3 qubit controlled gate
+        Args:
+            mat (np.ndarray): The 4x4 unitary gate to apply
+            q_id1 (str): The control qubit
+            q_id2 (str): A target qubit
+            q_id3 (str): A target qubit
+        """
+        # Move the qubits to the correct position
+        self.swap_qubits(q_id1, self.qubits[0])
+        self.swap_qubits(q_id2, self.qubits[1])
+        self.swap_qubits(q_id3, self.qubits[2])
+
+        first_mat = np.block([[np.eye(4), np.zeros((4, 4))], [np.zeros((4, 4)), mat]])
+        total_mat = np.kron(first_mat, np.eye(2 ** (len(self.qubits) - 3)))
+
+        self.qubit = np.dot(total_mat, self.qubit)
+
     def apply_two_qubit_gate(self, gate, q_id1, q_id2):
         """
-        Applies a two qubit gate to the statevector.
+        Applies a two qubit gate to the state vector.
 
         Args:
             gate(np.ndarray): 4x4 unitary matrix
@@ -185,11 +213,12 @@ def apply_two_qubit_gate(self, gate, q_id1, q_id2):
         # Bring the qubits in the right order
         i2 = self.qubits.index(q_id2)
         if i2 > 0:
-            new_i1 = i2-1
+            new_i1 = i2 - 1
             self.swap_qubits(q_id1, self.qubits[new_i1])
         else:
             self.swap_qubits(q_id1, self.qubits[0])
             self.swap_qubits(q_id2, self.qubits[1])
+
         apply_mat = gate
         nr1 = self.qubits.index(q_id1)
         total_amount = len(self.qubits)
@@ -309,6 +338,8 @@ def run(self):
                 self.apply_single_gate(item[1], item[2])
             elif item[0] == CONTROLLED_GATE:
                 self.apply_controlled_gate(item[1], item[2], item[3])
+            elif item[0] == CONTROLLED_TWO_GATE:
+                self.apply_controlled_two_qubit_gate(item[1], item[2], item[3], item[4])
             elif item[0] == MEASURE:
                 self.measure(item[1], item[2])
                 # no qubit left, terminate

eqsn/shared_dict.py

@@ -296,6 +296,6 @@ def stop_all_threads(self):
 
     def stop_shared_dict(self):
         """
-        Releases the dicionary object.
+        Releases the dictionary object.
         """
         SharedDict.__instance = None

eqsn/worker_process.py

@@ -1,12 +1,12 @@
 import logging
 import threading
-import os
 from queue import Queue
+
+from eqsn.qubit_thread import SINGLE_GATE, MERGE_SEND, MERGE_ACCEPT, MEASURE, \
+    MEASURE_NON_DESTRUCTIVE, GIVE_STATEVECTOR, \
+    CONTROLLED_GATE, NEW_QUBIT, ADD_MERGED_QUBITS_TO_DICT, CONTROLLED_TWO_GATE, \
+    DOUBLE_GATE, QubitThread
 from eqsn.shared_dict import SharedDict
-from eqsn.qubit_thread import SINGLE_GATE, MERGE_SEND, MERGE_ACCEPT, MEASURE,\
-                MEASURE_NON_DESTRUCTIVE, GIVE_STATEVECTOR, \
-                CONTROLLED_GATE, NEW_QUBIT, ADD_MERGED_QUBITS_TO_DICT, \
-                DOUBLE_GATE, QubitThread
 
 
 class WorkerProcess(object):
@@ -21,6 +21,7 @@ def __init__(self, queue):
             queue (Queue): Queue for receiving commands from main Process.
         """
         self.queue = queue
+        self.shared_dict = None
 
     def run(self):
         """
@@ -42,6 +43,8 @@ def run(self):
                 amount_single_gate += 1
             elif item[0] == CONTROLLED_GATE:
                 self.apply_controlled_gate(item[1], item[2], item[3])
+            elif item[0] == CONTROLLED_TWO_GATE:
+                self.apply_two_qubit_controlled_gate(item[1], item[2], item[3], item[4])
             elif item[0] == MEASURE:
                 self.measure(item[1], item[2])
             elif item[0] == MERGE_ACCEPT:
@@ -57,14 +60,14 @@ def run(self):
             elif item[0] == DOUBLE_GATE:
                 self.apply_two_qubit_gate(item[1], item[2], item[3])
             else:
-                raise ValueError("Command does not exist!")
+                raise ValueError(f"Command does not exist! {item[0]}")
 
     def new_qubit(self, q_id):
         """
         Creates a new qubit with an id.
 
         Args:
-            id (String): Id of the new qubit.
+            q_id (String): Id of the new qubit.
         """
         q = Queue()
         thread = QubitThread(q_id, q)
@@ -115,6 +118,11 @@ def stop_all(self):
         self.shared_dict.stop_all_threads()
         self.shared_dict.stop_shared_dict()
 
+    def apply_two_qubit_controlled_gate(self, gate, q_id1, q_id2, q_id3):
+        # Qubits are already mergered, they have the same queue
+        q = self.shared_dict.get_queues_for_ids([q_id1])[0]
+        q.put([CONTROLLED_TWO_GATE, gate, q_id1, q_id2, q_id3])
+
     def apply_two_qubit_gate(self, gate, q_id1, q_id2):
         """
         Applies a two qubit gate to a thread.
@@ -179,8 +187,8 @@ def merge_accept(self, q_id, queue):
         Handle a merge accept.
 
         Args:
-            q_id(String): ID of the qubit which should accept the merge.
-            channel(Queue): channel to receive qubit ids and statevectors from.
+            q_id (String): ID of the qubit which should accept the merge.
+            queue (Queue): channel to receive qubit ids and statevectors from.
         """
         q = self.shared_dict.get_queues_for_ids([q_id])[0]
         q.put([MERGE_ACCEPT, queue])

run_tests.py

@@ -20,13 +20,17 @@ def __exit__(self, etype, value, traceback):
 
 if __name__ == "__main__":
     files = [f for f in glob.glob("./tests/**/*.py")] + [f for f in glob.glob("./tests/*.py")]
-    print(files)
     for f in files:
-        print("Start with " + str(f))
         if f in ignore:
             continue
         path, filename = os.path.split(f)
         with cd(path):
+            print('Testing %s' % filename)
             exitcode = os.system("python %s" % filename)
             if exitcode != 0:
-                assert False, "Testfile %s was not successful!" % f
+                assert False, "Testing %s was not successful!" % f
+            else:
+                print("Testing %s was successful!" % filename)
+
+    print('Done tests')
+    exit(0)

tests/test_calling_gates_from_threads.py

@@ -3,16 +3,15 @@
 
 
 def test_call_single_qubit_gate_from_threads():
-    q_sim = EQSN()
+    eqsn = EQSN()
 
-    def call_X_gate_n_times(id, n):
-        for c in range(n):
-            # print("Apply %d time." % c)
-            q_sim.X_gate(id)
+    def call_X_gate_n_times(_id, n):
+        for _ in range(n):
+            eqsn.X_gate(_id)
 
     id1 = str(1)
-    q_sim.new_qubit(id1)
-    n = 999
+    eqsn.new_qubit(id1)
+    n = 99
     nr_threads = 5
     thread_list = []
     for _ in range(nr_threads):
@@ -21,12 +20,11 @@ def call_X_gate_n_times(id, n):
         thread_list.append(t)
     for t in thread_list:
         t.join()
-    m = q_sim.measure(id1)
-    print("Measured %d." % m)
+    m = eqsn.measure(id1)
     assert m == 1
-    print("Test was successfull!")
-    q_sim.stop_all()
+    eqsn.stop_all()
 
 
 if __name__ == "__main__":
     test_call_single_qubit_gate_from_threads()
+    exit(0)