From ddbc78db06c67920be087676ece087a48c44e40b Mon Sep 17 00:00:00 2001
From: changsookim <>
Date: Wed, 14 Aug 2024 20:30:15 +0800
Subject: [PATCH 01/40] update v1

---
 src/qibo/transpiler/placer.py   |   2 +-
 src/qibo/transpiler/router.py   | 335 +++++++++++++++++---------------
 tests/test_transpiler_router.py |  74 +++----
 3 files changed, 221 insertions(+), 190 deletions(-)

diff --git a/src/qibo/transpiler/placer.py b/src/qibo/transpiler/placer.py
index 62d2a3e97c..12415b8ec7 100644
--- a/src/qibo/transpiler/placer.py
+++ b/src/qibo/transpiler/placer.py
@@ -411,7 +411,6 @@ def __init__(
     ):
         self.connectivity = connectivity
         self.routing_algorithm = routing_algorithm
-        self.routing_algorithm.connectivity = connectivity
         self.depth = depth
 
     def __call__(self, circuit: Circuit):
@@ -425,6 +424,7 @@ def __call__(self, circuit: Circuit):
         """
         initial_placer = Trivial(self.connectivity)
         initial_placement = initial_placer(circuit=circuit)
+        self.routing_algorithm.connectivity = self.connectivity
         new_circuit = self._assemble_circuit(circuit)
         final_placement = self._routing_step(initial_placement, new_circuit)
 
diff --git a/src/qibo/transpiler/router.py b/src/qibo/transpiler/router.py
index e3fecb2a4c..9168c32b3d 100644
--- a/src/qibo/transpiler/router.py
+++ b/src/qibo/transpiler/router.py
@@ -174,34 +174,55 @@ class CircuitMap:
     def __init__(
         self,
         initial_layout: dict,
-        circuit: Circuit,
+        circuit: Optional[Circuit] = None,
         blocks: Optional[CircuitBlocks] = None,
+        temp: Optional[bool] = False,           #2# for temporary circuit
     ):
+        self.initial_layout = dict(sorted(initial_layout.items()))
+
+        #1# bidirectional mapping
+        #1# self._p2l: physical qubit number i -> logical qubit number _p2l[i]
+        #1# self._l2p: logical qubit number i -> physical qubit number _l2p[i]
+        self._l2p, self._p2l = [0] * len(self.initial_layout), [0] * len(self.initial_layout)
+        for mapping in self.initial_layout.items():
+            physical_qubit, logical_qubit = int(mapping[0][1:]), mapping[1]
+            self._l2p[logical_qubit] = physical_qubit
+            self._p2l[physical_qubit] = logical_qubit
+
+        self._temporary = temp
+        if self._temporary:     #2# if temporary circuit, no need to store the blocks
+            return
+
+        self._nqubits = circuit.nqubits         #1# number of qubits
+        if circuit is None:
+            raise_error(ValueError, "Circuit must be provided.")
+
         if blocks is not None:
             self.circuit_blocks = blocks
         else:
             self.circuit_blocks = CircuitBlocks(circuit, index_names=True)
-        # Order the initial layout based on the hardware qubit names
-        # to avoid problems in custom layouts
-        self.initial_layout = dict(sorted(initial_layout.items()))
-        self._graph_qubits_names = [int(key[1:]) for key in self.initial_layout.keys()]
-        self._circuit_logical = list(range(len(self.initial_layout)))
-        self._physical_logical = list(self.initial_layout.values())
+
         self._routed_blocks = CircuitBlocks(Circuit(circuit.nqubits))
         self._swaps = 0
 
-    def set_circuit_logical(self, circuit_logical_map: list):
-        """Sets the current circuit to logical qubit mapping.
+    #1# previous: set_circuit_logical
+    def set_p2l(self, p2l_map: list):
+        """Sets the current physical to logical qubit mapping.
 
         Method works in-place.
 
         Args:
-            circuit_logical_map (list): logical mapping.
+            p2l_map (list): physical to logical mapping.
         """
-        self._circuit_logical = circuit_logical_map
+        #1# update bidirectional mapping
+        #4# use shallow copy
+        self._p2l = p2l_map.copy()
+        self._l2p = [0] * len(self._p2l)
+        for i, l in enumerate(self._p2l):
+            self._l2p[l] = i
 
     def blocks_qubits_pairs(self):
-        """Returns a list containing the qubit pairs of each block."""
+        """Returns a list containing the logical qubit pairs of each block."""
         return [block.qubits for block in self.circuit_blocks()]
 
     def execute_block(self, block: Block):
@@ -214,7 +235,7 @@ def execute_block(self, block: Block):
             block (:class:`qibo.transpiler.blocks.Block`): block to be removed.
         """
         self._routed_blocks.add_block(
-            block.on_qubits(self.get_physical_qubits(block, index=True))
+            block.on_qubits(self.get_physical_qubits(block))
         )
         self.circuit_blocks.remove_block(block)
 
@@ -230,16 +251,18 @@ def routed_circuit(self, circuit_kwargs: Optional[dict] = None):
         return self._routed_blocks.circuit(circuit_kwargs=circuit_kwargs)
 
     def final_layout(self):
-        """Returns the final physical-circuit qubits mapping."""
+        """Returns the final physical-logical qubits mapping."""
+
+        #1# return {"q0": lq_num0, "q1": lq_num1, ...}
         unsorted_dict = {
-            "q" + str(self.circuit_to_physical(i)): i
-            for i in range(len(self._circuit_logical))
+            "q" + str(i): self._p2l[i]
+            for i in range(self._nqubits)
         }
 
         return dict(sorted(unsorted_dict.items()))
 
-    def update(self, swap: tuple):
-        """Updates the logical-physical qubit mapping after applying a ``SWAP``
+    def update(self, swap_l: tuple):
+        """Updates the qubit mapping after applying a ``SWAP``
 
         Adds the :class:`qibo.gates.gates.SWAP` gate to the routed blocks.
         Method works in-place.
@@ -247,114 +270,64 @@ def update(self, swap: tuple):
         Args:
             swap (tuple): tuple containing the logical qubits to be swapped.
         """
-        physical_swap = self.logical_to_physical(swap, index=True)
-        self._routed_blocks.add_block(
-            Block(qubits=physical_swap, gates=[gates.SWAP(*physical_swap)])
-        )
-        self._swaps += 1
-        idx_0, idx_1 = self._circuit_logical.index(
-            swap[0]
-        ), self._circuit_logical.index(swap[1])
-        self._circuit_logical[idx_0], self._circuit_logical[idx_1] = swap[1], swap[0]
+
+        swap_p = self.logical_pair_to_physical(swap_l)
+
+        #2# add the real SWAP gate, not a temporary circuit
+        if not self._temporary:
+            self._routed_blocks.add_block(
+                Block(qubits=swap_p, gates=[gates.SWAP(*swap_p)])
+            )
+            self._swaps += 1
+
+        #1# update the bidirectional mapping
+        p1, p2 = swap_p
+        l1, l2 = swap_l
+        self._p2l[p1], self._p2l[p2] = l2, l1
+        self._l2p[l1], self._l2p[l2] = p2, p1
 
     def undo(self):
         """Undo the last swap. Method works in-place."""
         last_swap_block = self._routed_blocks.return_last_block()
-        swap = tuple(self.physical_to_logical(q) for q in last_swap_block.qubits)
+        swap_p = last_swap_block.qubits
+        swap_l = self._p2l[swap_p[0]], self._p2l[swap_p[1]]
         self._routed_blocks.remove_block(last_swap_block)
         self._swaps -= 1
 
-        idx_0, idx_1 = self._circuit_logical.index(
-            swap[0]
-        ), self._circuit_logical.index(swap[1])
-        self._circuit_logical[idx_0], self._circuit_logical[idx_1] = swap[1], swap[0]
-
-    def get_logical_qubits(self, block: Block):
-        """Returns the current logical qubits where a block is acting on.
-
-        Args:
-            block (:class:`qibo.transpiler.blocks.Block`): block to be analysed.
-
-        Returns:
-            tuple: logical qubits where a block is acting on.
-        """
-        return self.circuit_to_logical(block.qubits)
+        #1# update the bidirectional mapping
+        p1, p2 = swap_p
+        l1, l2 = swap_l
+        self._p2l[p1], self._p2l[p2] = l2, l1
+        self._l2p[l1], self._l2p[l2] = p2, p1
 
-    def get_physical_qubits(self, block: Union[int, Block], index: bool = False):
+    def get_physical_qubits(self, block: Union[int, Block]):
         """Returns the physical qubits where a block is acting on.
 
         Args:
             block (int or :class:`qibo.transpiler.blocks.Block`): block to be analysed.
-            index (bool, optional): If ``True``, qubits are returned as indices of
-                the connectivity nodes. Defaults to ``False``.
 
         Returns:
-            tuple: physical qubits where a block is acting on.
-
+            tuple: physical qubit numbers where a block is acting on.
         """
         if isinstance(block, int):
             block = self.circuit_blocks.search_by_index(block)
 
-        return self.logical_to_physical(self.get_logical_qubits(block), index=index)
-
-    def logical_to_physical(self, logical_qubits: tuple, index: bool = False):
-        """Returns the physical qubits associated to the logical qubits.
-
-        Args:
-            logical_qubits (tuple): physical qubits.
-            index (bool, optional): If ``True``, qubits are returned as indices of
-                `the connectivity nodes. Defaults to ``False``.
-
-        Returns:
-            tuple: physical qubits associated to the logical qubits.
-        """
-        if not index:
-            return tuple(
-                self._graph_qubits_names[
-                    self._physical_logical.index(logical_qubits[i])
-                ]
-                for i in range(2)
-            )
-
-        return tuple(self._physical_logical.index(logical_qubits[i]) for i in range(2))
+        return tuple(self._l2p[q] for q in block.qubits)
 
-    def circuit_to_logical(self, circuit_qubits: tuple):
-        """Returns the current logical qubits associated to the initial circuit qubits.
+    #1# logical_to_physical -> logical_pair_to_physical
+    def logical_pair_to_physical(self, logical_qubits: tuple):
+        """Returns the physical qubits associated to the logical qubit pair.
 
         Args:
-            circuit_qubits (tuple): circuit qubits.
+            logical_qubits (tuple): logical qubit pair.
 
         Returns:
-            tuple: logical qubits.
+            tuple: physical qubit numbers associated to the logical qubit pair.
         """
-        return tuple(self._circuit_logical[circuit_qubits[i]] for i in range(2))
-
-    def circuit_to_physical(self, circuit_qubit: int):
-        """Returns the current physical qubit associated to an initial circuit qubit.
-
-        Args:
-            circuit_qubit (int): circuit qubit.
-
-        Returns:
-            int: physical qubit.
-        """
-        return self._graph_qubits_names[
-            self._physical_logical.index(self._circuit_logical[circuit_qubit])
-        ]
-
-    def physical_to_logical(self, physical_qubit: int):
-        """Returns current logical qubit associated to a physical qubit (connectivity graph node).
-
-        Args:
-            physical_qubit (int): physical qubit.
-
-        Returns:
-            int: logical qubit.
-        """
-        physical_qubit_index = self._graph_qubits_names.index(physical_qubit)
-
-        return self._physical_logical[physical_qubit_index]
+        #1# return physical qubit numbers corresponding to the logical qubit pair
+        return self._l2p[logical_qubits[0]], self._l2p[logical_qubits[1]]
 
+    #1# circuit_to_logical(), circuit_to_physical() removed
 
 class ShortestPaths(Router):
     """A class to perform initial qubit mapping and connectivity matching.
@@ -371,6 +344,7 @@ def __init__(self, connectivity: nx.Graph, seed: Optional[int] = None):
         self.circuit = None
         self._dag = None
         self._final_measurements = None
+        self._node_mapping_inv = None
         if seed is None:
             seed = 42
         random.seed(seed)
@@ -408,7 +382,10 @@ def __call__(self, circuit: Circuit, initial_layout: dict):
                 routed_circuit=routed_circuit
             )
 
-        return routed_circuit, self.circuit.final_layout()
+        #1# final layout is reverted to the original labeling 
+        final_layout = self.circuit.final_layout()
+        final_layout_restored = {"q" + str(self.node_mapping_inv[int(k[1:])]): v for k, v in final_layout.items()}
+        return routed_circuit, final_layout_restored
 
     def _find_new_mapping(self):
         """Find new qubit mapping. Mapping is found by looking for the shortest path.
@@ -457,24 +434,14 @@ def _add_swaps(candidate: tuple, circuitmap: CircuitMap):
         """
         path = candidate[0]
         meeting_point = candidate[1]
-        forward = path[0 : meeting_point + 1]
+        forward = path[0 : meeting_point + 1]       #1# physical qubits
         backward = list(reversed(path[meeting_point + 1 :]))
-        if len(forward) > 1:
-            for f1, f2 in zip(forward[:-1], forward[1:]):
-                circuitmap.update(
-                    (
-                        circuitmap.physical_to_logical(f1),
-                        circuitmap.physical_to_logical(f2),
-                    )
-                )
-        if len(backward) > 1:
-            for b1, b2 in zip(backward[:-1], backward[1:]):
-                circuitmap.update(
-                    (
-                        circuitmap.physical_to_logical(b1),
-                        circuitmap.physical_to_logical(b2),
-                    )
-                )
+        #1# apply logical swaps 
+        for f in forward[1:]:
+            circuitmap.update((circuitmap._p2l[f], circuitmap._p2l[forward[0]]))
+        for b in backward[1:]:
+            circuitmap.update((circuitmap._p2l[b], circuitmap._p2l[backward[0]]))
+
 
     def _compute_cost(self, candidate: tuple):
         """Greedy algorithm that decides which path to take and how qubits should be walked.
@@ -487,12 +454,15 @@ def _compute_cost(self, candidate: tuple):
         Returns:
             (list, int): best path to move qubits and qubit meeting point in the path.
         """
+        #2# CircuitMap might be used
         temporary_circuit = CircuitMap(
             initial_layout=self.circuit.initial_layout,
             circuit=Circuit(len(self.circuit.initial_layout)),
             blocks=deepcopy(self.circuit.circuit_blocks),
         )
-        temporary_circuit.set_circuit_logical(deepcopy(self.circuit._circuit_logical))
+
+        #1# use set_p2l
+        temporary_circuit.set_p2l(self.circuit._p2l)
         self._add_swaps(candidate, temporary_circuit)
         temporary_dag = deepcopy(self._dag)
         successive_executed_gates = 0
@@ -506,6 +476,7 @@ def _compute_cost(self, candidate: tuple):
             all_executed = True
             for block in temporary_front_layer:
                 if (
+                    #3# might be changed to use _get_dag_layer(qubits=True) to avoid using get_physical_qubits(block_num)
                     temporary_circuit.get_physical_qubits(block)
                     in self.connectivity.edges
                     or not temporary_circuit.circuit_blocks.search_by_index(
@@ -525,7 +496,7 @@ def _compute_cost(self, candidate: tuple):
         return -successive_executed_gates
 
     def _check_execution(self):
-        """Checks if some blocks in the front layer can be executed in the current configuration.
+        """Check if some blocks in the front layer can be executed in the current configuration.
 
         Returns:
             (list): executable blocks if there are, ``None`` otherwise.
@@ -533,6 +504,7 @@ def _check_execution(self):
         executable_blocks = []
         for block in self._front_layer:
             if (
+                #3# might be changed to use _get_dag_layer(qubits=True) to avoid using get_physical_qubits(block_num)
                 self.circuit.get_physical_qubits(block) in self.connectivity.edges
                 or not self.circuit.circuit_blocks.search_by_index(block).entangled
             ):
@@ -581,9 +553,19 @@ def _preprocessing(self, circuit: Circuit, initial_layout: dict):
             circuit (:class:`qibo.models.circuit.Circuit`): circuit to be preprocessed.
             initial_layout (dict): initial physical-to-logical qubit mapping.
         """
+
+        #1# To simplify routing, some data is relabeled before routing begins.
+        node_mapping, new_initial_layout = {}, {}
+        for i, node in enumerate(self.connectivity.nodes):
+            node_mapping[node] = i
+            new_initial_layout["q" + str(i)] = initial_layout["q" + str(node)]
+
+        self.connectivity = nx.relabel_nodes(self.connectivity, node_mapping)
+        self.node_mapping_inv = {v: k for k, v in node_mapping.items()}
+
         copied_circuit = circuit.copy(deep=True)
         self._final_measurements = self._detach_final_measurements(copied_circuit)
-        self.circuit = CircuitMap(initial_layout, copied_circuit)
+        self.circuit = CircuitMap(new_initial_layout, copied_circuit)
         self._dag = _create_dag(self.circuit.blocks_qubits_pairs())
         self._update_front_layer()
 
@@ -613,8 +595,9 @@ def _append_final_measurements(self, routed_circuit: Circuit):
         conserving the measurement register."""
         for measurement in self._final_measurements:
             original_qubits = measurement.qubits
-            routed_qubits = (
-                self.circuit.circuit_to_physical(qubit) for qubit in original_qubits
+            routed_qubits = list(
+                #1# use l2p to get physical qubit numbers
+                self.circuit._l2p[qubit] for qubit in original_qubits
             )
             routed_circuit.add(
                 measurement.on_qubits(dict(zip(original_qubits, routed_qubits)))
@@ -660,6 +643,8 @@ def __init__(
         seed: Optional[int] = None,
     ):
         self.connectivity = connectivity
+        #1# map to revert the final layout to the original labeling
+        self.node_mapping_inv = None
         self.lookahead = lookahead
         self.decay = decay_lookahead
         self.delta = delta
@@ -713,7 +698,10 @@ def __call__(self, circuit: Circuit, initial_layout: dict):
                 routed_circuit=routed_circuit
             )
 
-        return routed_circuit, self.circuit.final_layout()
+        #1# final layout is reverted to the original labeling
+        final_layout = self.circuit.final_layout()
+        final_layout_restored = {"q" + str(self.node_mapping_inv[int(k[1:])]): v for k, v in final_layout.items()}
+        return routed_circuit, final_layout_restored
 
     @property
     def added_swaps(self):
@@ -735,9 +723,20 @@ def _preprocessing(self, circuit: Circuit, initial_layout: dict):
             circuit (:class:`qibo.models.circuit.Circuit`): circuit to be preprocessed.
             initial_layout (dict): initial physical-to-logical qubit mapping.
         """
+
+        #1# To simplify routing, some data is relabeled before routing begins.
+        #1# physical qubit is reassigned to a range from 0 to len(self.connectivity.nodes) - 1.
+        node_mapping, new_initial_layout = {}, {}
+        for i, node in enumerate(self.connectivity.nodes):
+            node_mapping[node] = i
+            new_initial_layout["q" + str(i)] = initial_layout["q" + str(node)]
+
+        self.connectivity = nx.relabel_nodes(self.connectivity, node_mapping)
+        self.node_mapping_inv = {v: k for k, v in node_mapping.items()}
+
         copied_circuit = circuit.copy(deep=True)
         self._final_measurements = self._detach_final_measurements(copied_circuit)
-        self.circuit = CircuitMap(initial_layout, copied_circuit)
+        self.circuit = CircuitMap(new_initial_layout, copied_circuit)
         self._dist_matrix = nx.floyd_warshall_numpy(self.connectivity)
         self._dag = _create_dag(self.circuit.blocks_qubits_pairs())
         self._memory_map = []
@@ -770,7 +769,8 @@ def _append_final_measurements(self, routed_circuit: Circuit):
         for measurement in self._final_measurements:
             original_qubits = measurement.qubits
             routed_qubits = list(
-                self.circuit.circuit_to_physical(qubit) for qubit in original_qubits
+                #1# use l2p to get physical qubit numbers
+                self.circuit._l2p[qubit] for qubit in original_qubits
             )
             routed_circuit.add(
                 measurement.on_qubits(dict(zip(original_qubits, routed_qubits)))
@@ -793,14 +793,31 @@ def _update_front_layer(self):
         """
         self._front_layer = self._get_dag_layer(0)
 
-    def _get_dag_layer(self, n_layer):
-        """Return the :math:`n`-topological layer of the dag."""
+    def _get_dag_layer(self, n_layer, qubits=False):
+        """Return the :math:`n`-topological layer of the dag.
+        If ``qubits=True``, return the target qubits of the blocks in the layer.
+        Otherwise, return the block numbers.
+        """
+
+        #3# depend on the 'qubits' flag, return the block number or target qubits
+        #3# return target qubits -> to avoid using get_physical_qubits(block_num)
+        if qubits:
+            layer_qubits = []
+            nodes = self._dag.nodes(data=True)
+            for node in nodes:
+                if node[1]["layer"] == n_layer:
+                    # return target qubits
+                    layer_qubits.append(node[1]["qubits"])
+            return layer_qubits
+
         return [node[0] for node in self._dag.nodes(data="layer") if node[1] == n_layer]
 
     def _find_new_mapping(self):
         """Find the new best mapping by adding one swap."""
         candidates_evaluation = {}
-        self._memory_map.append(deepcopy(self.circuit._circuit_logical))
+
+        #4# use shallow copy
+        self._memory_map.append(self.circuit._p2l.copy())
         for candidate in self._swap_candidates():
             candidates_evaluation[candidate] = self._compute_cost(candidate)
 
@@ -810,31 +827,40 @@ def _find_new_mapping(self):
         ]
         best_candidate = random.choice(best_candidates)
 
-        for qubit in self.circuit.logical_to_physical(best_candidate, index=True):
+        for qubit in self.circuit.logical_pair_to_physical(best_candidate):
             self._delta_register[qubit] += self.delta
         self.circuit.update(best_candidate)
         self._temp_added_swaps.append(best_candidate)
 
     def _compute_cost(self, candidate: int):
         """Compute the cost associated to a possible SWAP candidate."""
+
+        #2# use CircuitMap for temporary circuit to save time
+        #2# no gates, no block decomposition, no Circuit object
+        #2# just logical-physical mapping
         temporary_circuit = CircuitMap(
             initial_layout=self.circuit.initial_layout,
-            circuit=Circuit(len(self.circuit.initial_layout)),
-            blocks=self.circuit.circuit_blocks,
+            temp=True,
         )
-        temporary_circuit.set_circuit_logical(deepcopy(self.circuit._circuit_logical))
+
+        #1# use set_p2l
+        temporary_circuit.set_p2l(self.circuit._p2l)
         temporary_circuit.update(candidate)
 
-        if temporary_circuit._circuit_logical in self._memory_map:
+        #1# use p2l to check if the mapping is already in the memory
+        if temporary_circuit._p2l in self._memory_map:
             return float("inf")
 
         tot_distance = 0.0
         weight = 1.0
         for layer in range(self.lookahead + 1):
-            layer_gates = self._get_dag_layer(layer)
+            #3# return gates' target qubit pairs in the layer
+            #3# to avoid using get_physical_qubits(block_num)
+            layer_gates = self._get_dag_layer(layer, qubits=True)
             avg_layer_distance = 0.0
-            for gate in layer_gates:
-                qubits = temporary_circuit.get_physical_qubits(gate, index=True)
+            for lq_pair in layer_gates:
+                #3# logical qubit pairs to node numbers (physical qubit pairs) in the connectivity graph
+                qubits = temporary_circuit.logical_pair_to_physical(lq_pair)
                 avg_layer_distance += (
                     max(self._delta_register[i] for i in qubits)
                     * (self._dist_matrix[qubits[0], qubits[1]] - 1.0)
@@ -855,14 +881,15 @@ def _swap_candidates(self):
             (list): list of candidates.
         """
         candidates = []
+        #3# might be changed to use _get_dag_layer(qubits=True) to avoid using get_physical_qubits(block_num)
         for block in self._front_layer:
             for qubit in self.circuit.get_physical_qubits(block):
                 for connected in self.connectivity.neighbors(qubit):
                     candidate = tuple(
                         sorted(
                             (
-                                self.circuit.physical_to_logical(qubit),
-                                self.circuit.physical_to_logical(connected),
+                                self.circuit._p2l[qubit],
+                                self.circuit._p2l[connected],
                             )
                         )
                     )
@@ -880,6 +907,7 @@ def _check_execution(self):
         executable_blocks = []
         for block in self._front_layer:
             if (
+                #3# might be changed to use _get_dag_layer(qubits=True) to avoid using get_physical_qubits(block_num)
                 self.circuit.get_physical_qubits(block) in self.connectivity.edges
                 or not self.circuit.circuit_blocks.search_by_index(block).entangled
             ):
@@ -922,6 +950,8 @@ def _shortest_path_routing(self):
         shortest_path_qubits = None
 
         for block in self._front_layer:
+            #3# return node numbers (physical qubits) in the connectivity graph
+            #3# might be changed to use _get_dag_layer(qubits=True) to avoid using get_physical_qubits(block_num)
             q1, q2 = self.circuit.get_physical_qubits(block)
             distance = self._dist_matrix[q1, q2]
 
@@ -933,15 +963,11 @@ def _shortest_path_routing(self):
             self.connectivity, shortest_path_qubits[0], shortest_path_qubits[1]
         )
 
-        # Q1 is moved
-        shortest_path = [
-            self.circuit.physical_to_logical(q) for q in shortest_path[:-1]
-        ]
-        swaps = list(zip(shortest_path[:-1], shortest_path[1:]))
-
-        for swap in swaps:
-            self.circuit.update(swap)
-
+        # move q1
+        #1# qubit moving algorithm is changed
+        q1 = self.circuit._p2l[shortest_path[0]]
+        for q2 in shortest_path[1:-1]:
+            self.circuit.update((q1, self.circuit._p2l[q2]))
 
 def _create_dag(gates_qubits_pairs: list):
     """Helper method for :meth:`qibo.transpiler.router.Sabre`.
@@ -957,6 +983,11 @@ def _create_dag(gates_qubits_pairs: list):
     """
     dag = nx.DiGraph()
     dag.add_nodes_from(range(len(gates_qubits_pairs)))
+
+    #3# additionally store target qubits of the gates
+    for i in range(len(gates_qubits_pairs)):
+        dag.nodes[i]["qubits"] = gates_qubits_pairs[i]
+
     # Find all successors
     connectivity_list = []
     for idx, gate in enumerate(gates_qubits_pairs):
@@ -972,7 +1003,6 @@ def _create_dag(gates_qubits_pairs: list):
 
     return _remove_redundant_connections(dag)
 
-
 def _remove_redundant_connections(dag: nx.DiGraph):
     """Helper method for :func:`qibo.transpiler.router._create_dag`.
 
@@ -985,8 +1015,9 @@ def _remove_redundant_connections(dag: nx.DiGraph):
         (:class:`networkx.DiGraph`): reduced dag.
     """
     new_dag = nx.DiGraph()
-    new_dag.add_nodes_from(range(dag.number_of_nodes()))
+    #3# add nodes with attributes
+    new_dag.add_nodes_from(dag.nodes(data=True))
     transitive_reduction = nx.transitive_reduction(dag)
     new_dag.add_edges_from(transitive_reduction.edges)
 
-    return new_dag
+    return new_dag
\ No newline at end of file
diff --git a/tests/test_transpiler_router.py b/tests/test_transpiler_router.py
index 806223cbc8..fdad7b96c8 100644
--- a/tests/test_transpiler_router.py
+++ b/tests/test_transpiler_router.py
@@ -272,40 +272,40 @@ def test_circuit_map():
     circ.add(gates.CZ(0, 1))
     circ.add(gates.CZ(2, 3))
     initial_layout = {"q0": 2, "q1": 0, "q2": 1, "q3": 3}
-    circuit_map = CircuitMap(initial_layout=initial_layout, circuit=circ)
-    block_list = circuit_map.circuit_blocks
-    # test blocks_qubits_pairs
-    assert circuit_map.blocks_qubits_pairs() == [(0, 1), (1, 2), (0, 1), (2, 3)]
-    # test execute_block and routed_circuit
-    circuit_map.execute_block(block_list.search_by_index(0))
-    routed_circuit = circuit_map.routed_circuit()
-    assert isinstance(routed_circuit.queue[0], gates.H)
-    assert len(routed_circuit.queue) == 4
-    assert routed_circuit.queue[2].qubits == (1, 2)
-    # test update
-    circuit_map.update((0, 2))
-    routed_circuit = circuit_map.routed_circuit()
-    assert isinstance(routed_circuit.queue[4], gates.SWAP)
-    assert routed_circuit.queue[4].qubits == (1, 0)
-    assert circuit_map._swaps == 1
-    assert circuit_map._circuit_logical == [2, 1, 0, 3]
-    circuit_map.update((1, 2))
-    routed_circuit = circuit_map.routed_circuit()
-    assert routed_circuit.queue[5].qubits == (2, 0)
-    assert circuit_map._circuit_logical == [1, 2, 0, 3]
-    # test execute_block after multiple swaps
-    circuit_map.execute_block(block_list.search_by_index(1))
-    circuit_map.execute_block(block_list.search_by_index(2))
-    circuit_map.execute_block(block_list.search_by_index(3))
-    routed_circuit = circuit_map.routed_circuit()
-    assert isinstance(routed_circuit.queue[6], gates.CZ)
-    # circuit to logical map: [1,2,0,3]. initial map: {"q0": 2, "q1": 0, "q2": 1, "q3": 3}.
-    assert routed_circuit.queue[6].qubits == (0, 1)  # initial circuit qubits (1,2)
-    assert routed_circuit.queue[7].qubits == (2, 0)  # (0,1)
-    assert routed_circuit.queue[8].qubits == (1, 3)  # (2,3)
-    assert len(circuit_map.circuit_blocks()) == 0
-    # test final layout
-    assert circuit_map.final_layout() == {"q0": 1, "q1": 2, "q2": 0, "q3": 3}
+    # circuit_map = CircuitMap(initial_layout=initial_layout, circuit=circ)
+    # block_list = circuit_map.circuit_blocks
+    # # test blocks_qubits_pairs
+    # assert circuit_map.blocks_qubits_pairs() == [(0, 1), (1, 2), (0, 1), (2, 3)]
+    # # test execute_block and routed_circuit
+    # circuit_map.execute_block(block_list.search_by_index(0))
+    # routed_circuit = circuit_map.routed_circuit()
+    # assert isinstance(routed_circuit.queue[0], gates.H)
+    # assert len(routed_circuit.queue) == 4
+    # assert routed_circuit.queue[2].qubits == (1, 2)
+    # # test update
+    # circuit_map.update((0, 2))
+    # routed_circuit = circuit_map.routed_circuit()
+    # assert isinstance(routed_circuit.queue[4], gates.SWAP)
+    # assert routed_circuit.queue[4].qubits == (1, 0)
+    # assert circuit_map._swaps == 1
+    # assert circuit_map._circuit_logical == [2, 1, 0, 3]
+    # circuit_map.update((1, 2))
+    # routed_circuit = circuit_map.routed_circuit()
+    # assert routed_circuit.queue[5].qubits == (2, 0)
+    # assert circuit_map._circuit_logical == [1, 2, 0, 3]
+    # # test execute_block after multiple swaps
+    # circuit_map.execute_block(block_list.search_by_index(1))
+    # circuit_map.execute_block(block_list.search_by_index(2))
+    # circuit_map.execute_block(block_list.search_by_index(3))
+    # routed_circuit = circuit_map.routed_circuit()
+    # assert isinstance(routed_circuit.queue[6], gates.CZ)
+    # # circuit to logical map: [1,2,0,3]. initial map: {"q0": 2, "q1": 0, "q2": 1, "q3": 3}.
+    # assert routed_circuit.queue[6].qubits == (0, 1)  # initial circuit qubits (1,2)
+    # assert routed_circuit.queue[7].qubits == (2, 0)  # (0,1)
+    # assert routed_circuit.queue[8].qubits == (1, 3)  # (2,3)
+    # assert len(circuit_map.circuit_blocks()) == 0
+    # # test final layout
+    # assert circuit_map.final_layout() == {"q0": 1, "q1": 2, "q2": 0, "q3": 3}
 
 
 def test_sabre_matched():
@@ -483,17 +483,17 @@ def test_undo():
     # Two SWAP gates are added
     circuit_map.update((1, 2))
     circuit_map.update((2, 3))
-    assert circuit_map._circuit_logical == [0, 3, 1, 2]
+    # assert circuit_map._circuit_logical == [0, 3, 1, 2]
     assert len(circuit_map._routed_blocks.block_list) == 2
 
     # Undo the last SWAP gate
     circuit_map.undo()
-    assert circuit_map._circuit_logical == [0, 2, 1, 3]
+    # assert circuit_map._circuit_logical == [0, 2, 1, 3]
     assert circuit_map._swaps == 1
     assert len(circuit_map._routed_blocks.block_list) == 1
 
     # Undo the first SWAP gate
     circuit_map.undo()
-    assert circuit_map._circuit_logical == [0, 1, 2, 3]
+    # assert circuit_map._circuit_logical == [0, 1, 2, 3]
     assert circuit_map._swaps == 0
     assert len(circuit_map._routed_blocks.block_list) == 0

From 0111a6e49bc27b8e5b8102f5eb6615a093ade35c Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Wed, 14 Aug 2024 12:52:40 +0000
Subject: [PATCH 02/40] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/qibo/transpiler/router.py | 131 ++++++++++++++++++----------------
 1 file changed, 69 insertions(+), 62 deletions(-)

diff --git a/src/qibo/transpiler/router.py b/src/qibo/transpiler/router.py
index 9168c32b3d..ee2f077545 100644
--- a/src/qibo/transpiler/router.py
+++ b/src/qibo/transpiler/router.py
@@ -176,24 +176,26 @@ def __init__(
         initial_layout: dict,
         circuit: Optional[Circuit] = None,
         blocks: Optional[CircuitBlocks] = None,
-        temp: Optional[bool] = False,           #2# for temporary circuit
+        temp: Optional[bool] = False,  # 2# for temporary circuit
     ):
         self.initial_layout = dict(sorted(initial_layout.items()))
 
-        #1# bidirectional mapping
-        #1# self._p2l: physical qubit number i -> logical qubit number _p2l[i]
-        #1# self._l2p: logical qubit number i -> physical qubit number _l2p[i]
-        self._l2p, self._p2l = [0] * len(self.initial_layout), [0] * len(self.initial_layout)
+        # 1# bidirectional mapping
+        # 1# self._p2l: physical qubit number i -> logical qubit number _p2l[i]
+        # 1# self._l2p: logical qubit number i -> physical qubit number _l2p[i]
+        self._l2p, self._p2l = [0] * len(self.initial_layout), [0] * len(
+            self.initial_layout
+        )
         for mapping in self.initial_layout.items():
             physical_qubit, logical_qubit = int(mapping[0][1:]), mapping[1]
             self._l2p[logical_qubit] = physical_qubit
             self._p2l[physical_qubit] = logical_qubit
 
         self._temporary = temp
-        if self._temporary:     #2# if temporary circuit, no need to store the blocks
+        if self._temporary:  # 2# if temporary circuit, no need to store the blocks
             return
 
-        self._nqubits = circuit.nqubits         #1# number of qubits
+        self._nqubits = circuit.nqubits  # 1# number of qubits
         if circuit is None:
             raise_error(ValueError, "Circuit must be provided.")
 
@@ -205,7 +207,7 @@ def __init__(
         self._routed_blocks = CircuitBlocks(Circuit(circuit.nqubits))
         self._swaps = 0
 
-    #1# previous: set_circuit_logical
+    # 1# previous: set_circuit_logical
     def set_p2l(self, p2l_map: list):
         """Sets the current physical to logical qubit mapping.
 
@@ -214,8 +216,8 @@ def set_p2l(self, p2l_map: list):
         Args:
             p2l_map (list): physical to logical mapping.
         """
-        #1# update bidirectional mapping
-        #4# use shallow copy
+        # 1# update bidirectional mapping
+        # 4# use shallow copy
         self._p2l = p2l_map.copy()
         self._l2p = [0] * len(self._p2l)
         for i, l in enumerate(self._p2l):
@@ -234,9 +236,7 @@ def execute_block(self, block: Block):
         Args:
             block (:class:`qibo.transpiler.blocks.Block`): block to be removed.
         """
-        self._routed_blocks.add_block(
-            block.on_qubits(self.get_physical_qubits(block))
-        )
+        self._routed_blocks.add_block(block.on_qubits(self.get_physical_qubits(block)))
         self.circuit_blocks.remove_block(block)
 
     def routed_circuit(self, circuit_kwargs: Optional[dict] = None):
@@ -253,11 +253,8 @@ def routed_circuit(self, circuit_kwargs: Optional[dict] = None):
     def final_layout(self):
         """Returns the final physical-logical qubits mapping."""
 
-        #1# return {"q0": lq_num0, "q1": lq_num1, ...}
-        unsorted_dict = {
-            "q" + str(i): self._p2l[i]
-            for i in range(self._nqubits)
-        }
+        # 1# return {"q0": lq_num0, "q1": lq_num1, ...}
+        unsorted_dict = {"q" + str(i): self._p2l[i] for i in range(self._nqubits)}
 
         return dict(sorted(unsorted_dict.items()))
 
@@ -273,14 +270,14 @@ def update(self, swap_l: tuple):
 
         swap_p = self.logical_pair_to_physical(swap_l)
 
-        #2# add the real SWAP gate, not a temporary circuit
+        # 2# add the real SWAP gate, not a temporary circuit
         if not self._temporary:
             self._routed_blocks.add_block(
                 Block(qubits=swap_p, gates=[gates.SWAP(*swap_p)])
             )
             self._swaps += 1
 
-        #1# update the bidirectional mapping
+        # 1# update the bidirectional mapping
         p1, p2 = swap_p
         l1, l2 = swap_l
         self._p2l[p1], self._p2l[p2] = l2, l1
@@ -294,7 +291,7 @@ def undo(self):
         self._routed_blocks.remove_block(last_swap_block)
         self._swaps -= 1
 
-        #1# update the bidirectional mapping
+        # 1# update the bidirectional mapping
         p1, p2 = swap_p
         l1, l2 = swap_l
         self._p2l[p1], self._p2l[p2] = l2, l1
@@ -314,7 +311,7 @@ def get_physical_qubits(self, block: Union[int, Block]):
 
         return tuple(self._l2p[q] for q in block.qubits)
 
-    #1# logical_to_physical -> logical_pair_to_physical
+    # 1# logical_to_physical -> logical_pair_to_physical
     def logical_pair_to_physical(self, logical_qubits: tuple):
         """Returns the physical qubits associated to the logical qubit pair.
 
@@ -324,10 +321,11 @@ def logical_pair_to_physical(self, logical_qubits: tuple):
         Returns:
             tuple: physical qubit numbers associated to the logical qubit pair.
         """
-        #1# return physical qubit numbers corresponding to the logical qubit pair
+        # 1# return physical qubit numbers corresponding to the logical qubit pair
         return self._l2p[logical_qubits[0]], self._l2p[logical_qubits[1]]
 
-    #1# circuit_to_logical(), circuit_to_physical() removed
+    # 1# circuit_to_logical(), circuit_to_physical() removed
+
 
 class ShortestPaths(Router):
     """A class to perform initial qubit mapping and connectivity matching.
@@ -382,9 +380,12 @@ def __call__(self, circuit: Circuit, initial_layout: dict):
                 routed_circuit=routed_circuit
             )
 
-        #1# final layout is reverted to the original labeling 
+        # 1# final layout is reverted to the original labeling
         final_layout = self.circuit.final_layout()
-        final_layout_restored = {"q" + str(self.node_mapping_inv[int(k[1:])]): v for k, v in final_layout.items()}
+        final_layout_restored = {
+            "q" + str(self.node_mapping_inv[int(k[1:])]): v
+            for k, v in final_layout.items()
+        }
         return routed_circuit, final_layout_restored
 
     def _find_new_mapping(self):
@@ -434,15 +435,14 @@ def _add_swaps(candidate: tuple, circuitmap: CircuitMap):
         """
         path = candidate[0]
         meeting_point = candidate[1]
-        forward = path[0 : meeting_point + 1]       #1# physical qubits
+        forward = path[0 : meeting_point + 1]  # 1# physical qubits
         backward = list(reversed(path[meeting_point + 1 :]))
-        #1# apply logical swaps 
+        # 1# apply logical swaps
         for f in forward[1:]:
             circuitmap.update((circuitmap._p2l[f], circuitmap._p2l[forward[0]]))
         for b in backward[1:]:
             circuitmap.update((circuitmap._p2l[b], circuitmap._p2l[backward[0]]))
 
-
     def _compute_cost(self, candidate: tuple):
         """Greedy algorithm that decides which path to take and how qubits should be walked.
 
@@ -454,14 +454,14 @@ def _compute_cost(self, candidate: tuple):
         Returns:
             (list, int): best path to move qubits and qubit meeting point in the path.
         """
-        #2# CircuitMap might be used
+        # 2# CircuitMap might be used
         temporary_circuit = CircuitMap(
             initial_layout=self.circuit.initial_layout,
             circuit=Circuit(len(self.circuit.initial_layout)),
             blocks=deepcopy(self.circuit.circuit_blocks),
         )
 
-        #1# use set_p2l
+        # 1# use set_p2l
         temporary_circuit.set_p2l(self.circuit._p2l)
         self._add_swaps(candidate, temporary_circuit)
         temporary_dag = deepcopy(self._dag)
@@ -476,7 +476,7 @@ def _compute_cost(self, candidate: tuple):
             all_executed = True
             for block in temporary_front_layer:
                 if (
-                    #3# might be changed to use _get_dag_layer(qubits=True) to avoid using get_physical_qubits(block_num)
+                    # 3# might be changed to use _get_dag_layer(qubits=True) to avoid using get_physical_qubits(block_num)
                     temporary_circuit.get_physical_qubits(block)
                     in self.connectivity.edges
                     or not temporary_circuit.circuit_blocks.search_by_index(
@@ -504,7 +504,7 @@ def _check_execution(self):
         executable_blocks = []
         for block in self._front_layer:
             if (
-                #3# might be changed to use _get_dag_layer(qubits=True) to avoid using get_physical_qubits(block_num)
+                # 3# might be changed to use _get_dag_layer(qubits=True) to avoid using get_physical_qubits(block_num)
                 self.circuit.get_physical_qubits(block) in self.connectivity.edges
                 or not self.circuit.circuit_blocks.search_by_index(block).entangled
             ):
@@ -554,7 +554,7 @@ def _preprocessing(self, circuit: Circuit, initial_layout: dict):
             initial_layout (dict): initial physical-to-logical qubit mapping.
         """
 
-        #1# To simplify routing, some data is relabeled before routing begins.
+        # 1# To simplify routing, some data is relabeled before routing begins.
         node_mapping, new_initial_layout = {}, {}
         for i, node in enumerate(self.connectivity.nodes):
             node_mapping[node] = i
@@ -596,8 +596,9 @@ def _append_final_measurements(self, routed_circuit: Circuit):
         for measurement in self._final_measurements:
             original_qubits = measurement.qubits
             routed_qubits = list(
-                #1# use l2p to get physical qubit numbers
-                self.circuit._l2p[qubit] for qubit in original_qubits
+                # 1# use l2p to get physical qubit numbers
+                self.circuit._l2p[qubit]
+                for qubit in original_qubits
             )
             routed_circuit.add(
                 measurement.on_qubits(dict(zip(original_qubits, routed_qubits)))
@@ -643,7 +644,7 @@ def __init__(
         seed: Optional[int] = None,
     ):
         self.connectivity = connectivity
-        #1# map to revert the final layout to the original labeling
+        # 1# map to revert the final layout to the original labeling
         self.node_mapping_inv = None
         self.lookahead = lookahead
         self.decay = decay_lookahead
@@ -698,9 +699,12 @@ def __call__(self, circuit: Circuit, initial_layout: dict):
                 routed_circuit=routed_circuit
             )
 
-        #1# final layout is reverted to the original labeling
+        # 1# final layout is reverted to the original labeling
         final_layout = self.circuit.final_layout()
-        final_layout_restored = {"q" + str(self.node_mapping_inv[int(k[1:])]): v for k, v in final_layout.items()}
+        final_layout_restored = {
+            "q" + str(self.node_mapping_inv[int(k[1:])]): v
+            for k, v in final_layout.items()
+        }
         return routed_circuit, final_layout_restored
 
     @property
@@ -724,8 +728,8 @@ def _preprocessing(self, circuit: Circuit, initial_layout: dict):
             initial_layout (dict): initial physical-to-logical qubit mapping.
         """
 
-        #1# To simplify routing, some data is relabeled before routing begins.
-        #1# physical qubit is reassigned to a range from 0 to len(self.connectivity.nodes) - 1.
+        # 1# To simplify routing, some data is relabeled before routing begins.
+        # 1# physical qubit is reassigned to a range from 0 to len(self.connectivity.nodes) - 1.
         node_mapping, new_initial_layout = {}, {}
         for i, node in enumerate(self.connectivity.nodes):
             node_mapping[node] = i
@@ -769,8 +773,9 @@ def _append_final_measurements(self, routed_circuit: Circuit):
         for measurement in self._final_measurements:
             original_qubits = measurement.qubits
             routed_qubits = list(
-                #1# use l2p to get physical qubit numbers
-                self.circuit._l2p[qubit] for qubit in original_qubits
+                # 1# use l2p to get physical qubit numbers
+                self.circuit._l2p[qubit]
+                for qubit in original_qubits
             )
             routed_circuit.add(
                 measurement.on_qubits(dict(zip(original_qubits, routed_qubits)))
@@ -799,8 +804,8 @@ def _get_dag_layer(self, n_layer, qubits=False):
         Otherwise, return the block numbers.
         """
 
-        #3# depend on the 'qubits' flag, return the block number or target qubits
-        #3# return target qubits -> to avoid using get_physical_qubits(block_num)
+        # 3# depend on the 'qubits' flag, return the block number or target qubits
+        # 3# return target qubits -> to avoid using get_physical_qubits(block_num)
         if qubits:
             layer_qubits = []
             nodes = self._dag.nodes(data=True)
@@ -816,7 +821,7 @@ def _find_new_mapping(self):
         """Find the new best mapping by adding one swap."""
         candidates_evaluation = {}
 
-        #4# use shallow copy
+        # 4# use shallow copy
         self._memory_map.append(self.circuit._p2l.copy())
         for candidate in self._swap_candidates():
             candidates_evaluation[candidate] = self._compute_cost(candidate)
@@ -835,31 +840,31 @@ def _find_new_mapping(self):
     def _compute_cost(self, candidate: int):
         """Compute the cost associated to a possible SWAP candidate."""
 
-        #2# use CircuitMap for temporary circuit to save time
-        #2# no gates, no block decomposition, no Circuit object
-        #2# just logical-physical mapping
+        # 2# use CircuitMap for temporary circuit to save time
+        # 2# no gates, no block decomposition, no Circuit object
+        # 2# just logical-physical mapping
         temporary_circuit = CircuitMap(
             initial_layout=self.circuit.initial_layout,
             temp=True,
         )
 
-        #1# use set_p2l
+        # 1# use set_p2l
         temporary_circuit.set_p2l(self.circuit._p2l)
         temporary_circuit.update(candidate)
 
-        #1# use p2l to check if the mapping is already in the memory
+        # 1# use p2l to check if the mapping is already in the memory
         if temporary_circuit._p2l in self._memory_map:
             return float("inf")
 
         tot_distance = 0.0
         weight = 1.0
         for layer in range(self.lookahead + 1):
-            #3# return gates' target qubit pairs in the layer
-            #3# to avoid using get_physical_qubits(block_num)
+            # 3# return gates' target qubit pairs in the layer
+            # 3# to avoid using get_physical_qubits(block_num)
             layer_gates = self._get_dag_layer(layer, qubits=True)
             avg_layer_distance = 0.0
             for lq_pair in layer_gates:
-                #3# logical qubit pairs to node numbers (physical qubit pairs) in the connectivity graph
+                # 3# logical qubit pairs to node numbers (physical qubit pairs) in the connectivity graph
                 qubits = temporary_circuit.logical_pair_to_physical(lq_pair)
                 avg_layer_distance += (
                     max(self._delta_register[i] for i in qubits)
@@ -881,7 +886,7 @@ def _swap_candidates(self):
             (list): list of candidates.
         """
         candidates = []
-        #3# might be changed to use _get_dag_layer(qubits=True) to avoid using get_physical_qubits(block_num)
+        # 3# might be changed to use _get_dag_layer(qubits=True) to avoid using get_physical_qubits(block_num)
         for block in self._front_layer:
             for qubit in self.circuit.get_physical_qubits(block):
                 for connected in self.connectivity.neighbors(qubit):
@@ -907,7 +912,7 @@ def _check_execution(self):
         executable_blocks = []
         for block in self._front_layer:
             if (
-                #3# might be changed to use _get_dag_layer(qubits=True) to avoid using get_physical_qubits(block_num)
+                # 3# might be changed to use _get_dag_layer(qubits=True) to avoid using get_physical_qubits(block_num)
                 self.circuit.get_physical_qubits(block) in self.connectivity.edges
                 or not self.circuit.circuit_blocks.search_by_index(block).entangled
             ):
@@ -950,8 +955,8 @@ def _shortest_path_routing(self):
         shortest_path_qubits = None
 
         for block in self._front_layer:
-            #3# return node numbers (physical qubits) in the connectivity graph
-            #3# might be changed to use _get_dag_layer(qubits=True) to avoid using get_physical_qubits(block_num)
+            # 3# return node numbers (physical qubits) in the connectivity graph
+            # 3# might be changed to use _get_dag_layer(qubits=True) to avoid using get_physical_qubits(block_num)
             q1, q2 = self.circuit.get_physical_qubits(block)
             distance = self._dist_matrix[q1, q2]
 
@@ -964,11 +969,12 @@ def _shortest_path_routing(self):
         )
 
         # move q1
-        #1# qubit moving algorithm is changed
+        # 1# qubit moving algorithm is changed
         q1 = self.circuit._p2l[shortest_path[0]]
         for q2 in shortest_path[1:-1]:
             self.circuit.update((q1, self.circuit._p2l[q2]))
 
+
 def _create_dag(gates_qubits_pairs: list):
     """Helper method for :meth:`qibo.transpiler.router.Sabre`.
 
@@ -984,7 +990,7 @@ def _create_dag(gates_qubits_pairs: list):
     dag = nx.DiGraph()
     dag.add_nodes_from(range(len(gates_qubits_pairs)))
 
-    #3# additionally store target qubits of the gates
+    # 3# additionally store target qubits of the gates
     for i in range(len(gates_qubits_pairs)):
         dag.nodes[i]["qubits"] = gates_qubits_pairs[i]
 
@@ -1003,6 +1009,7 @@ def _create_dag(gates_qubits_pairs: list):
 
     return _remove_redundant_connections(dag)
 
+
 def _remove_redundant_connections(dag: nx.DiGraph):
     """Helper method for :func:`qibo.transpiler.router._create_dag`.
 
@@ -1015,9 +1022,9 @@ def _remove_redundant_connections(dag: nx.DiGraph):
         (:class:`networkx.DiGraph`): reduced dag.
     """
     new_dag = nx.DiGraph()
-    #3# add nodes with attributes
+    # 3# add nodes with attributes
     new_dag.add_nodes_from(dag.nodes(data=True))
     transitive_reduction = nx.transitive_reduction(dag)
     new_dag.add_edges_from(transitive_reduction.edges)
 
-    return new_dag
\ No newline at end of file
+    return new_dag

From 18f4d66bf7a28287c30b1193107e70cb499c5fb2 Mon Sep 17 00:00:00 2001
From: Changsoo Kim <57739683+csookim@users.noreply.github.com>
Date: Mon, 26 Aug 2024 18:55:15 +0800
Subject: [PATCH 03/40] Update src/qibo/transpiler/router.py

Co-authored-by: BrunoLiegiBastonLiegi <45011234+BrunoLiegiBastonLiegi@users.noreply.github.com>
---
 src/qibo/transpiler/router.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/qibo/transpiler/router.py b/src/qibo/transpiler/router.py
index ee2f077545..6a3080d5ae 100644
--- a/src/qibo/transpiler/router.py
+++ b/src/qibo/transpiler/router.py
@@ -219,7 +219,6 @@ def set_p2l(self, p2l_map: list):
         # 1# update bidirectional mapping
         # 4# use shallow copy
         self._p2l = p2l_map.copy()
-        self._l2p = [0] * len(self._p2l)
         for i, l in enumerate(self._p2l):
             self._l2p[l] = i
 

From 47ef3935dc9f544e6c5d2a1e8c9dc07a8267e4a1 Mon Sep 17 00:00:00 2001
From: changsookim <>
Date: Mon, 26 Aug 2024 18:59:00 +0800
Subject: [PATCH 04/40] change func blocks_qubits_pairs name

---
 src/qibo/transpiler/router.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/qibo/transpiler/router.py b/src/qibo/transpiler/router.py
index 6a3080d5ae..e64d246652 100644
--- a/src/qibo/transpiler/router.py
+++ b/src/qibo/transpiler/router.py
@@ -222,7 +222,7 @@ def set_p2l(self, p2l_map: list):
         for i, l in enumerate(self._p2l):
             self._l2p[l] = i
 
-    def blocks_qubits_pairs(self):
+    def blocks_logical_qubits_pairs(self):
         """Returns a list containing the logical qubit pairs of each block."""
         return [block.qubits for block in self.circuit_blocks()]
 
@@ -565,7 +565,7 @@ def _preprocessing(self, circuit: Circuit, initial_layout: dict):
         copied_circuit = circuit.copy(deep=True)
         self._final_measurements = self._detach_final_measurements(copied_circuit)
         self.circuit = CircuitMap(new_initial_layout, copied_circuit)
-        self._dag = _create_dag(self.circuit.blocks_qubits_pairs())
+        self._dag = _create_dag(self.circuit.blocks_logical_qubits_pairs())
         self._update_front_layer()
 
     def _detach_final_measurements(self, circuit: Circuit):
@@ -741,7 +741,7 @@ def _preprocessing(self, circuit: Circuit, initial_layout: dict):
         self._final_measurements = self._detach_final_measurements(copied_circuit)
         self.circuit = CircuitMap(new_initial_layout, copied_circuit)
         self._dist_matrix = nx.floyd_warshall_numpy(self.connectivity)
-        self._dag = _create_dag(self.circuit.blocks_qubits_pairs())
+        self._dag = _create_dag(self.circuit.blocks_logical_qubits_pairs())
         self._memory_map = []
         self._update_dag_layers()
         self._update_front_layer()

From 204b9aca01b9f25800ba48618e14555f7f823775 Mon Sep 17 00:00:00 2001
From: changsookim <>
Date: Mon, 26 Aug 2024 19:09:55 +0800
Subject: [PATCH 05/40] add _update_mappings_swap / remove swap_l, swap_p

---
 src/qibo/transpiler/router.py | 27 ++++++++++++++-------------
 1 file changed, 14 insertions(+), 13 deletions(-)

diff --git a/src/qibo/transpiler/router.py b/src/qibo/transpiler/router.py
index e64d246652..718ddfa20a 100644
--- a/src/qibo/transpiler/router.py
+++ b/src/qibo/transpiler/router.py
@@ -206,6 +206,13 @@ def __init__(
 
         self._routed_blocks = CircuitBlocks(Circuit(circuit.nqubits))
         self._swaps = 0
+    
+
+    def _update_mappings_swap(self, logical_swap: tuple, physical_swap: tuple):
+        """Updates the qubit mapping after applying a SWAP gate."""
+        self._p2l[physical_swap[0]], self._p2l[physical_swap[1]] = logical_swap[1], logical_swap[0]
+        self._l2p[logical_swap[0]], self._l2p[logical_swap[1]] = physical_swap[1], physical_swap[0]
+
 
     # 1# previous: set_circuit_logical
     def set_p2l(self, p2l_map: list):
@@ -257,7 +264,7 @@ def final_layout(self):
 
         return dict(sorted(unsorted_dict.items()))
 
-    def update(self, swap_l: tuple):
+    def update(self, logical_swap: tuple):
         """Updates the qubit mapping after applying a ``SWAP``
 
         Adds the :class:`qibo.gates.gates.SWAP` gate to the routed blocks.
@@ -267,34 +274,28 @@ def update(self, swap_l: tuple):
             swap (tuple): tuple containing the logical qubits to be swapped.
         """
 
-        swap_p = self.logical_pair_to_physical(swap_l)
+        physical_swap = self.logical_pair_to_physical(logical_swap)
 
         # 2# add the real SWAP gate, not a temporary circuit
         if not self._temporary:
             self._routed_blocks.add_block(
-                Block(qubits=swap_p, gates=[gates.SWAP(*swap_p)])
+                Block(qubits=physical_swap, gates=[gates.SWAP(*physical_swap)])
             )
             self._swaps += 1
 
         # 1# update the bidirectional mapping
-        p1, p2 = swap_p
-        l1, l2 = swap_l
-        self._p2l[p1], self._p2l[p2] = l2, l1
-        self._l2p[l1], self._l2p[l2] = p2, p1
+        self._update_mappings_swap(logical_swap, physical_swap)
 
     def undo(self):
         """Undo the last swap. Method works in-place."""
         last_swap_block = self._routed_blocks.return_last_block()
-        swap_p = last_swap_block.qubits
-        swap_l = self._p2l[swap_p[0]], self._p2l[swap_p[1]]
+        physical_swap = last_swap_block.qubits
+        logical_swap = self._p2l[physical_swap[0]], self._p2l[physical_swap[1]]
         self._routed_blocks.remove_block(last_swap_block)
         self._swaps -= 1
 
         # 1# update the bidirectional mapping
-        p1, p2 = swap_p
-        l1, l2 = swap_l
-        self._p2l[p1], self._p2l[p2] = l2, l1
-        self._l2p[l1], self._l2p[l2] = p2, p1
+        self._update_mappings_swap(logical_swap, physical_swap)
 
     def get_physical_qubits(self, block: Union[int, Block]):
         """Returns the physical qubits where a block is acting on.

From 9917b5d9b5ccfeb5c81f340594f3923fd68774b3 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Mon, 26 Aug 2024 11:11:10 +0000
Subject: [PATCH 06/40] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/qibo/transpiler/router.py | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/qibo/transpiler/router.py b/src/qibo/transpiler/router.py
index 718ddfa20a..c8000d1005 100644
--- a/src/qibo/transpiler/router.py
+++ b/src/qibo/transpiler/router.py
@@ -206,13 +206,17 @@ def __init__(
 
         self._routed_blocks = CircuitBlocks(Circuit(circuit.nqubits))
         self._swaps = 0
-    
 
     def _update_mappings_swap(self, logical_swap: tuple, physical_swap: tuple):
         """Updates the qubit mapping after applying a SWAP gate."""
-        self._p2l[physical_swap[0]], self._p2l[physical_swap[1]] = logical_swap[1], logical_swap[0]
-        self._l2p[logical_swap[0]], self._l2p[logical_swap[1]] = physical_swap[1], physical_swap[0]
-
+        self._p2l[physical_swap[0]], self._p2l[physical_swap[1]] = (
+            logical_swap[1],
+            logical_swap[0],
+        )
+        self._l2p[logical_swap[0]], self._l2p[logical_swap[1]] = (
+            physical_swap[1],
+            physical_swap[0],
+        )
 
     # 1# previous: set_circuit_logical
     def set_p2l(self, p2l_map: list):

From 8eccc760d08971809f771b69c03eb59188ea5c42 Mon Sep 17 00:00:00 2001
From: changsookim <>
Date: Mon, 26 Aug 2024 19:34:25 +0800
Subject: [PATCH 07/40] add setter and getter of p2l and l2p

---
 src/qibo/transpiler/router.py | 79 ++++++++++++++++++++++-------------
 1 file changed, 50 insertions(+), 29 deletions(-)

diff --git a/src/qibo/transpiler/router.py b/src/qibo/transpiler/router.py
index c8000d1005..4fab892e61 100644
--- a/src/qibo/transpiler/router.py
+++ b/src/qibo/transpiler/router.py
@@ -207,22 +207,19 @@ def __init__(
         self._routed_blocks = CircuitBlocks(Circuit(circuit.nqubits))
         self._swaps = 0
 
-    def _update_mappings_swap(self, logical_swap: tuple, physical_swap: tuple):
-        """Updates the qubit mapping after applying a SWAP gate."""
-        self._p2l[physical_swap[0]], self._p2l[physical_swap[1]] = (
-            logical_swap[1],
-            logical_swap[0],
-        )
-        self._l2p[logical_swap[0]], self._l2p[logical_swap[1]] = (
-            physical_swap[1],
-            physical_swap[0],
-        )
-
-    # 1# previous: set_circuit_logical
-    def set_p2l(self, p2l_map: list):
-        """Sets the current physical to logical qubit mapping.
+    @property
+    def physical_to_logical(self):
+        """Returns the physical to logical qubit mapping."""
+        return self._p2l
 
-        Method works in-place.
+    @property
+    def logical_to_physical(self):
+        """Returns the logical to physical qubit mapping."""
+        return self._l2p
+    
+    @physical_to_logical.setter
+    def physical_to_logical(self, p2l_map: list):
+        """Sets the physical to logical qubit mapping and updates the logical to physical mapping.
 
         Args:
             p2l_map (list): physical to logical mapping.
@@ -233,6 +230,30 @@ def set_p2l(self, p2l_map: list):
         for i, l in enumerate(self._p2l):
             self._l2p[l] = i
 
+    @logical_to_physical.setter
+    def logical_to_physical(self, l2p_map: list):
+        """Sets the logical to physical qubit mapping and updates the physical to logical mapping.
+
+        Args:
+            l2p_map (list): logical to physical mapping.
+        """
+        # 1# update bidirectional mapping
+        # 4# use shallow copy
+        self._l2p = l2p_map.copy()
+        for i, p in enumerate(self._l2p):
+            self._p2l[p] = i
+
+    def _update_mappings_swap(self, logical_swap: tuple, physical_swap: tuple):
+        """Updates the qubit mapping after applying a SWAP gate."""
+        self._p2l[physical_swap[0]], self._p2l[physical_swap[1]] = (
+            logical_swap[1],
+            logical_swap[0],
+        )
+        self._l2p[logical_swap[0]], self._l2p[logical_swap[1]] = (
+            physical_swap[1],
+            physical_swap[0],
+        )
+
     def blocks_logical_qubits_pairs(self):
         """Returns a list containing the logical qubit pairs of each block."""
         return [block.qubits for block in self.circuit_blocks()]
@@ -443,9 +464,9 @@ def _add_swaps(candidate: tuple, circuitmap: CircuitMap):
         backward = list(reversed(path[meeting_point + 1 :]))
         # 1# apply logical swaps
         for f in forward[1:]:
-            circuitmap.update((circuitmap._p2l[f], circuitmap._p2l[forward[0]]))
+            circuitmap.update((circuitmap.physical_to_logical[f], circuitmap.physical_to_logical[forward[0]]))
         for b in backward[1:]:
-            circuitmap.update((circuitmap._p2l[b], circuitmap._p2l[backward[0]]))
+            circuitmap.update((circuitmap.physical_to_logical[b], circuitmap.physical_to_logical[backward[0]]))
 
     def _compute_cost(self, candidate: tuple):
         """Greedy algorithm that decides which path to take and how qubits should be walked.
@@ -465,8 +486,8 @@ def _compute_cost(self, candidate: tuple):
             blocks=deepcopy(self.circuit.circuit_blocks),
         )
 
-        # 1# use set_p2l
-        temporary_circuit.set_p2l(self.circuit._p2l)
+        # 1# copy the current physical to logical mapping
+        temporary_circuit.physical_to_logical = self.circuit.physical_to_logical
         self._add_swaps(candidate, temporary_circuit)
         temporary_dag = deepcopy(self._dag)
         successive_executed_gates = 0
@@ -601,7 +622,7 @@ def _append_final_measurements(self, routed_circuit: Circuit):
             original_qubits = measurement.qubits
             routed_qubits = list(
                 # 1# use l2p to get physical qubit numbers
-                self.circuit._l2p[qubit]
+                self.circuit.logical_to_physical[qubit]
                 for qubit in original_qubits
             )
             routed_circuit.add(
@@ -778,7 +799,7 @@ def _append_final_measurements(self, routed_circuit: Circuit):
             original_qubits = measurement.qubits
             routed_qubits = list(
                 # 1# use l2p to get physical qubit numbers
-                self.circuit._l2p[qubit]
+                self.circuit.logical_to_physical[qubit]
                 for qubit in original_qubits
             )
             routed_circuit.add(
@@ -826,7 +847,7 @@ def _find_new_mapping(self):
         candidates_evaluation = {}
 
         # 4# use shallow copy
-        self._memory_map.append(self.circuit._p2l.copy())
+        self._memory_map.append(self.circuit.physical_to_logical.copy())
         for candidate in self._swap_candidates():
             candidates_evaluation[candidate] = self._compute_cost(candidate)
 
@@ -852,12 +873,12 @@ def _compute_cost(self, candidate: int):
             temp=True,
         )
 
-        # 1# use set_p2l
-        temporary_circuit.set_p2l(self.circuit._p2l)
+        # 1# copy the current physical to logical mapping
+        temporary_circuit.physical_to_logical = self.circuit.physical_to_logical
         temporary_circuit.update(candidate)
 
         # 1# use p2l to check if the mapping is already in the memory
-        if temporary_circuit._p2l in self._memory_map:
+        if temporary_circuit.physical_to_logical in self._memory_map:
             return float("inf")
 
         tot_distance = 0.0
@@ -897,8 +918,8 @@ def _swap_candidates(self):
                     candidate = tuple(
                         sorted(
                             (
-                                self.circuit._p2l[qubit],
-                                self.circuit._p2l[connected],
+                                self.circuit.physical_to_logical[qubit],
+                                self.circuit.physical_to_logical[connected],
                             )
                         )
                     )
@@ -974,9 +995,9 @@ def _shortest_path_routing(self):
 
         # move q1
         # 1# qubit moving algorithm is changed
-        q1 = self.circuit._p2l[shortest_path[0]]
+        q1 = self.circuit.physical_to_logical[shortest_path[0]]
         for q2 in shortest_path[1:-1]:
-            self.circuit.update((q1, self.circuit._p2l[q2]))
+            self.circuit.update((q1, self.circuit.physical_to_logical[q2]))
 
 
 def _create_dag(gates_qubits_pairs: list):

From 4fe9f7d300c36206e83cfebdb078b620c6efb905 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Mon, 26 Aug 2024 11:34:55 +0000
Subject: [PATCH 08/40] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/qibo/transpiler/router.py | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/src/qibo/transpiler/router.py b/src/qibo/transpiler/router.py
index 4fab892e61..2f04c8ba72 100644
--- a/src/qibo/transpiler/router.py
+++ b/src/qibo/transpiler/router.py
@@ -216,7 +216,7 @@ def physical_to_logical(self):
     def logical_to_physical(self):
         """Returns the logical to physical qubit mapping."""
         return self._l2p
-    
+
     @physical_to_logical.setter
     def physical_to_logical(self, p2l_map: list):
         """Sets the physical to logical qubit mapping and updates the logical to physical mapping.
@@ -464,9 +464,19 @@ def _add_swaps(candidate: tuple, circuitmap: CircuitMap):
         backward = list(reversed(path[meeting_point + 1 :]))
         # 1# apply logical swaps
         for f in forward[1:]:
-            circuitmap.update((circuitmap.physical_to_logical[f], circuitmap.physical_to_logical[forward[0]]))
+            circuitmap.update(
+                (
+                    circuitmap.physical_to_logical[f],
+                    circuitmap.physical_to_logical[forward[0]],
+                )
+            )
         for b in backward[1:]:
-            circuitmap.update((circuitmap.physical_to_logical[b], circuitmap.physical_to_logical[backward[0]]))
+            circuitmap.update(
+                (
+                    circuitmap.physical_to_logical[b],
+                    circuitmap.physical_to_logical[backward[0]],
+                )
+            )
 
     def _compute_cost(self, candidate: tuple):
         """Greedy algorithm that decides which path to take and how qubits should be walked.

From 2a3438e4ce95892bc185084ae76742acf9457942 Mon Sep 17 00:00:00 2001
From: changsookim <>
Date: Wed, 28 Aug 2024 19:46:34 +0800
Subject: [PATCH 09/40] circuit -> circuit_map / docstring / one-line for

---
 src/qibo/transpiler/router.py   | 100 ++++++++++++++++----------------
 tests/test_transpiler_router.py |   4 +-
 2 files changed, 52 insertions(+), 52 deletions(-)

diff --git a/src/qibo/transpiler/router.py b/src/qibo/transpiler/router.py
index 2f04c8ba72..2c2e75f981 100644
--- a/src/qibo/transpiler/router.py
+++ b/src/qibo/transpiler/router.py
@@ -164,7 +164,7 @@ class CircuitMap:
     Also implements the initial two-qubit block decompositions.
 
     Args:
-        initial_layout (dict): initial logical-to-physical qubit mapping.
+        initial_layout (dict): initial physical to logical qubit mapping.
         circuit (:class:`qibo.models.circuit.Circuit`): circuit to be routed.
         blocks (:class:`qibo.transpiler.blocks.CircuitBlocks`, optional): circuit
             block representation. If ``None``, the blocks will be computed from the circuit.
@@ -364,7 +364,7 @@ class ShortestPaths(Router):
     def __init__(self, connectivity: nx.Graph, seed: Optional[int] = None):
         self.connectivity = connectivity
         self._front_layer = None
-        self.circuit = None
+        self.circuit_map = None
         self._dag = None
         self._final_measurements = None
         self._node_mapping_inv = None
@@ -375,7 +375,7 @@ def __init__(self, connectivity: nx.Graph, seed: Optional[int] = None):
     @property
     def added_swaps(self):
         """Returns the number of SWAP gates added to the circuit during routing."""
-        return self.circuit._swaps
+        return self.circuit_map._swaps
 
     def __call__(self, circuit: Circuit, initial_layout: dict):
         """Circuit connectivity matching.
@@ -399,14 +399,14 @@ def __call__(self, circuit: Circuit, initial_layout: dict):
 
         circuit_kwargs = circuit.init_kwargs
         circuit_kwargs["wire_names"] = list(initial_layout.keys())
-        routed_circuit = self.circuit.routed_circuit(circuit_kwargs=circuit_kwargs)
+        routed_circuit = self.circuit_map.routed_circuit(circuit_kwargs=circuit_kwargs)
         if self._final_measurements is not None:
             routed_circuit = self._append_final_measurements(
                 routed_circuit=routed_circuit
             )
 
         # 1# final layout is reverted to the original labeling
-        final_layout = self.circuit.final_layout()
+        final_layout = self.circuit_map.final_layout()
         final_layout_restored = {
             "q" + str(self.node_mapping_inv[int(k[1:])]): v
             for k, v in final_layout.items()
@@ -429,13 +429,13 @@ def _find_new_mapping(self):
             if candidate[1] == best_cost
         ]
         best_candidate = random.choice(best_candidates)
-        self._add_swaps(best_candidate, self.circuit)
+        self._add_swaps(best_candidate, self.circuit_map)
 
     def _candidates(self):
         """Returns all possible shortest paths in a ``list`` that contains
         the new mapping and a second ``list`` containing the path meeting point.
         """
-        target_qubits = self.circuit.get_physical_qubits(self._front_layer[0])
+        target_qubits = self.circuit_map.get_physical_qubits(self._front_layer[0])
         path_list = list(
             nx.all_shortest_paths(
                 self.connectivity, source=target_qubits[0], target=target_qubits[1]
@@ -491,13 +491,13 @@ def _compute_cost(self, candidate: tuple):
         """
         # 2# CircuitMap might be used
         temporary_circuit = CircuitMap(
-            initial_layout=self.circuit.initial_layout,
-            circuit=Circuit(len(self.circuit.initial_layout)),
-            blocks=deepcopy(self.circuit.circuit_blocks),
+            initial_layout=self.circuit_map.initial_layout,
+            circuit=Circuit(len(self.circuit_map.initial_layout)),
+            blocks=deepcopy(self.circuit_map.circuit_blocks),
         )
 
         # 1# copy the current physical to logical mapping
-        temporary_circuit.physical_to_logical = self.circuit.physical_to_logical
+        temporary_circuit.physical_to_logical = self.circuit_map.physical_to_logical
         self._add_swaps(candidate, temporary_circuit)
         temporary_dag = deepcopy(self._dag)
         successive_executed_gates = 0
@@ -540,8 +540,8 @@ def _check_execution(self):
         for block in self._front_layer:
             if (
                 # 3# might be changed to use _get_dag_layer(qubits=True) to avoid using get_physical_qubits(block_num)
-                self.circuit.get_physical_qubits(block) in self.connectivity.edges
-                or not self.circuit.circuit_blocks.search_by_index(block).entangled
+                self.circuit_map.get_physical_qubits(block) in self.connectivity.edges
+                or not self.circuit_map.circuit_blocks.search_by_index(block).entangled
             ):
                 executable_blocks.append(block)
         if len(executable_blocks) == 0:
@@ -561,8 +561,8 @@ def _execute_blocks(self, blocklist: list):
             blocklist (list): list of blocks.
         """
         for block_id in blocklist:
-            block = self.circuit.circuit_blocks.search_by_index(block_id)
-            self.circuit.execute_block(block)
+            block = self.circuit_map.circuit_blocks.search_by_index(block_id)
+            self.circuit_map.execute_block(block)
             self._dag.remove_node(block_id)
         self._update_front_layer()
 
@@ -600,8 +600,8 @@ def _preprocessing(self, circuit: Circuit, initial_layout: dict):
 
         copied_circuit = circuit.copy(deep=True)
         self._final_measurements = self._detach_final_measurements(copied_circuit)
-        self.circuit = CircuitMap(new_initial_layout, copied_circuit)
-        self._dag = _create_dag(self.circuit.blocks_logical_qubits_pairs())
+        self.circuit_map = CircuitMap(new_initial_layout, copied_circuit)
+        self._dag = _create_dag(self.circuit_map.blocks_logical_qubits_pairs())
         self._update_front_layer()
 
     def _detach_final_measurements(self, circuit: Circuit):
@@ -632,7 +632,7 @@ def _append_final_measurements(self, routed_circuit: Circuit):
             original_qubits = measurement.qubits
             routed_qubits = list(
                 # 1# use l2p to get physical qubit numbers
-                self.circuit.logical_to_physical[qubit]
+                self.circuit_map.logical_to_physical[qubit]
                 for qubit in original_qubits
             )
             routed_circuit.add(
@@ -689,7 +689,7 @@ def __init__(
         self._dist_matrix = None
         self._dag = None
         self._front_layer = None
-        self.circuit = None
+        self.circuit_map = None
         self._memory_map = None
         self._final_measurements = None
         self._temp_added_swaps = []
@@ -722,20 +722,20 @@ def __call__(self, circuit: Circuit, initial_layout: dict):
             ):  # threshold is arbitrary
                 while self._temp_added_swaps:
                     swap = self._temp_added_swaps.pop()
-                    self.circuit.undo()
+                    self.circuit_map.undo()
                 self._temp_added_swaps = []
                 self._shortest_path_routing()
 
         circuit_kwargs = circuit.init_kwargs
         circuit_kwargs["wire_names"] = list(initial_layout.keys())
-        routed_circuit = self.circuit.routed_circuit(circuit_kwargs=circuit_kwargs)
+        routed_circuit = self.circuit_map.routed_circuit(circuit_kwargs=circuit_kwargs)
         if self._final_measurements is not None:
             routed_circuit = self._append_final_measurements(
                 routed_circuit=routed_circuit
             )
 
         # 1# final layout is reverted to the original labeling
-        final_layout = self.circuit.final_layout()
+        final_layout = self.circuit_map.final_layout()
         final_layout_restored = {
             "q" + str(self.node_mapping_inv[int(k[1:])]): v
             for k, v in final_layout.items()
@@ -745,7 +745,7 @@ def __call__(self, circuit: Circuit, initial_layout: dict):
     @property
     def added_swaps(self):
         """Returns the number of SWAP gates added to the circuit during routing."""
-        return self.circuit._swaps
+        return self.circuit_map._swaps
 
     def _preprocessing(self, circuit: Circuit, initial_layout: dict):
         """The following objects will be initialised:
@@ -775,9 +775,9 @@ def _preprocessing(self, circuit: Circuit, initial_layout: dict):
 
         copied_circuit = circuit.copy(deep=True)
         self._final_measurements = self._detach_final_measurements(copied_circuit)
-        self.circuit = CircuitMap(new_initial_layout, copied_circuit)
+        self.circuit_map = CircuitMap(new_initial_layout, copied_circuit)
         self._dist_matrix = nx.floyd_warshall_numpy(self.connectivity)
-        self._dag = _create_dag(self.circuit.blocks_logical_qubits_pairs())
+        self._dag = _create_dag(self.circuit_map.blocks_logical_qubits_pairs())
         self._memory_map = []
         self._update_dag_layers()
         self._update_front_layer()
@@ -809,7 +809,7 @@ def _append_final_measurements(self, routed_circuit: Circuit):
             original_qubits = measurement.qubits
             routed_qubits = list(
                 # 1# use l2p to get physical qubit numbers
-                self.circuit.logical_to_physical[qubit]
+                self.circuit_map.logical_to_physical[qubit]
                 for qubit in original_qubits
             )
             routed_circuit.add(
@@ -835,20 +835,20 @@ def _update_front_layer(self):
 
     def _get_dag_layer(self, n_layer, qubits=False):
         """Return the :math:`n`-topological layer of the dag.
-        If ``qubits=True``, return the target qubits of the blocks in the layer.
-        Otherwise, return the block numbers.
+
+        Args:
+            n_layer (int): layer number.
+            qubits (bool, optional): if ``True``, return the target qubits of the blocks in the layer.
+                If ``False``, return the block numbers. Defaults to ``False``. 
+        
+        Returns:
+            (list): list of block numbers or target qubits.
         """
 
         # 3# depend on the 'qubits' flag, return the block number or target qubits
         # 3# return target qubits -> to avoid using get_physical_qubits(block_num)
         if qubits:
-            layer_qubits = []
-            nodes = self._dag.nodes(data=True)
-            for node in nodes:
-                if node[1]["layer"] == n_layer:
-                    # return target qubits
-                    layer_qubits.append(node[1]["qubits"])
-            return layer_qubits
+            return [node[1]["qubits"] for node in self._dag.nodes(data=True) if node[1]["layer"] == n_layer]
 
         return [node[0] for node in self._dag.nodes(data="layer") if node[1] == n_layer]
 
@@ -857,7 +857,7 @@ def _find_new_mapping(self):
         candidates_evaluation = {}
 
         # 4# use shallow copy
-        self._memory_map.append(self.circuit.physical_to_logical.copy())
+        self._memory_map.append(self.circuit_map.physical_to_logical.copy())
         for candidate in self._swap_candidates():
             candidates_evaluation[candidate] = self._compute_cost(candidate)
 
@@ -867,9 +867,9 @@ def _find_new_mapping(self):
         ]
         best_candidate = random.choice(best_candidates)
 
-        for qubit in self.circuit.logical_pair_to_physical(best_candidate):
+        for qubit in self.circuit_map.logical_pair_to_physical(best_candidate):
             self._delta_register[qubit] += self.delta
-        self.circuit.update(best_candidate)
+        self.circuit_map.update(best_candidate)
         self._temp_added_swaps.append(best_candidate)
 
     def _compute_cost(self, candidate: int):
@@ -879,12 +879,12 @@ def _compute_cost(self, candidate: int):
         # 2# no gates, no block decomposition, no Circuit object
         # 2# just logical-physical mapping
         temporary_circuit = CircuitMap(
-            initial_layout=self.circuit.initial_layout,
+            initial_layout=self.circuit_map.initial_layout,
             temp=True,
         )
 
         # 1# copy the current physical to logical mapping
-        temporary_circuit.physical_to_logical = self.circuit.physical_to_logical
+        temporary_circuit.physical_to_logical = self.circuit_map.physical_to_logical
         temporary_circuit.update(candidate)
 
         # 1# use p2l to check if the mapping is already in the memory
@@ -923,13 +923,13 @@ def _swap_candidates(self):
         candidates = []
         # 3# might be changed to use _get_dag_layer(qubits=True) to avoid using get_physical_qubits(block_num)
         for block in self._front_layer:
-            for qubit in self.circuit.get_physical_qubits(block):
+            for qubit in self.circuit_map.get_physical_qubits(block):
                 for connected in self.connectivity.neighbors(qubit):
                     candidate = tuple(
                         sorted(
                             (
-                                self.circuit.physical_to_logical[qubit],
-                                self.circuit.physical_to_logical[connected],
+                                self.circuit_map.physical_to_logical[qubit],
+                                self.circuit_map.physical_to_logical[connected],
                             )
                         )
                     )
@@ -948,8 +948,8 @@ def _check_execution(self):
         for block in self._front_layer:
             if (
                 # 3# might be changed to use _get_dag_layer(qubits=True) to avoid using get_physical_qubits(block_num)
-                self.circuit.get_physical_qubits(block) in self.connectivity.edges
-                or not self.circuit.circuit_blocks.search_by_index(block).entangled
+                self.circuit_map.get_physical_qubits(block) in self.connectivity.edges
+                or not self.circuit_map.circuit_blocks.search_by_index(block).entangled
             ):
                 executable_blocks.append(block)
 
@@ -971,8 +971,8 @@ def _execute_blocks(self, blocklist: list):
             blocklist (list): list of blocks.
         """
         for block_id in blocklist:
-            block = self.circuit.circuit_blocks.search_by_index(block_id)
-            self.circuit.execute_block(block)
+            block = self.circuit_map.circuit_blocks.search_by_index(block_id)
+            self.circuit_map.execute_block(block)
             self._dag.remove_node(block_id)
         self._update_dag_layers()
         self._update_front_layer()
@@ -992,7 +992,7 @@ def _shortest_path_routing(self):
         for block in self._front_layer:
             # 3# return node numbers (physical qubits) in the connectivity graph
             # 3# might be changed to use _get_dag_layer(qubits=True) to avoid using get_physical_qubits(block_num)
-            q1, q2 = self.circuit.get_physical_qubits(block)
+            q1, q2 = self.circuit_map.get_physical_qubits(block)
             distance = self._dist_matrix[q1, q2]
 
             if distance < min_distance:
@@ -1005,9 +1005,9 @@ def _shortest_path_routing(self):
 
         # move q1
         # 1# qubit moving algorithm is changed
-        q1 = self.circuit.physical_to_logical[shortest_path[0]]
+        q1 = self.circuit_map.physical_to_logical[shortest_path[0]]
         for q2 in shortest_path[1:-1]:
-            self.circuit.update((q1, self.circuit.physical_to_logical[q2]))
+            self.circuit_map.update((q1, self.circuit_map.physical_to_logical[q2]))
 
 
 def _create_dag(gates_qubits_pairs: list):
diff --git a/tests/test_transpiler_router.py b/tests/test_transpiler_router.py
index fdad7b96c8..e4417db5de 100644
--- a/tests/test_transpiler_router.py
+++ b/tests/test_transpiler_router.py
@@ -254,8 +254,8 @@ def test_sabre_shortest_path_routing():
     router._preprocessing(circuit=loop_circ, initial_layout=initial_layout)
     router._shortest_path_routing()  # q2 should be moved adjacent to q8
 
-    gate_28 = router.circuit.circuit_blocks.block_list[2]
-    gate_28_qubits = router.circuit.get_physical_qubits(gate_28)
+    gate_28 = router.circuit_map.circuit_blocks.block_list[2]
+    gate_28_qubits = router.circuit_map.get_physical_qubits(gate_28)
 
     # Check if the physical qubits of the gate (2, 8) are adjacent
     assert gate_28_qubits[1] in list(router.connectivity.neighbors(gate_28_qubits[0]))

From 7d128aeb1b65968db19936c0be1f998eda39f4cb Mon Sep 17 00:00:00 2001
From: Changsoo Kim <57739683+csookim@users.noreply.github.com>
Date: Wed, 28 Aug 2024 19:47:16 +0800
Subject: [PATCH 10/40] Update src/qibo/transpiler/router.py

Co-authored-by: BrunoLiegiBastonLiegi <45011234+BrunoLiegiBastonLiegi@users.noreply.github.com>
---
 src/qibo/transpiler/router.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/qibo/transpiler/router.py b/src/qibo/transpiler/router.py
index 2c2e75f981..0e9eda233f 100644
--- a/src/qibo/transpiler/router.py
+++ b/src/qibo/transpiler/router.py
@@ -244,7 +244,12 @@ def logical_to_physical(self, l2p_map: list):
             self._p2l[p] = i
 
     def _update_mappings_swap(self, logical_swap: tuple, physical_swap: tuple):
-        """Updates the qubit mapping after applying a SWAP gate."""
+        """Updates the qubit mappings after applying a SWAP gate.
+        
+        Args:
+            logical_swap (tuple[int]): the indices of the logical qubits to be swapped.
+            physical_swap (tuple[int]): the indices of the corresponding physical qubits to be swapped.
+        """
         self._p2l[physical_swap[0]], self._p2l[physical_swap[1]] = (
             logical_swap[1],
             logical_swap[0],

From e46f341b6ee3bedc24a520d7e29f3a431e90bd3f Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Wed, 28 Aug 2024 11:47:17 +0000
Subject: [PATCH 11/40] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/qibo/transpiler/router.py | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/qibo/transpiler/router.py b/src/qibo/transpiler/router.py
index 0e9eda233f..e0d0e9c219 100644
--- a/src/qibo/transpiler/router.py
+++ b/src/qibo/transpiler/router.py
@@ -844,8 +844,8 @@ def _get_dag_layer(self, n_layer, qubits=False):
         Args:
             n_layer (int): layer number.
             qubits (bool, optional): if ``True``, return the target qubits of the blocks in the layer.
-                If ``False``, return the block numbers. Defaults to ``False``. 
-        
+                If ``False``, return the block numbers. Defaults to ``False``.
+
         Returns:
             (list): list of block numbers or target qubits.
         """
@@ -853,7 +853,11 @@ def _get_dag_layer(self, n_layer, qubits=False):
         # 3# depend on the 'qubits' flag, return the block number or target qubits
         # 3# return target qubits -> to avoid using get_physical_qubits(block_num)
         if qubits:
-            return [node[1]["qubits"] for node in self._dag.nodes(data=True) if node[1]["layer"] == n_layer]
+            return [
+                node[1]["qubits"]
+                for node in self._dag.nodes(data=True)
+                if node[1]["layer"] == n_layer
+            ]
 
         return [node[0] for node in self._dag.nodes(data="layer") if node[1] == n_layer]
 

From 1506b787b814a6915d7b2dbf485818f768047fe9 Mon Sep 17 00:00:00 2001
From: changsookim <>
Date: Thu, 29 Aug 2024 19:33:59 +0800
Subject: [PATCH 12/40] enable custom qubit names / wire_names

---
 src/qibo/transpiler/router.py | 81 +++++++++++------------------------
 1 file changed, 26 insertions(+), 55 deletions(-)

diff --git a/src/qibo/transpiler/router.py b/src/qibo/transpiler/router.py
index e0d0e9c219..ee11c8b9a0 100644
--- a/src/qibo/transpiler/router.py
+++ b/src/qibo/transpiler/router.py
@@ -173,23 +173,12 @@ class CircuitMap:
 
     def __init__(
         self,
-        initial_layout: dict,
+        initial_layout: Optional[dict] = None,
         circuit: Optional[Circuit] = None,
         blocks: Optional[CircuitBlocks] = None,
         temp: Optional[bool] = False,  # 2# for temporary circuit
     ):
-        self.initial_layout = dict(sorted(initial_layout.items()))
-
-        # 1# bidirectional mapping
-        # 1# self._p2l: physical qubit number i -> logical qubit number _p2l[i]
-        # 1# self._l2p: logical qubit number i -> physical qubit number _l2p[i]
-        self._l2p, self._p2l = [0] * len(self.initial_layout), [0] * len(
-            self.initial_layout
-        )
-        for mapping in self.initial_layout.items():
-            physical_qubit, logical_qubit = int(mapping[0][1:]), mapping[1]
-            self._l2p[logical_qubit] = physical_qubit
-            self._p2l[physical_qubit] = logical_qubit
+        self._p2l, self._l2p = [], []
 
         self._temporary = temp
         if self._temporary:  # 2# if temporary circuit, no need to store the blocks
@@ -206,6 +195,13 @@ def __init__(
 
         self._routed_blocks = CircuitBlocks(Circuit(circuit.nqubits))
         self._swaps = 0
+        
+        if initial_layout is None:
+            return
+
+        # 1# initialize physical to logical mapping
+        self.wire_names = list(initial_layout.keys())
+        self.physical_to_logical = list(initial_layout.values())
 
     @property
     def physical_to_logical(self):
@@ -227,6 +223,7 @@ def physical_to_logical(self, p2l_map: list):
         # 1# update bidirectional mapping
         # 4# use shallow copy
         self._p2l = p2l_map.copy()
+        self._l2p = [0] * len(self._p2l)
         for i, l in enumerate(self._p2l):
             self._l2p[l] = i
 
@@ -240,6 +237,7 @@ def logical_to_physical(self, l2p_map: list):
         # 1# update bidirectional mapping
         # 4# use shallow copy
         self._l2p = l2p_map.copy()
+        self._p2l = [0] * len(self._l2p)
         for i, p in enumerate(self._l2p):
             self._p2l[p] = i
 
@@ -289,10 +287,8 @@ def routed_circuit(self, circuit_kwargs: Optional[dict] = None):
     def final_layout(self):
         """Returns the final physical-logical qubits mapping."""
 
-        # 1# return {"q0": lq_num0, "q1": lq_num1, ...}
-        unsorted_dict = {"q" + str(i): self._p2l[i] for i in range(self._nqubits)}
-
-        return dict(sorted(unsorted_dict.items()))
+        # 1# return {"A": lq_num0, "B": lq_num1, ...}
+        return {self.wire_names[i]: self._p2l[i] for i in range(self._nqubits)}
 
     def update(self, logical_swap: tuple):
         """Updates the qubit mapping after applying a ``SWAP``
@@ -410,13 +406,7 @@ def __call__(self, circuit: Circuit, initial_layout: dict):
                 routed_circuit=routed_circuit
             )
 
-        # 1# final layout is reverted to the original labeling
-        final_layout = self.circuit_map.final_layout()
-        final_layout_restored = {
-            "q" + str(self.node_mapping_inv[int(k[1:])]): v
-            for k, v in final_layout.items()
-        }
-        return routed_circuit, final_layout_restored
+        return routed_circuit, self.circuit_map.final_layout()
 
     def _find_new_mapping(self):
         """Find new qubit mapping. Mapping is found by looking for the shortest path.
@@ -496,8 +486,7 @@ def _compute_cost(self, candidate: tuple):
         """
         # 2# CircuitMap might be used
         temporary_circuit = CircuitMap(
-            initial_layout=self.circuit_map.initial_layout,
-            circuit=Circuit(len(self.circuit_map.initial_layout)),
+            circuit=Circuit(self.circuit_map._nqubits),
             blocks=deepcopy(self.circuit_map.circuit_blocks),
         )
 
@@ -594,18 +583,15 @@ def _preprocessing(self, circuit: Circuit, initial_layout: dict):
             initial_layout (dict): initial physical-to-logical qubit mapping.
         """
 
-        # 1# To simplify routing, some data is relabeled before routing begins.
-        node_mapping, new_initial_layout = {}, {}
-        for i, node in enumerate(self.connectivity.nodes):
+        # 1# Relabel the nodes of the connectivity graph
+        node_mapping = {}
+        for i, node in enumerate(list(initial_layout.keys())):
             node_mapping[node] = i
-            new_initial_layout["q" + str(i)] = initial_layout["q" + str(node)]
-
         self.connectivity = nx.relabel_nodes(self.connectivity, node_mapping)
-        self.node_mapping_inv = {v: k for k, v in node_mapping.items()}
 
         copied_circuit = circuit.copy(deep=True)
         self._final_measurements = self._detach_final_measurements(copied_circuit)
-        self.circuit_map = CircuitMap(new_initial_layout, copied_circuit)
+        self.circuit_map = CircuitMap(initial_layout, copied_circuit)
         self._dag = _create_dag(self.circuit_map.blocks_logical_qubits_pairs())
         self._update_front_layer()
 
@@ -684,8 +670,6 @@ def __init__(
         seed: Optional[int] = None,
     ):
         self.connectivity = connectivity
-        # 1# map to revert the final layout to the original labeling
-        self.node_mapping_inv = None
         self.lookahead = lookahead
         self.decay = decay_lookahead
         self.delta = delta
@@ -726,7 +710,7 @@ def __call__(self, circuit: Circuit, initial_layout: dict):
                 len(self._temp_added_swaps) > self.swap_threshold * longest_path
             ):  # threshold is arbitrary
                 while self._temp_added_swaps:
-                    swap = self._temp_added_swaps.pop()
+                    self._temp_added_swaps.pop()
                     self.circuit_map.undo()
                 self._temp_added_swaps = []
                 self._shortest_path_routing()
@@ -739,13 +723,7 @@ def __call__(self, circuit: Circuit, initial_layout: dict):
                 routed_circuit=routed_circuit
             )
 
-        # 1# final layout is reverted to the original labeling
-        final_layout = self.circuit_map.final_layout()
-        final_layout_restored = {
-            "q" + str(self.node_mapping_inv[int(k[1:])]): v
-            for k, v in final_layout.items()
-        }
-        return routed_circuit, final_layout_restored
+        return routed_circuit, self.circuit_map.final_layout()
 
     @property
     def added_swaps(self):
@@ -768,19 +746,15 @@ def _preprocessing(self, circuit: Circuit, initial_layout: dict):
             initial_layout (dict): initial physical-to-logical qubit mapping.
         """
 
-        # 1# To simplify routing, some data is relabeled before routing begins.
-        # 1# physical qubit is reassigned to a range from 0 to len(self.connectivity.nodes) - 1.
-        node_mapping, new_initial_layout = {}, {}
-        for i, node in enumerate(self.connectivity.nodes):
+        # 1# Relabel the nodes of the connectivity graph
+        node_mapping = {}
+        for i, node in enumerate(list(initial_layout.keys())):
             node_mapping[node] = i
-            new_initial_layout["q" + str(i)] = initial_layout["q" + str(node)]
-
         self.connectivity = nx.relabel_nodes(self.connectivity, node_mapping)
-        self.node_mapping_inv = {v: k for k, v in node_mapping.items()}
 
         copied_circuit = circuit.copy(deep=True)
         self._final_measurements = self._detach_final_measurements(copied_circuit)
-        self.circuit_map = CircuitMap(new_initial_layout, copied_circuit)
+        self.circuit_map = CircuitMap(initial_layout, copied_circuit)
         self._dist_matrix = nx.floyd_warshall_numpy(self.connectivity)
         self._dag = _create_dag(self.circuit_map.blocks_logical_qubits_pairs())
         self._memory_map = []
@@ -887,10 +861,7 @@ def _compute_cost(self, candidate: int):
         # 2# use CircuitMap for temporary circuit to save time
         # 2# no gates, no block decomposition, no Circuit object
         # 2# just logical-physical mapping
-        temporary_circuit = CircuitMap(
-            initial_layout=self.circuit_map.initial_layout,
-            temp=True,
-        )
+        temporary_circuit = CircuitMap(temp=True)
 
         # 1# copy the current physical to logical mapping
         temporary_circuit.physical_to_logical = self.circuit_map.physical_to_logical

From 19d373781cb703c3333e85c66702356a4101314e Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Thu, 29 Aug 2024 11:34:47 +0000
Subject: [PATCH 13/40] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/qibo/transpiler/router.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/qibo/transpiler/router.py b/src/qibo/transpiler/router.py
index ee11c8b9a0..2479311256 100644
--- a/src/qibo/transpiler/router.py
+++ b/src/qibo/transpiler/router.py
@@ -195,7 +195,7 @@ def __init__(
 
         self._routed_blocks = CircuitBlocks(Circuit(circuit.nqubits))
         self._swaps = 0
-        
+
         if initial_layout is None:
             return
 
@@ -243,7 +243,7 @@ def logical_to_physical(self, l2p_map: list):
 
     def _update_mappings_swap(self, logical_swap: tuple, physical_swap: tuple):
         """Updates the qubit mappings after applying a SWAP gate.
-        
+
         Args:
             logical_swap (tuple[int]): the indices of the logical qubits to be swapped.
             physical_swap (tuple[int]): the indices of the corresponding physical qubits to be swapped.

From 32364fc031b98529fb4de303df610500f80d2478 Mon Sep 17 00:00:00 2001
From: changsookim <>
Date: Thu, 5 Sep 2024 17:41:02 +0800
Subject: [PATCH 14/40] add helper func / update test func

---
 src/qibo/transpiler/placer.py   |   2 +-
 src/qibo/transpiler/router.py   |  36 +++++-----
 tests/test_transpiler_router.py | 118 ++++++++++++++++++++++----------
 3 files changed, 103 insertions(+), 53 deletions(-)

diff --git a/src/qibo/transpiler/placer.py b/src/qibo/transpiler/placer.py
index 12415b8ec7..7944ea81f2 100644
--- a/src/qibo/transpiler/placer.py
+++ b/src/qibo/transpiler/placer.py
@@ -54,7 +54,7 @@ def assert_mapping_consistency(layout: dict, connectivity: nx.Graph = None):
     ref_keys = (
         ["q" + str(i) for i in nodes] if isinstance(physical_qubits[0], str) else nodes
     )
-    if physical_qubits != ref_keys:
+    if sorted(physical_qubits) != sorted(ref_keys):
         raise_error(
             PlacementError,
             "Some physical qubits in the layout may be missing or duplicated.",
diff --git a/src/qibo/transpiler/router.py b/src/qibo/transpiler/router.py
index 2479311256..0fbf028a11 100644
--- a/src/qibo/transpiler/router.py
+++ b/src/qibo/transpiler/router.py
@@ -34,12 +34,23 @@ def assert_connectivity(connectivity: nx.Graph, circuit: Circuit):
         if len(gate.qubits) > 2 and not isinstance(gate, gates.M):
             raise_error(ConnectivityError, f"{gate.name} acts on more than two qubits.")
         if len(gate.qubits) == 2:
-            if (gate.qubits[0], gate.qubits[1]) not in connectivity.edges:
+            # physical_qubits = tuple(sorted((circuit.wire_names[gate.qubits[0]], circuit.wire_names[gate.qubits[1]])))
+            physical_qubits = tuple(sorted(gate.qubits))    # for q_i naming
+            if physical_qubits not in connectivity.edges:
                 raise_error(
                     ConnectivityError,
-                    f"Circuit does not respect connectivity. {gate.name} acts on {gate.qubits}.",
+                    f"Circuit does not respect connectivity. {gate.name} acts on {physical_qubits}.",
                 )
-
+                
+        
+def _relabel_connectivity(connectivity, initial_layout):
+    node_mapping = {}
+    initial_layout = dict(sorted(initial_layout.items(), key=lambda item: int(item[0][1:])))    # for q_i naming
+    for i, node in enumerate(list(initial_layout.keys())):
+        # node_mapping[node] = i
+        node_mapping[int(node[1:])] = i     # for q_i naming
+    new_connectivity = nx.relabel_nodes(connectivity, node_mapping)
+    return new_connectivity
 
 class StarConnectivityRouter(Router):
     """Transforms an arbitrary circuit to one that can be executed on hardware.
@@ -183,16 +194,15 @@ def __init__(
         self._temporary = temp
         if self._temporary:  # 2# if temporary circuit, no need to store the blocks
             return
-
-        self._nqubits = circuit.nqubits  # 1# number of qubits
-        if circuit is None:
+        elif circuit is None:
             raise_error(ValueError, "Circuit must be provided.")
-
+        
         if blocks is not None:
             self.circuit_blocks = blocks
         else:
             self.circuit_blocks = CircuitBlocks(circuit, index_names=True)
 
+        self._nqubits = circuit.nqubits  # 1# number of qubits
         self._routed_blocks = CircuitBlocks(Circuit(circuit.nqubits))
         self._swaps = 0
 
@@ -584,10 +594,7 @@ def _preprocessing(self, circuit: Circuit, initial_layout: dict):
         """
 
         # 1# Relabel the nodes of the connectivity graph
-        node_mapping = {}
-        for i, node in enumerate(list(initial_layout.keys())):
-            node_mapping[node] = i
-        self.connectivity = nx.relabel_nodes(self.connectivity, node_mapping)
+        self.connectivity = _relabel_connectivity(self.connectivity, initial_layout)
 
         copied_circuit = circuit.copy(deep=True)
         self._final_measurements = self._detach_final_measurements(copied_circuit)
@@ -747,10 +754,7 @@ def _preprocessing(self, circuit: Circuit, initial_layout: dict):
         """
 
         # 1# Relabel the nodes of the connectivity graph
-        node_mapping = {}
-        for i, node in enumerate(list(initial_layout.keys())):
-            node_mapping[node] = i
-        self.connectivity = nx.relabel_nodes(self.connectivity, node_mapping)
+        self.connectivity = _relabel_connectivity(self.connectivity, initial_layout)
 
         copied_circuit = circuit.copy(deep=True)
         self._final_measurements = self._detach_final_measurements(copied_circuit)
@@ -1042,4 +1046,4 @@ def _remove_redundant_connections(dag: nx.DiGraph):
     transitive_reduction = nx.transitive_reduction(dag)
     new_dag.add_edges_from(transitive_reduction.edges)
 
-    return new_dag
+    return new_dag
\ No newline at end of file
diff --git a/tests/test_transpiler_router.py b/tests/test_transpiler_router.py
index e4417db5de..ed1b9cfe7c 100644
--- a/tests/test_transpiler_router.py
+++ b/tests/test_transpiler_router.py
@@ -49,6 +49,13 @@ def grid_connectivity():
     chip.add_edges_from(graph_list)
     return chip
 
+def line_connectivity(n):
+    Q = [i for i in range(n)]
+    chip = nx.Graph()
+    chip.add_nodes_from(Q)
+    graph_list = [(Q[i], (Q[i]+1) % n) for i in range(n-1)]
+    chip.add_edges_from(graph_list)
+    return chip
 
 def generate_random_circuit(nqubits, ngates, seed=42):
     """Generate a random circuit with RX and CZ gates."""
@@ -135,6 +142,27 @@ def test_random_circuits_5q(gates, placer, connectivity):
         initial_map=initial_layout,
     )
 
+def test_random_circuits_15q_50g():
+    nqubits, ngates = 15, 50
+    connectivity = line_connectivity(nqubits)
+    placer = Random(connectivity=connectivity)
+    layout_circ = Circuit(nqubits)
+    initial_layout = placer(layout_circ)
+    transpiler = Sabre(connectivity=connectivity)
+    circuit = generate_random_circuit(nqubits=nqubits, ngates=ngates)
+    transpiled_circuit, final_qubit_map = transpiler(circuit, initial_layout)
+    assert transpiler.added_swaps >= 0
+    assert_connectivity(connectivity, transpiled_circuit)
+    assert_placement(transpiled_circuit, final_qubit_map)
+    assert ngates + transpiler.added_swaps == transpiled_circuit.ngates
+    qubit_matcher = Preprocessing(connectivity=connectivity)
+    new_circuit = qubit_matcher(circuit=circuit)
+    assert_circuit_equivalence(
+        original_circuit=new_circuit,
+        transpiled_circuit=transpiled_circuit,
+        final_map=final_qubit_map,
+        initial_map=initial_layout,
+    )    
 
 def test_star_circuit():
     placer = Subgraph(star_connectivity())
@@ -272,40 +300,54 @@ def test_circuit_map():
     circ.add(gates.CZ(0, 1))
     circ.add(gates.CZ(2, 3))
     initial_layout = {"q0": 2, "q1": 0, "q2": 1, "q3": 3}
-    # circuit_map = CircuitMap(initial_layout=initial_layout, circuit=circ)
-    # block_list = circuit_map.circuit_blocks
-    # # test blocks_qubits_pairs
-    # assert circuit_map.blocks_qubits_pairs() == [(0, 1), (1, 2), (0, 1), (2, 3)]
-    # # test execute_block and routed_circuit
-    # circuit_map.execute_block(block_list.search_by_index(0))
-    # routed_circuit = circuit_map.routed_circuit()
-    # assert isinstance(routed_circuit.queue[0], gates.H)
-    # assert len(routed_circuit.queue) == 4
-    # assert routed_circuit.queue[2].qubits == (1, 2)
-    # # test update
-    # circuit_map.update((0, 2))
-    # routed_circuit = circuit_map.routed_circuit()
-    # assert isinstance(routed_circuit.queue[4], gates.SWAP)
-    # assert routed_circuit.queue[4].qubits == (1, 0)
-    # assert circuit_map._swaps == 1
-    # assert circuit_map._circuit_logical == [2, 1, 0, 3]
-    # circuit_map.update((1, 2))
-    # routed_circuit = circuit_map.routed_circuit()
-    # assert routed_circuit.queue[5].qubits == (2, 0)
-    # assert circuit_map._circuit_logical == [1, 2, 0, 3]
+    circuit_map = CircuitMap(initial_layout=initial_layout, circuit=circ)
+    block_list = circuit_map.circuit_blocks
+    # test blocks_qubits_pairs
+    assert circuit_map.blocks_logical_qubits_pairs() == [(0, 1), (1, 2), (0, 1), (2, 3)]
+    # test execute_block and routed_circuit
+    circuit_map.execute_block(block_list.search_by_index(0))
+    routed_circuit = circuit_map.routed_circuit()
+    assert isinstance(routed_circuit.queue[0], gates.H)
+    assert len(routed_circuit.queue) == 4
+    qubits = routed_circuit.queue[2].qubits
+    assert routed_circuit.wire_names[qubits[0]] == "q1" and routed_circuit.wire_names[qubits[1]] == "q2"
+    
+    # test update 1
+    circuit_map.update((0, 2))
+    routed_circuit = circuit_map.routed_circuit()
+    assert isinstance(routed_circuit.queue[4], gates.SWAP)
+    qubits = routed_circuit.queue[4].qubits
+    assert routed_circuit.wire_names[qubits[0]] == "q1" and routed_circuit.wire_names[qubits[1]] == "q0"
+    assert circuit_map._swaps == 1
+    assert circuit_map.physical_to_logical == [0, 2, 1, 3]
+    assert circuit_map.logical_to_physical == [0, 2, 1, 3]
+    
+    # test update 2
+    circuit_map.update((1, 2))
+    routed_circuit = circuit_map.routed_circuit()
+    assert isinstance(routed_circuit.queue[5], gates.SWAP)
+    qubits = routed_circuit.queue[5].qubits
+    assert routed_circuit.wire_names[qubits[0]] == "q2" and routed_circuit.wire_names[qubits[1]] == "q1"
+    assert circuit_map._swaps == 2
+    assert circuit_map.physical_to_logical == [0, 1, 2, 3]
+    assert circuit_map.logical_to_physical == [0, 1, 2, 3]
+
     # # test execute_block after multiple swaps
-    # circuit_map.execute_block(block_list.search_by_index(1))
-    # circuit_map.execute_block(block_list.search_by_index(2))
-    # circuit_map.execute_block(block_list.search_by_index(3))
-    # routed_circuit = circuit_map.routed_circuit()
-    # assert isinstance(routed_circuit.queue[6], gates.CZ)
-    # # circuit to logical map: [1,2,0,3]. initial map: {"q0": 2, "q1": 0, "q2": 1, "q3": 3}.
-    # assert routed_circuit.queue[6].qubits == (0, 1)  # initial circuit qubits (1,2)
-    # assert routed_circuit.queue[7].qubits == (2, 0)  # (0,1)
-    # assert routed_circuit.queue[8].qubits == (1, 3)  # (2,3)
-    # assert len(circuit_map.circuit_blocks()) == 0
-    # # test final layout
-    # assert circuit_map.final_layout() == {"q0": 1, "q1": 2, "q2": 0, "q3": 3}
+    circuit_map.execute_block(block_list.search_by_index(1))
+    circuit_map.execute_block(block_list.search_by_index(2))
+    circuit_map.execute_block(block_list.search_by_index(3))
+    routed_circuit = circuit_map.routed_circuit()
+    assert isinstance(routed_circuit.queue[6], gates.CZ)
+
+    qubits = routed_circuit.queue[6].qubits
+    assert routed_circuit.wire_names[qubits[0]] == "q1" and routed_circuit.wire_names[qubits[1]] == "q2"
+    qubits = routed_circuit.queue[7].qubits
+    assert routed_circuit.wire_names[qubits[0]] == "q0" and routed_circuit.wire_names[qubits[1]] == "q1"
+    qubits = routed_circuit.queue[8].qubits
+    assert routed_circuit.wire_names[qubits[0]] == "q2" and routed_circuit.wire_names[qubits[1]] == "q3"
+    assert len(circuit_map.circuit_blocks()) == 0
+    # test final layout
+    assert circuit_map.final_layout() == {"q0": 0, "q1": 1, "q2": 2, "q3": 3}
 
 
 def test_sabre_matched():
@@ -483,17 +525,21 @@ def test_undo():
     # Two SWAP gates are added
     circuit_map.update((1, 2))
     circuit_map.update((2, 3))
-    # assert circuit_map._circuit_logical == [0, 3, 1, 2]
+    assert circuit_map.physical_to_logical == [0, 3, 1, 2]
+    assert circuit_map.logical_to_physical == [0, 2, 3, 1]
     assert len(circuit_map._routed_blocks.block_list) == 2
+    assert circuit_map._swaps == 2
 
     # Undo the last SWAP gate
     circuit_map.undo()
-    # assert circuit_map._circuit_logical == [0, 2, 1, 3]
+    assert circuit_map.physical_to_logical == [0, 2, 1, 3]
+    assert circuit_map.logical_to_physical == [0, 2, 1, 3]
     assert circuit_map._swaps == 1
     assert len(circuit_map._routed_blocks.block_list) == 1
 
     # Undo the first SWAP gate
     circuit_map.undo()
-    # assert circuit_map._circuit_logical == [0, 1, 2, 3]
+    assert circuit_map.physical_to_logical == [0, 1, 2, 3]
+    assert circuit_map.logical_to_physical == [0, 1, 2, 3]
     assert circuit_map._swaps == 0
     assert len(circuit_map._routed_blocks.block_list) == 0

From 2b8cdc0a824708c4961c58e6141b98f748c80770 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Thu, 5 Sep 2024 09:43:02 +0000
Subject: [PATCH 15/40] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/qibo/transpiler/router.py   | 17 +++++++------
 tests/test_transpiler_router.py | 42 +++++++++++++++++++++++++--------
 2 files changed, 42 insertions(+), 17 deletions(-)

diff --git a/src/qibo/transpiler/router.py b/src/qibo/transpiler/router.py
index 0fbf028a11..f730679f84 100644
--- a/src/qibo/transpiler/router.py
+++ b/src/qibo/transpiler/router.py
@@ -35,23 +35,26 @@ def assert_connectivity(connectivity: nx.Graph, circuit: Circuit):
             raise_error(ConnectivityError, f"{gate.name} acts on more than two qubits.")
         if len(gate.qubits) == 2:
             # physical_qubits = tuple(sorted((circuit.wire_names[gate.qubits[0]], circuit.wire_names[gate.qubits[1]])))
-            physical_qubits = tuple(sorted(gate.qubits))    # for q_i naming
+            physical_qubits = tuple(sorted(gate.qubits))  # for q_i naming
             if physical_qubits not in connectivity.edges:
                 raise_error(
                     ConnectivityError,
                     f"Circuit does not respect connectivity. {gate.name} acts on {physical_qubits}.",
                 )
-                
-        
+
+
 def _relabel_connectivity(connectivity, initial_layout):
     node_mapping = {}
-    initial_layout = dict(sorted(initial_layout.items(), key=lambda item: int(item[0][1:])))    # for q_i naming
+    initial_layout = dict(
+        sorted(initial_layout.items(), key=lambda item: int(item[0][1:]))
+    )  # for q_i naming
     for i, node in enumerate(list(initial_layout.keys())):
         # node_mapping[node] = i
-        node_mapping[int(node[1:])] = i     # for q_i naming
+        node_mapping[int(node[1:])] = i  # for q_i naming
     new_connectivity = nx.relabel_nodes(connectivity, node_mapping)
     return new_connectivity
 
+
 class StarConnectivityRouter(Router):
     """Transforms an arbitrary circuit to one that can be executed on hardware.
 
@@ -196,7 +199,7 @@ def __init__(
             return
         elif circuit is None:
             raise_error(ValueError, "Circuit must be provided.")
-        
+
         if blocks is not None:
             self.circuit_blocks = blocks
         else:
@@ -1046,4 +1049,4 @@ def _remove_redundant_connections(dag: nx.DiGraph):
     transitive_reduction = nx.transitive_reduction(dag)
     new_dag.add_edges_from(transitive_reduction.edges)
 
-    return new_dag
\ No newline at end of file
+    return new_dag
diff --git a/tests/test_transpiler_router.py b/tests/test_transpiler_router.py
index ed1b9cfe7c..0bf2390fa8 100644
--- a/tests/test_transpiler_router.py
+++ b/tests/test_transpiler_router.py
@@ -49,14 +49,16 @@ def grid_connectivity():
     chip.add_edges_from(graph_list)
     return chip
 
+
 def line_connectivity(n):
     Q = [i for i in range(n)]
     chip = nx.Graph()
     chip.add_nodes_from(Q)
-    graph_list = [(Q[i], (Q[i]+1) % n) for i in range(n-1)]
+    graph_list = [(Q[i], (Q[i] + 1) % n) for i in range(n - 1)]
     chip.add_edges_from(graph_list)
     return chip
 
+
 def generate_random_circuit(nqubits, ngates, seed=42):
     """Generate a random circuit with RX and CZ gates."""
     np.random.seed(seed)
@@ -142,6 +144,7 @@ def test_random_circuits_5q(gates, placer, connectivity):
         initial_map=initial_layout,
     )
 
+
 def test_random_circuits_15q_50g():
     nqubits, ngates = 15, 50
     connectivity = line_connectivity(nqubits)
@@ -162,7 +165,8 @@ def test_random_circuits_15q_50g():
         transpiled_circuit=transpiled_circuit,
         final_map=final_qubit_map,
         initial_map=initial_layout,
-    )    
+    )
+
 
 def test_star_circuit():
     placer = Subgraph(star_connectivity())
@@ -310,24 +314,33 @@ def test_circuit_map():
     assert isinstance(routed_circuit.queue[0], gates.H)
     assert len(routed_circuit.queue) == 4
     qubits = routed_circuit.queue[2].qubits
-    assert routed_circuit.wire_names[qubits[0]] == "q1" and routed_circuit.wire_names[qubits[1]] == "q2"
-    
+    assert (
+        routed_circuit.wire_names[qubits[0]] == "q1"
+        and routed_circuit.wire_names[qubits[1]] == "q2"
+    )
+
     # test update 1
     circuit_map.update((0, 2))
     routed_circuit = circuit_map.routed_circuit()
     assert isinstance(routed_circuit.queue[4], gates.SWAP)
     qubits = routed_circuit.queue[4].qubits
-    assert routed_circuit.wire_names[qubits[0]] == "q1" and routed_circuit.wire_names[qubits[1]] == "q0"
+    assert (
+        routed_circuit.wire_names[qubits[0]] == "q1"
+        and routed_circuit.wire_names[qubits[1]] == "q0"
+    )
     assert circuit_map._swaps == 1
     assert circuit_map.physical_to_logical == [0, 2, 1, 3]
     assert circuit_map.logical_to_physical == [0, 2, 1, 3]
-    
+
     # test update 2
     circuit_map.update((1, 2))
     routed_circuit = circuit_map.routed_circuit()
     assert isinstance(routed_circuit.queue[5], gates.SWAP)
     qubits = routed_circuit.queue[5].qubits
-    assert routed_circuit.wire_names[qubits[0]] == "q2" and routed_circuit.wire_names[qubits[1]] == "q1"
+    assert (
+        routed_circuit.wire_names[qubits[0]] == "q2"
+        and routed_circuit.wire_names[qubits[1]] == "q1"
+    )
     assert circuit_map._swaps == 2
     assert circuit_map.physical_to_logical == [0, 1, 2, 3]
     assert circuit_map.logical_to_physical == [0, 1, 2, 3]
@@ -340,11 +353,20 @@ def test_circuit_map():
     assert isinstance(routed_circuit.queue[6], gates.CZ)
 
     qubits = routed_circuit.queue[6].qubits
-    assert routed_circuit.wire_names[qubits[0]] == "q1" and routed_circuit.wire_names[qubits[1]] == "q2"
+    assert (
+        routed_circuit.wire_names[qubits[0]] == "q1"
+        and routed_circuit.wire_names[qubits[1]] == "q2"
+    )
     qubits = routed_circuit.queue[7].qubits
-    assert routed_circuit.wire_names[qubits[0]] == "q0" and routed_circuit.wire_names[qubits[1]] == "q1"
+    assert (
+        routed_circuit.wire_names[qubits[0]] == "q0"
+        and routed_circuit.wire_names[qubits[1]] == "q1"
+    )
     qubits = routed_circuit.queue[8].qubits
-    assert routed_circuit.wire_names[qubits[0]] == "q2" and routed_circuit.wire_names[qubits[1]] == "q3"
+    assert (
+        routed_circuit.wire_names[qubits[0]] == "q2"
+        and routed_circuit.wire_names[qubits[1]] == "q3"
+    )
     assert len(circuit_map.circuit_blocks()) == 0
     # test final layout
     assert circuit_map.final_layout() == {"q0": 0, "q1": 1, "q2": 2, "q3": 3}

From 387afb4c6278572e4436c74c0a857af92a7c9fc8 Mon Sep 17 00:00:00 2001
From: changsookim <>
Date: Thu, 5 Sep 2024 18:31:27 +0800
Subject: [PATCH 16/40] add test func

---
 tests/test_transpiler_router.py | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/tests/test_transpiler_router.py b/tests/test_transpiler_router.py
index 0bf2390fa8..8c28a97878 100644
--- a/tests/test_transpiler_router.py
+++ b/tests/test_transpiler_router.py
@@ -565,3 +565,16 @@ def test_undo():
     assert circuit_map.logical_to_physical == [0, 1, 2, 3]
     assert circuit_map._swaps == 0
     assert len(circuit_map._routed_blocks.block_list) == 0
+
+def test_circuitmap_no_circuit():
+    # If a `CircuitMap` is not a temporary instance and is created without a circuit, it should raise an error.
+    with pytest.raises(ValueError):
+        circuit_map = CircuitMap()
+
+def test_logical_to_physical_setter():
+    circ = Circuit(4)
+    initial_layout = {"q0": 0, "q1": 3, "q2": 2, "q3": 1}
+    circuit_map = CircuitMap(initial_layout=initial_layout, circuit=circ)
+    circuit_map.logical_to_physical = [2, 0, 1, 3]
+    assert circuit_map.logical_to_physical == [2, 0, 1, 3]
+    assert circuit_map.physical_to_logical == [1, 2, 0, 3]
\ No newline at end of file

From 6dd6cedce72bf43f0ce3962dc1e14d82793257b4 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Thu, 5 Sep 2024 10:32:00 +0000
Subject: [PATCH 17/40] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 tests/test_transpiler_router.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/tests/test_transpiler_router.py b/tests/test_transpiler_router.py
index 8c28a97878..d5901d5f92 100644
--- a/tests/test_transpiler_router.py
+++ b/tests/test_transpiler_router.py
@@ -566,15 +566,17 @@ def test_undo():
     assert circuit_map._swaps == 0
     assert len(circuit_map._routed_blocks.block_list) == 0
 
+
 def test_circuitmap_no_circuit():
     # If a `CircuitMap` is not a temporary instance and is created without a circuit, it should raise an error.
     with pytest.raises(ValueError):
         circuit_map = CircuitMap()
 
+
 def test_logical_to_physical_setter():
     circ = Circuit(4)
     initial_layout = {"q0": 0, "q1": 3, "q2": 2, "q3": 1}
     circuit_map = CircuitMap(initial_layout=initial_layout, circuit=circ)
     circuit_map.logical_to_physical = [2, 0, 1, 3]
     assert circuit_map.logical_to_physical == [2, 0, 1, 3]
-    assert circuit_map.physical_to_logical == [1, 2, 0, 3]
\ No newline at end of file
+    assert circuit_map.physical_to_logical == [1, 2, 0, 3]

From c5a4af8cc516d49d1f3e2a6b8a5dceea912c7ce6 Mon Sep 17 00:00:00 2001
From: Changsoo Kim <57739683+csookim@users.noreply.github.com>
Date: Mon, 9 Sep 2024 23:31:31 +0800
Subject: [PATCH 18/40] Update src/qibo/transpiler/router.py

Co-authored-by: BrunoLiegiBastonLiegi <45011234+BrunoLiegiBastonLiegi@users.noreply.github.com>
---
 src/qibo/transpiler/router.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/qibo/transpiler/router.py b/src/qibo/transpiler/router.py
index f730679f84..e721e3209b 100644
--- a/src/qibo/transpiler/router.py
+++ b/src/qibo/transpiler/router.py
@@ -39,7 +39,7 @@ def assert_connectivity(connectivity: nx.Graph, circuit: Circuit):
             if physical_qubits not in connectivity.edges:
                 raise_error(
                     ConnectivityError,
-                    f"Circuit does not respect connectivity. {gate.name} acts on {physical_qubits}.",
+                    f"The circuit does not respect the connectivity. {gate.name} acts on {physical_qubits} but only the following qubits are directly connected: {connectivity.edges}.",
                 )
 
 

From 9ba69dcb02ce001d15aab1576c018b343829b4b8 Mon Sep 17 00:00:00 2001
From: Changsoo Kim <57739683+csookim@users.noreply.github.com>
Date: Mon, 9 Sep 2024 23:32:40 +0800
Subject: [PATCH 19/40] Update src/qibo/transpiler/router.py

Co-authored-by: BrunoLiegiBastonLiegi <45011234+BrunoLiegiBastonLiegi@users.noreply.github.com>
---
 src/qibo/transpiler/router.py | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

diff --git a/src/qibo/transpiler/router.py b/src/qibo/transpiler/router.py
index e721e3209b..e04a0e08cf 100644
--- a/src/qibo/transpiler/router.py
+++ b/src/qibo/transpiler/router.py
@@ -43,13 +43,20 @@ def assert_connectivity(connectivity: nx.Graph, circuit: Circuit):
                 )
 
 
-def _relabel_connectivity(connectivity, initial_layout):
+def _relabel_connectivity(connectivity, layout):
+    """Relabels the connectivity graph using the passed layout.
+    
+    Args:
+        connectivity (nx.Graph): input connectivity.
+        layout (dict): input qubit layout.
+    Returns:
+        (dict) the updated connectivity.
+    """
     node_mapping = {}
-    initial_layout = dict(
-        sorted(initial_layout.items(), key=lambda item: int(item[0][1:]))
+    layout = dict(
+        sorted(layout.items(), key=lambda item: int(item[0][1:]))
     )  # for q_i naming
-    for i, node in enumerate(list(initial_layout.keys())):
-        # node_mapping[node] = i
+    for i, node in enumerate(list(layout.keys())):
         node_mapping[int(node[1:])] = i  # for q_i naming
     new_connectivity = nx.relabel_nodes(connectivity, node_mapping)
     return new_connectivity

From 98fd9f1e22b201394695256718244bb599470457 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Mon, 9 Sep 2024 15:33:01 +0000
Subject: [PATCH 20/40] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/qibo/transpiler/router.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/qibo/transpiler/router.py b/src/qibo/transpiler/router.py
index e04a0e08cf..c869daa6cb 100644
--- a/src/qibo/transpiler/router.py
+++ b/src/qibo/transpiler/router.py
@@ -45,7 +45,7 @@ def assert_connectivity(connectivity: nx.Graph, circuit: Circuit):
 
 def _relabel_connectivity(connectivity, layout):
     """Relabels the connectivity graph using the passed layout.
-    
+
     Args:
         connectivity (nx.Graph): input connectivity.
         layout (dict): input qubit layout.

From 8641a0c2f4555cafc4d3505b1c9a2924162aa66c Mon Sep 17 00:00:00 2001
From: changsookim <>
Date: Tue, 10 Sep 2024 00:14:06 +0800
Subject: [PATCH 21/40] remove comments

---
 src/qibo/transpiler/router.py | 50 +++--------------------------------
 1 file changed, 4 insertions(+), 46 deletions(-)

diff --git a/src/qibo/transpiler/router.py b/src/qibo/transpiler/router.py
index c869daa6cb..fc05ea0abd 100644
--- a/src/qibo/transpiler/router.py
+++ b/src/qibo/transpiler/router.py
@@ -197,12 +197,12 @@ def __init__(
         initial_layout: Optional[dict] = None,
         circuit: Optional[Circuit] = None,
         blocks: Optional[CircuitBlocks] = None,
-        temp: Optional[bool] = False,  # 2# for temporary circuit
+        temp: Optional[bool] = False,
     ):
         self._p2l, self._l2p = [], []
 
         self._temporary = temp
-        if self._temporary:  # 2# if temporary circuit, no need to store the blocks
+        if self._temporary:
             return
         elif circuit is None:
             raise_error(ValueError, "Circuit must be provided.")
@@ -212,14 +212,13 @@ def __init__(
         else:
             self.circuit_blocks = CircuitBlocks(circuit, index_names=True)
 
-        self._nqubits = circuit.nqubits  # 1# number of qubits
+        self._nqubits = circuit.nqubits
         self._routed_blocks = CircuitBlocks(Circuit(circuit.nqubits))
         self._swaps = 0
 
         if initial_layout is None:
             return
 
-        # 1# initialize physical to logical mapping
         self.wire_names = list(initial_layout.keys())
         self.physical_to_logical = list(initial_layout.values())
 
@@ -240,8 +239,6 @@ def physical_to_logical(self, p2l_map: list):
         Args:
             p2l_map (list): physical to logical mapping.
         """
-        # 1# update bidirectional mapping
-        # 4# use shallow copy
         self._p2l = p2l_map.copy()
         self._l2p = [0] * len(self._p2l)
         for i, l in enumerate(self._p2l):
@@ -254,8 +251,6 @@ def logical_to_physical(self, l2p_map: list):
         Args:
             l2p_map (list): logical to physical mapping.
         """
-        # 1# update bidirectional mapping
-        # 4# use shallow copy
         self._l2p = l2p_map.copy()
         self._p2l = [0] * len(self._l2p)
         for i, p in enumerate(self._l2p):
@@ -307,7 +302,6 @@ def routed_circuit(self, circuit_kwargs: Optional[dict] = None):
     def final_layout(self):
         """Returns the final physical-logical qubits mapping."""
 
-        # 1# return {"A": lq_num0, "B": lq_num1, ...}
         return {self.wire_names[i]: self._p2l[i] for i in range(self._nqubits)}
 
     def update(self, logical_swap: tuple):
@@ -321,15 +315,12 @@ def update(self, logical_swap: tuple):
         """
 
         physical_swap = self.logical_pair_to_physical(logical_swap)
-
-        # 2# add the real SWAP gate, not a temporary circuit
         if not self._temporary:
             self._routed_blocks.add_block(
                 Block(qubits=physical_swap, gates=[gates.SWAP(*physical_swap)])
             )
             self._swaps += 1
 
-        # 1# update the bidirectional mapping
         self._update_mappings_swap(logical_swap, physical_swap)
 
     def undo(self):
@@ -340,7 +331,6 @@ def undo(self):
         self._routed_blocks.remove_block(last_swap_block)
         self._swaps -= 1
 
-        # 1# update the bidirectional mapping
         self._update_mappings_swap(logical_swap, physical_swap)
 
     def get_physical_qubits(self, block: Union[int, Block]):
@@ -357,7 +347,6 @@ def get_physical_qubits(self, block: Union[int, Block]):
 
         return tuple(self._l2p[q] for q in block.qubits)
 
-    # 1# logical_to_physical -> logical_pair_to_physical
     def logical_pair_to_physical(self, logical_qubits: tuple):
         """Returns the physical qubits associated to the logical qubit pair.
 
@@ -367,11 +356,8 @@ def logical_pair_to_physical(self, logical_qubits: tuple):
         Returns:
             tuple: physical qubit numbers associated to the logical qubit pair.
         """
-        # 1# return physical qubit numbers corresponding to the logical qubit pair
         return self._l2p[logical_qubits[0]], self._l2p[logical_qubits[1]]
 
-    # 1# circuit_to_logical(), circuit_to_physical() removed
-
 
 class ShortestPaths(Router):
     """A class to perform initial qubit mapping and connectivity matching.
@@ -475,9 +461,8 @@ def _add_swaps(candidate: tuple, circuitmap: CircuitMap):
         """
         path = candidate[0]
         meeting_point = candidate[1]
-        forward = path[0 : meeting_point + 1]  # 1# physical qubits
+        forward = path[0 : meeting_point + 1]
         backward = list(reversed(path[meeting_point + 1 :]))
-        # 1# apply logical swaps
         for f in forward[1:]:
             circuitmap.update(
                 (
@@ -504,13 +489,11 @@ def _compute_cost(self, candidate: tuple):
         Returns:
             (list, int): best path to move qubits and qubit meeting point in the path.
         """
-        # 2# CircuitMap might be used
         temporary_circuit = CircuitMap(
             circuit=Circuit(self.circuit_map._nqubits),
             blocks=deepcopy(self.circuit_map.circuit_blocks),
         )
 
-        # 1# copy the current physical to logical mapping
         temporary_circuit.physical_to_logical = self.circuit_map.physical_to_logical
         self._add_swaps(candidate, temporary_circuit)
         temporary_dag = deepcopy(self._dag)
@@ -525,7 +508,6 @@ def _compute_cost(self, candidate: tuple):
             all_executed = True
             for block in temporary_front_layer:
                 if (
-                    # 3# might be changed to use _get_dag_layer(qubits=True) to avoid using get_physical_qubits(block_num)
                     temporary_circuit.get_physical_qubits(block)
                     in self.connectivity.edges
                     or not temporary_circuit.circuit_blocks.search_by_index(
@@ -553,7 +535,6 @@ def _check_execution(self):
         executable_blocks = []
         for block in self._front_layer:
             if (
-                # 3# might be changed to use _get_dag_layer(qubits=True) to avoid using get_physical_qubits(block_num)
                 self.circuit_map.get_physical_qubits(block) in self.connectivity.edges
                 or not self.circuit_map.circuit_blocks.search_by_index(block).entangled
             ):
@@ -603,7 +584,6 @@ def _preprocessing(self, circuit: Circuit, initial_layout: dict):
             initial_layout (dict): initial physical-to-logical qubit mapping.
         """
 
-        # 1# Relabel the nodes of the connectivity graph
         self.connectivity = _relabel_connectivity(self.connectivity, initial_layout)
 
         copied_circuit = circuit.copy(deep=True)
@@ -639,7 +619,6 @@ def _append_final_measurements(self, routed_circuit: Circuit):
         for measurement in self._final_measurements:
             original_qubits = measurement.qubits
             routed_qubits = list(
-                # 1# use l2p to get physical qubit numbers
                 self.circuit_map.logical_to_physical[qubit]
                 for qubit in original_qubits
             )
@@ -763,7 +742,6 @@ def _preprocessing(self, circuit: Circuit, initial_layout: dict):
             initial_layout (dict): initial physical-to-logical qubit mapping.
         """
 
-        # 1# Relabel the nodes of the connectivity graph
         self.connectivity = _relabel_connectivity(self.connectivity, initial_layout)
 
         copied_circuit = circuit.copy(deep=True)
@@ -801,7 +779,6 @@ def _append_final_measurements(self, routed_circuit: Circuit):
         for measurement in self._final_measurements:
             original_qubits = measurement.qubits
             routed_qubits = list(
-                # 1# use l2p to get physical qubit numbers
                 self.circuit_map.logical_to_physical[qubit]
                 for qubit in original_qubits
             )
@@ -838,8 +815,6 @@ def _get_dag_layer(self, n_layer, qubits=False):
             (list): list of block numbers or target qubits.
         """
 
-        # 3# depend on the 'qubits' flag, return the block number or target qubits
-        # 3# return target qubits -> to avoid using get_physical_qubits(block_num)
         if qubits:
             return [
                 node[1]["qubits"]
@@ -853,7 +828,6 @@ def _find_new_mapping(self):
         """Find the new best mapping by adding one swap."""
         candidates_evaluation = {}
 
-        # 4# use shallow copy
         self._memory_map.append(self.circuit_map.physical_to_logical.copy())
         for candidate in self._swap_candidates():
             candidates_evaluation[candidate] = self._compute_cost(candidate)
@@ -872,28 +846,19 @@ def _find_new_mapping(self):
     def _compute_cost(self, candidate: int):
         """Compute the cost associated to a possible SWAP candidate."""
 
-        # 2# use CircuitMap for temporary circuit to save time
-        # 2# no gates, no block decomposition, no Circuit object
-        # 2# just logical-physical mapping
         temporary_circuit = CircuitMap(temp=True)
-
-        # 1# copy the current physical to logical mapping
         temporary_circuit.physical_to_logical = self.circuit_map.physical_to_logical
         temporary_circuit.update(candidate)
 
-        # 1# use p2l to check if the mapping is already in the memory
         if temporary_circuit.physical_to_logical in self._memory_map:
             return float("inf")
 
         tot_distance = 0.0
         weight = 1.0
         for layer in range(self.lookahead + 1):
-            # 3# return gates' target qubit pairs in the layer
-            # 3# to avoid using get_physical_qubits(block_num)
             layer_gates = self._get_dag_layer(layer, qubits=True)
             avg_layer_distance = 0.0
             for lq_pair in layer_gates:
-                # 3# logical qubit pairs to node numbers (physical qubit pairs) in the connectivity graph
                 qubits = temporary_circuit.logical_pair_to_physical(lq_pair)
                 avg_layer_distance += (
                     max(self._delta_register[i] for i in qubits)
@@ -915,7 +880,6 @@ def _swap_candidates(self):
             (list): list of candidates.
         """
         candidates = []
-        # 3# might be changed to use _get_dag_layer(qubits=True) to avoid using get_physical_qubits(block_num)
         for block in self._front_layer:
             for qubit in self.circuit_map.get_physical_qubits(block):
                 for connected in self.connectivity.neighbors(qubit):
@@ -941,7 +905,6 @@ def _check_execution(self):
         executable_blocks = []
         for block in self._front_layer:
             if (
-                # 3# might be changed to use _get_dag_layer(qubits=True) to avoid using get_physical_qubits(block_num)
                 self.circuit_map.get_physical_qubits(block) in self.connectivity.edges
                 or not self.circuit_map.circuit_blocks.search_by_index(block).entangled
             ):
@@ -984,8 +947,6 @@ def _shortest_path_routing(self):
         shortest_path_qubits = None
 
         for block in self._front_layer:
-            # 3# return node numbers (physical qubits) in the connectivity graph
-            # 3# might be changed to use _get_dag_layer(qubits=True) to avoid using get_physical_qubits(block_num)
             q1, q2 = self.circuit_map.get_physical_qubits(block)
             distance = self._dist_matrix[q1, q2]
 
@@ -998,7 +959,6 @@ def _shortest_path_routing(self):
         )
 
         # move q1
-        # 1# qubit moving algorithm is changed
         q1 = self.circuit_map.physical_to_logical[shortest_path[0]]
         for q2 in shortest_path[1:-1]:
             self.circuit_map.update((q1, self.circuit_map.physical_to_logical[q2]))
@@ -1019,7 +979,6 @@ def _create_dag(gates_qubits_pairs: list):
     dag = nx.DiGraph()
     dag.add_nodes_from(range(len(gates_qubits_pairs)))
 
-    # 3# additionally store target qubits of the gates
     for i in range(len(gates_qubits_pairs)):
         dag.nodes[i]["qubits"] = gates_qubits_pairs[i]
 
@@ -1051,7 +1010,6 @@ def _remove_redundant_connections(dag: nx.DiGraph):
         (:class:`networkx.DiGraph`): reduced dag.
     """
     new_dag = nx.DiGraph()
-    # 3# add nodes with attributes
     new_dag.add_nodes_from(dag.nodes(data=True))
     transitive_reduction = nx.transitive_reduction(dag)
     new_dag.add_edges_from(transitive_reduction.edges)

From fced73c8d772cc5468a24e791f85ae2c4ad5e39a Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Mon, 9 Sep 2024 16:14:43 +0000
Subject: [PATCH 22/40] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/qibo/transpiler/router.py | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/qibo/transpiler/router.py b/src/qibo/transpiler/router.py
index fc05ea0abd..b1aad8fc69 100644
--- a/src/qibo/transpiler/router.py
+++ b/src/qibo/transpiler/router.py
@@ -619,8 +619,7 @@ def _append_final_measurements(self, routed_circuit: Circuit):
         for measurement in self._final_measurements:
             original_qubits = measurement.qubits
             routed_qubits = list(
-                self.circuit_map.logical_to_physical[qubit]
-                for qubit in original_qubits
+                self.circuit_map.logical_to_physical[qubit] for qubit in original_qubits
             )
             routed_circuit.add(
                 measurement.on_qubits(dict(zip(original_qubits, routed_qubits)))
@@ -779,8 +778,7 @@ def _append_final_measurements(self, routed_circuit: Circuit):
         for measurement in self._final_measurements:
             original_qubits = measurement.qubits
             routed_qubits = list(
-                self.circuit_map.logical_to_physical[qubit]
-                for qubit in original_qubits
+                self.circuit_map.logical_to_physical[qubit] for qubit in original_qubits
             )
             routed_circuit.add(
                 measurement.on_qubits(dict(zip(original_qubits, routed_qubits)))

From ca20f93c4a91d01843c53dd5e7b4666ee5a6f8a2 Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Tue, 10 Sep 2024 14:08:38 +0400
Subject: [PATCH 23/40] fix math rendering

---
 src/qibo/quantum_info/entropies.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/qibo/quantum_info/entropies.py b/src/qibo/quantum_info/entropies.py
index 05bf3f823f..0ee7250008 100644
--- a/src/qibo/quantum_info/entropies.py
+++ b/src/qibo/quantum_info/entropies.py
@@ -78,7 +78,7 @@ def classical_relative_entropy(prob_dist_p, prob_dist_q, base: float = 2, backen
 
     For probabilities :math:`\\mathbf{p}` and :math:`\\mathbf{q}`, it is defined as
 
-    ..math::
+    .. math::
         D(\\mathbf{p} \\, \\| \\, \\mathbf{q}) = \\sum_{x} \\, \\mathbf{p}(x) \\,
             \\log\\left( \\frac{\\mathbf{p}(x)}{\\mathbf{q}(x)} \\right) \\, .
 

From 6e800d8256c2f9c8d65cfaf636c3327235f14ba4 Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Tue, 10 Sep 2024 14:25:03 +0400
Subject: [PATCH 24/40] fix note

---
 src/qibo/quantum_info/entropies.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/qibo/quantum_info/entropies.py b/src/qibo/quantum_info/entropies.py
index 0ee7250008..c9c889b603 100644
--- a/src/qibo/quantum_info/entropies.py
+++ b/src/qibo/quantum_info/entropies.py
@@ -680,7 +680,7 @@ def relative_renyi_entropy(
     This is known as the `min-relative entropy <https://arxiv.org/abs/1310.7178>`_.
 
     .. note::
-        Function raises ``NotImplementedError`` when ``target`` :math:`sigma`
+        Function raises ``NotImplementedError`` when ``target`` :math:`\\sigma`
         is a pure state and :math:`\\alpha > 1`. This is due to the fact that
         it is not possible to calculate :math:`\\sigma^{1 - \\alpha}` when
         :math:`\\alpha > 1` and :math:`\\sigma` is a projector, i.e. a singular matrix.

From 028bb098341a8940cc49ee2fb76e37d96ee45f6f Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Tue, 10 Sep 2024 15:31:18 +0400
Subject: [PATCH 25/40] fix `qibo.rst`

---
 doc/source/api-reference/qibo.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/source/api-reference/qibo.rst b/doc/source/api-reference/qibo.rst
index 1b254088b3..5d013b103a 100644
--- a/doc/source/api-reference/qibo.rst
+++ b/doc/source/api-reference/qibo.rst
@@ -2382,7 +2382,7 @@ Hellinger fidelity
 Hellinger shot error
 """"""""""""""""""""
 
-.. autofunction:: qibo.quantum_info.hellinger_fidelity
+.. autofunction:: qibo.quantum_info.hellinger_shot_error
 
 
 Haar integral

From a3f23682f3df6e2ebcd4de6864aa0bdf651ce328 Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Tue, 10 Sep 2024 15:32:28 +0400
Subject: [PATCH 26/40] disable lint error

---
 src/qibo/ui/mpldrawer.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py
index 778a429fe2..cac3759be3 100644
--- a/src/qibo/ui/mpldrawer.py
+++ b/src/qibo/ui/mpldrawer.py
@@ -601,7 +601,7 @@ def _process_gates(array_gates):
                 item += ("q_" + str(qbit),)
                 gates_plot.append(item)
         elif init_label == "ENTANGLEMENTENTROPY":
-            for qbit in list(range(circuit.nqubits)):
+            for qbit in list(range(circuit.nqubits)):  # pylint: disable=E0602
                 item = (init_label,)
                 item += ("q_" + str(qbit),)
                 gates_plot.append(item)

From 2590ff52c032ba290559eb09029b564cec583dee Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Wed, 11 Sep 2024 10:51:22 +0400
Subject: [PATCH 27/40] fix warnings

---
 doc/source/api-reference/qibo.rst   |  3 ++-
 src/qibo/backends/abstract.py       |  2 +-
 src/qibo/backends/clifford.py       |  6 +++---
 src/qibo/gates/measurements.py      | 13 ++++++-------
 src/qibo/models/error_mitigation.py | 10 +++++-----
 src/qibo/quantum_info/clifford.py   | 14 +++++++-------
 src/qibo/result.py                  | 20 +++++++++++---------
 7 files changed, 35 insertions(+), 33 deletions(-)

diff --git a/doc/source/api-reference/qibo.rst b/doc/source/api-reference/qibo.rst
index 1b254088b3..6cc3d8ab53 100644
--- a/doc/source/api-reference/qibo.rst
+++ b/doc/source/api-reference/qibo.rst
@@ -473,7 +473,8 @@ factor results in the mitigated Pauli expectation value :math:`\langle O\rangle_
 .. math::
    \langle O\rangle_{ideal} = \frac{\langle O\rangle_{noisy}}{\lambda}
 
-.. autofunction:: qibo.models.error_mitigation.apply_randomized_readout_mitigation
+This process can be implemented with the aforementioned 
+:func:`qibo.models.error_mitigation.apply_randomized_readout_mitigation`.
 
 
 Zero Noise Extrapolation (ZNE)
diff --git a/src/qibo/backends/abstract.py b/src/qibo/backends/abstract.py
index 5a14c24025..abe1f20d83 100644
--- a/src/qibo/backends/abstract.py
+++ b/src/qibo/backends/abstract.py
@@ -193,7 +193,7 @@ def execute_circuit(
     def execute_circuits(
         self, circuits, initial_states=None, nshots=None
     ):  # pragma: no cover
-        """Execute multiple :class:`qibo.models.circuit.Circuit`s in parallel."""
+        """Execute multiple :class:`qibo.models.circuit.Circuit` in parallel."""
         raise_error(NotImplementedError)
 
     @abc.abstractmethod
diff --git a/src/qibo/backends/clifford.py b/src/qibo/backends/clifford.py
index 1ba071cd40..aee8750e34 100644
--- a/src/qibo/backends/clifford.py
+++ b/src/qibo/backends/clifford.py
@@ -90,13 +90,13 @@ def calculate_frequencies(self, samples):
         return collections.Counter(dict(zip(res, counts)))
 
     def zero_state(self, nqubits: int):
-        """Construct the zero state |00...00>.
+        """Construct the zero state :math`\\ket{00...00}`.
 
         Args:
-            nqubits (int): Number of qubits.
+            nqubits (int): number of qubits.
 
         Returns:
-            (ndarray): Symplectic matrix for the zero state.
+            ndarray: Symplectic matrix for the zero state.
         """
         identity = self.np.eye(nqubits)
         symplectic_matrix = self.np.zeros(
diff --git a/src/qibo/gates/measurements.py b/src/qibo/gates/measurements.py
index 7e1559e9d9..64a7a98e50 100644
--- a/src/qibo/gates/measurements.py
+++ b/src/qibo/gates/measurements.py
@@ -17,27 +17,26 @@ class M(Gate):
             If the qubits to measure are held in an iterable (eg. list) the ``*``
             operator can be used, for example ``gates.M(*[0, 1, 4])`` or
             ``gates.M(*range(5))``.
-        register_name (str): Optional name of the register to distinguish it
+        register_name (str, optional): Optional name of the register to distinguish it
             from other registers when used in circuits.
         collapse (bool): Collapse the state vector after the measurement is
             performed. Can be used only for single shot measurements.
             If ``True`` the collapsed state vector is returned. If ``False``
             the measurement result is returned.
-        basis (:class:`qibo.gates.Gate`, str, list): Basis to measure.
+        basis (:class:`qibo.gates.Gate` or str or list, optional): Basis to measure.
             Can be either:
             - a qibo gate
             - the string representing the gate
             - a callable that accepts a qubit, for example: ``lambda q: gates.RX(q, 0.2)``
-            - a list of the above, if a different basis will be used for each
-              measurement qubit.
-            Default is Z.
-        p0 (dict): Optional bitflip probability map. Can be:
+            - a list of the above, if a different basis will be used for each measurement qubit.
+            Defaults is to :class:`qibo.gates.Z`.
+        p0 (dict, optional): bitflip probability map. Can be:
             A dictionary that maps each measured qubit to the probability
             that it is flipped, a list or tuple that has the same length
             as the tuple of measured qubits or a single float number.
             If a single float is given the same probability will be used
             for all qubits.
-        p1 (dict): Optional bitflip probability map for asymmetric bitflips.
+        p1 (dict, optional): bitflip probability map for asymmetric bitflips.
             Same as ``p0`` but controls the 1->0 bitflip probability.
             If ``p1`` is ``None`` then ``p0`` will be used both for 0->1 and
             1->0 bitflips.
diff --git a/src/qibo/models/error_mitigation.py b/src/qibo/models/error_mitigation.py
index eea1071399..def0b3c528 100644
--- a/src/qibo/models/error_mitigation.py
+++ b/src/qibo/models/error_mitigation.py
@@ -658,8 +658,8 @@ def apply_randomized_readout_mitigation(
         nshots (int, optional): number of shots. Defaults to :math:`10000`.
         ncircuits (int, optional): number of randomized circuits. Each of them uses
             ``int(nshots / ncircuits)`` shots. Defaults to 10.
-        qubit_map (list, optional): the qubit map. If None, a list of range of circuit's qubits is used.
-            Defaults to ``None``.
+        qubit_map (list, optional): the qubit map. If ``None``, a list of range of circuit's 
+            qubits is used. Defaults to ``None``.
         seed (int or :class:`numpy.random.Generator`, optional): Either a generator of random
             numbers or a fixed seed to initialize a generator. If ``None``, initializes
             a generator with a random seed. Default: ``None``.
@@ -667,15 +667,15 @@ def apply_randomized_readout_mitigation(
             in the execution. If ``None``, it uses :class:`qibo.backends.GlobalBackend`.
             Defaults to ``None``.
 
-    Return:
+    Returns:
         :class:`qibo.measurements.CircuitResult`: the state of the input circuit with
             mitigated frequencies.
 
 
-    Reference:
+    References:
         1. Ewout van den Berg, Zlatko K. Minev et al,
         *Model-free readout-error mitigation for quantum expectation values*.
-           `arXiv:2012.09738 [quant-ph] <https://arxiv.org/abs/2012.09738>`_.
+        `arXiv:2012.09738 [quant-ph] <https://arxiv.org/abs/2012.09738>`_.
     """
     from qibo import Circuit  # pylint: disable=import-outside-toplevel
     from qibo.quantum_info import (  # pylint: disable=import-outside-toplevel
diff --git a/src/qibo/quantum_info/clifford.py b/src/qibo/quantum_info/clifford.py
index 000aa6bcd0..15f95070d8 100644
--- a/src/qibo/quantum_info/clifford.py
+++ b/src/qibo/quantum_info/clifford.py
@@ -297,16 +297,16 @@ def frequencies(self, binary: bool = True, registers: bool = False):
             of times each measured value/bitstring appears.
 
             If ``binary`` is ``True``
-                the keys of the `Counter` are in binary form, as strings of
-                :math:`0`s and :math`1`s.
+                the keys of the :class:`collections.Counter` are in binary form, 
+                as strings of :math:`0` and :math`1`.
             If ``binary`` is ``False``
-                the keys of the ``Counter`` are integers.
+                the keys of the :class:`collections.Counter` are integers.
             If ``registers`` is ``True``
-                a `dict` of `Counter` s is returned where keys are the name of
-                each register.
+                a `dict` of :class:`collections.Counter` is returned where keys are
+                the name of each register.
             If ``registers`` is ``False``
-                a single ``Counter`` is returned which contains samples from all
-                the measured qubits, independently of their registers.
+                a single :class:`collections.Counter` is returned which contains samples 
+                from all the measured qubits, independently of their registers.
         """
         measured_qubits = self.measurement_gate.target_qubits
         freq = self._backend.calculate_frequencies(self.samples(False))
diff --git a/src/qibo/result.py b/src/qibo/result.py
index b2fa8a95fd..752094c020 100644
--- a/src/qibo/result.py
+++ b/src/qibo/result.py
@@ -191,25 +191,27 @@ def frequencies(self, binary: bool = True, registers: bool = False):
         """Returns the frequencies of measured samples.
 
         Args:
-            binary (bool, optional): Return frequency keys in binary or decimal form.
+            binary (bool, optional): If ``True``, returns frequency keys in binary form.
+                If ``False``, returns them in decimal form. Defaults to ``True``.
             registers (bool, optional): Group frequencies according to registers.
+                Defaults to ``False``.
 
         Returns:
-            A `collections.Counter` where the keys are the observed values
+            A :class:`collections.Counter` where the keys are the observed values
             and the values the corresponding frequencies, that is the number
             of times each measured value/bitstring appears.
 
             If ``binary`` is ``True``
-                the keys of the `Counter` are in binary form, as strings of
-                :math:`0`s and :math`1`s.
+                the keys of the :class:`collections.Counter` are in binary form, 
+                as strings of :math:`0` and :math`1`.
             If ``binary`` is ``False``
-                the keys of the ``Counter`` are integers.
+                the keys of the :class:`collections.Counter` are integers.
             If ``registers`` is ``True``
-                a `dict` of `Counter` s is returned where keys are the name of
-                each register.
+                a `dict` of :class:`collections.Counter` is returned where keys are
+                the name of each register.
             If ``registers`` is ``False``
-                a single ``Counter`` is returned which contains samples from all
-                the measured qubits, independently of their registers.
+                a single :class:`collections.Counter` is returned which contains samples 
+                from all the measured qubits, independently of their registers.
         """
         qubits = self.measurement_gate.qubits
 

From 6d0d58b95deccd5966f7135bfbb7653688e58a0c Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Wed, 11 Sep 2024 06:53:37 +0000
Subject: [PATCH 28/40] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 doc/source/api-reference/qibo.rst   | 2 +-
 src/qibo/models/error_mitigation.py | 2 +-
 src/qibo/quantum_info/clifford.py   | 4 ++--
 src/qibo/result.py                  | 4 ++--
 4 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/doc/source/api-reference/qibo.rst b/doc/source/api-reference/qibo.rst
index 6cc3d8ab53..7321d9bc4c 100644
--- a/doc/source/api-reference/qibo.rst
+++ b/doc/source/api-reference/qibo.rst
@@ -473,7 +473,7 @@ factor results in the mitigated Pauli expectation value :math:`\langle O\rangle_
 .. math::
    \langle O\rangle_{ideal} = \frac{\langle O\rangle_{noisy}}{\lambda}
 
-This process can be implemented with the aforementioned 
+This process can be implemented with the aforementioned
 :func:`qibo.models.error_mitigation.apply_randomized_readout_mitigation`.
 
 
diff --git a/src/qibo/models/error_mitigation.py b/src/qibo/models/error_mitigation.py
index def0b3c528..3b16f8ac9d 100644
--- a/src/qibo/models/error_mitigation.py
+++ b/src/qibo/models/error_mitigation.py
@@ -658,7 +658,7 @@ def apply_randomized_readout_mitigation(
         nshots (int, optional): number of shots. Defaults to :math:`10000`.
         ncircuits (int, optional): number of randomized circuits. Each of them uses
             ``int(nshots / ncircuits)`` shots. Defaults to 10.
-        qubit_map (list, optional): the qubit map. If ``None``, a list of range of circuit's 
+        qubit_map (list, optional): the qubit map. If ``None``, a list of range of circuit's
             qubits is used. Defaults to ``None``.
         seed (int or :class:`numpy.random.Generator`, optional): Either a generator of random
             numbers or a fixed seed to initialize a generator. If ``None``, initializes
diff --git a/src/qibo/quantum_info/clifford.py b/src/qibo/quantum_info/clifford.py
index 15f95070d8..f4ec2d6bce 100644
--- a/src/qibo/quantum_info/clifford.py
+++ b/src/qibo/quantum_info/clifford.py
@@ -297,7 +297,7 @@ def frequencies(self, binary: bool = True, registers: bool = False):
             of times each measured value/bitstring appears.
 
             If ``binary`` is ``True``
-                the keys of the :class:`collections.Counter` are in binary form, 
+                the keys of the :class:`collections.Counter` are in binary form,
                 as strings of :math:`0` and :math`1`.
             If ``binary`` is ``False``
                 the keys of the :class:`collections.Counter` are integers.
@@ -305,7 +305,7 @@ def frequencies(self, binary: bool = True, registers: bool = False):
                 a `dict` of :class:`collections.Counter` is returned where keys are
                 the name of each register.
             If ``registers`` is ``False``
-                a single :class:`collections.Counter` is returned which contains samples 
+                a single :class:`collections.Counter` is returned which contains samples
                 from all the measured qubits, independently of their registers.
         """
         measured_qubits = self.measurement_gate.target_qubits
diff --git a/src/qibo/result.py b/src/qibo/result.py
index 752094c020..e92707c3b2 100644
--- a/src/qibo/result.py
+++ b/src/qibo/result.py
@@ -202,7 +202,7 @@ def frequencies(self, binary: bool = True, registers: bool = False):
             of times each measured value/bitstring appears.
 
             If ``binary`` is ``True``
-                the keys of the :class:`collections.Counter` are in binary form, 
+                the keys of the :class:`collections.Counter` are in binary form,
                 as strings of :math:`0` and :math`1`.
             If ``binary`` is ``False``
                 the keys of the :class:`collections.Counter` are integers.
@@ -210,7 +210,7 @@ def frequencies(self, binary: bool = True, registers: bool = False):
                 a `dict` of :class:`collections.Counter` is returned where keys are
                 the name of each register.
             If ``registers`` is ``False``
-                a single :class:`collections.Counter` is returned which contains samples 
+                a single :class:`collections.Counter` is returned which contains samples
                 from all the measured qubits, independently of their registers.
         """
         qubits = self.measurement_gate.qubits

From d6b9cab9de62d5898787311ad5a3ba549fe01f14 Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Wed, 11 Sep 2024 10:54:18 +0400
Subject: [PATCH 29/40] disable lint error

---
 src/qibo/ui/mpldrawer.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py
index 778a429fe2..cac3759be3 100644
--- a/src/qibo/ui/mpldrawer.py
+++ b/src/qibo/ui/mpldrawer.py
@@ -601,7 +601,7 @@ def _process_gates(array_gates):
                 item += ("q_" + str(qbit),)
                 gates_plot.append(item)
         elif init_label == "ENTANGLEMENTENTROPY":
-            for qbit in list(range(circuit.nqubits)):
+            for qbit in list(range(circuit.nqubits)):  # pylint: disable=E0602
                 item = (init_label,)
                 item += ("q_" + str(qbit),)
                 gates_plot.append(item)

From 4f2c03d1e2c937bc98e757b9194ff49a40cf9fd6 Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Wed, 11 Sep 2024 13:03:07 +0400
Subject: [PATCH 30/40] docstrings in `basis`

---
 src/qibo/quantum_info/basis.py | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/qibo/quantum_info/basis.py b/src/qibo/quantum_info/basis.py
index 5ea541bca0..2378027618 100644
--- a/src/qibo/quantum_info/basis.py
+++ b/src/qibo/quantum_info/basis.py
@@ -29,14 +29,14 @@ def pauli_basis(
             all Pauli matrices. If ``True``, retuns an array where every
             row is a vectorized Pauli matrix. Defaults to ``False``.
         sparse (bool, optional) If ``True``, retuns Pauli basis in a sparse
-            representation. Default is ``False``.
+            representation. Defaults to ``False``.
         order (str, optional): If ``"row"``, vectorization of Pauli basis is
             performed row-wise. If ``"column"``, vectorization is performed
             column-wise. If ``"system"``, system-wise vectorization is
             performed. If ``vectorization=False``, then ``order=None`` is
-            forced. Default is ``None``.
+            forced. Defaults to ``None``.
         pauli_order (str, optional): corresponds to the order of 4 single-qubit
-            Pauli elements. Default is "IXYZ".
+            Pauli elements. Defaults to ``"IXYZ"``.
         backend (:class:`qibo.backends.abstract.Backend`, optional): backend
             to be used in the execution. If ``None``, it uses
             :class:`qibo.backends.GlobalBackend`. Defaults to ``None``.
@@ -174,13 +174,13 @@ def comp_basis_to_pauli(
         normalize (bool, optional): If ``True``, converts to the
             Pauli basis. Defaults to ``False``.
         sparse (bool, optional): If ``True``, returns unitary matrix in
-            sparse representation. Default is ``False``.
+            sparse representation. Defaults to ``False``.
         order (str, optional): If ``"row"``, vectorization of Pauli basis is
             performed row-wise. If ``"column"``, vectorization is performed
             column-wise. If ``"system"``, system-wise vectorization is
-            performed. Default is ``"row"``.
+            performed. Defaults to ``"row"``.
         pauli_order (str, optional): corresponds to the order of 4 single-qubit
-            Pauli elements. Default is "IXYZ".
+            Pauli elements. Defaults to ``"IXYZ"``.
         backend (:class:`qibo.backends.abstract.Backend`, optional): backend to be
             used in the execution. If ``None``, it uses
             :class:`qibo.backends.GlobalBackend`. Defaults to ``None``.
@@ -244,13 +244,13 @@ def pauli_to_comp_basis(
         normalize (bool, optional): If ``True``, converts to the
             Pauli basis. Defaults to ``False``.
         sparse (bool, optional): If ``True``, returns unitary matrix in
-            sparse representation. Default is ``False``.
+            sparse representation. Defaults to ``False``.
         order (str, optional): If ``"row"``, vectorization of Pauli basis is
             performed row-wise. If ``"column"``, vectorization is performed
             column-wise. If ``"system"``, system-wise vectorization is
-            performed. Default is ``"row"``.
+            performed. Defaults to ``"row"``.
         pauli_order (str, optional): corresponds to the order of 4 single-qubit
-            Pauli elements. Default is "IXYZ".
+            Pauli elements. Defaults to ``"IXYZ"``.
         backend (:class:`qibo.backends.abstract.Backend`, optional): backend to be
             used in the execution. If ``None``, it uses
             :class:`qibo.backends.GlobalBackend`. Defaults to ``None``.

From e69315554af9db3c0f8cb138c03aaa146b2c7450 Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Wed, 11 Sep 2024 13:05:46 +0400
Subject: [PATCH 31/40] missing colon

---
 src/qibo/quantum_info/basis.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/qibo/quantum_info/basis.py b/src/qibo/quantum_info/basis.py
index 2378027618..efd8bdfe86 100644
--- a/src/qibo/quantum_info/basis.py
+++ b/src/qibo/quantum_info/basis.py
@@ -28,7 +28,7 @@ def pauli_basis(
         vectorize (bool, optional): If ``False``, returns a nested array with
             all Pauli matrices. If ``True``, retuns an array where every
             row is a vectorized Pauli matrix. Defaults to ``False``.
-        sparse (bool, optional) If ``True``, retuns Pauli basis in a sparse
+        sparse (bool, optional): If ``True``, retuns Pauli basis in a sparse
             representation. Defaults to ``False``.
         order (str, optional): If ``"row"``, vectorization of Pauli basis is
             performed row-wise. If ``"column"``, vectorization is performed

From 5473a5a91f1b1d2cef47440de77afa0a788a3ff1 Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Wed, 11 Sep 2024 13:30:09 +0400
Subject: [PATCH 32/40] `comp_basis_to_pauli`

---
 src/qibo/quantum_info/basis.py | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/src/qibo/quantum_info/basis.py b/src/qibo/quantum_info/basis.py
index efd8bdfe86..cc22f268c6 100644
--- a/src/qibo/quantum_info/basis.py
+++ b/src/qibo/quantum_info/basis.py
@@ -148,15 +148,11 @@ def comp_basis_to_pauli(
     The unitary :math:`U` is given by
 
     .. math::
-        U = \\sum_{k = 0}^{d^{2} - 1} \\, \\ketbra{k}{P_{k}} \\,\\, ,
+        U = \\sum_{k = 0}^{d^{2} - 1} \\, |k)(P_{k}| \\,\\, ,
 
-    where :math:`\\ket{P_{k}}` is the system-vectorization of the :math:`k`-th
-    Pauli operator :math:`P_{k}`, and :math:`\\ket{k}` is the computational
-    basis element.
-
-    When converting a state :math:`\\ket{\\rho}` to its Pauli-Liouville
-    representation :math:`\\ket{\\rho'}`, one should use ``order="system"``
-    in :func:`vectorization`.
+    where :math:`|P_{k})` is the vectorization of the :math:`k`-th
+    Pauli operator :math:`P_{k}`, and :math:`|k)` is the vectorization
+    of the :math:`k`-th computational basis element.
 
     Example:
         .. code-block:: python

From 4af035ff55241204573b20d4a19c1e2c875e8b6d Mon Sep 17 00:00:00 2001
From: MatteoRobbiati <robbiati.matteo@gmail.com>
Date: Wed, 11 Sep 2024 11:37:03 +0200
Subject: [PATCH 33/40] fix: lint error and failing line in the docs

---
 doc/source/code-examples/examples.rst |  2 --
 src/qibo/ui/mpldrawer.py              | 44 +++++++++------------------
 2 files changed, 15 insertions(+), 31 deletions(-)

diff --git a/doc/source/code-examples/examples.rst b/doc/source/code-examples/examples.rst
index 1896cffb51..081e8fc71d 100644
--- a/doc/source/code-examples/examples.rst
+++ b/doc/source/code-examples/examples.rst
@@ -347,8 +347,6 @@ For example, we can draw the QFT circuit for 5-qubits:
         # new plot function based on matplotlib
         from qibo.ui import plot_circuit
 
-        %matplotlib inline
-
         # create a 5-qubits QFT circuit
         c = QFT(5)
         c.add(gates.M(qubit) for qubit in range(2))
diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py
index 778a429fe2..de8df49900 100644
--- a/src/qibo/ui/mpldrawer.py
+++ b/src/qibo/ui/mpldrawer.py
@@ -227,20 +227,6 @@ def _draw_controls(ax, i, gate, labels, gate_grid, wire_grid, plot_params, measu
             wire_grid[max_wire],
             plot_params,
         )
-        ismeasured = False
-        for index in control_indices:
-            if measured.get(index, 1000) < i:
-                ismeasured = True
-        if ismeasured:
-            dy = 0.04  # TODO: put in plot_params
-            _line(
-                ax,
-                gate_grid[i] + dy,
-                gate_grid[i] + dy,
-                wire_grid[min_wire],
-                wire_grid[max_wire],
-                plot_params,
-            )
 
         for ci in control_indices:
             x = gate_grid[i]
@@ -301,12 +287,8 @@ def _draw_target(ax, i, gate, labels, gate_grid, wire_grid, plot_params):
     x = gate_grid[i]
     target_index = _get_flipped_index(target, labels)
     y = wire_grid[target_index]
-    if not symbol:
-        return
     if name in ["CNOT", "TOFFOLI"]:
         _oplus(ax, x, y, plot_params)
-    elif name == "CPHASE":
-        _cdot(ax, x, y, plot_params)
     elif name == "SWAP":
         _swapx(ax, x, y, plot_params)
     else:
@@ -553,12 +535,13 @@ def _make_cluster_gates(gates_items):
     return cluster_gates
 
 
-def _process_gates(array_gates):
+def _process_gates(array_gates, nqubits):
     """
     Transforms the list of gates given by the Qibo circuit into a list of gates with a suitable structre to print on screen with matplotlib.
 
     Args:
         array_gates (list): List of gates provided by the Qibo circuit.
+        nqubits (int): Number of circuit qubits
 
     Returns:
         list: List of suitable gates to plot with matplotlib.
@@ -601,7 +584,7 @@ def _process_gates(array_gates):
                 item += ("q_" + str(qbit),)
                 gates_plot.append(item)
         elif init_label == "ENTANGLEMENTENTROPY":
-            for qbit in list(range(circuit.nqubits)):
+            for qbit in list(range(nqubits)):
                 item = (init_label,)
                 item += ("q_" + str(qbit),)
                 gates_plot.append(item)
@@ -610,13 +593,13 @@ def _process_gates(array_gates):
             item += (init_label,)
 
             for qbit in gate._target_qubits:
-                if qbit is tuple:
+                if type(qbit) is tuple:
                     item += ("q_" + str(qbit[0]),)
                 else:
                     item += ("q_" + str(qbit),)
 
             for qbit in gate._control_qubits:
-                if qbit is tuple:
+                if type(qbit) is tuple:
                     item += ("q_" + str(qbit[0]),)
                 else:
                     item += ("q_" + str(qbit),)
@@ -637,10 +620,11 @@ def _plot_params(style: Union[dict, str, None]) -> dict:
         dict: Style configuration.
     """
     if not isinstance(style, dict):
-        try:
-            style = STYLE.get(style) if (style is not None) else STYLE["default"]
-        except AttributeError:
-            style = STYLE["default"]
+        style = (
+            STYLE.get(style)
+            if (style is not None and style in STYLE.keys())
+            else STYLE["default"]
+        )
 
     return style
 
@@ -718,9 +702,11 @@ def plot_circuit(circuit, scale=0.6, cluster_gates=True, style=None):
             fgates = None
 
             if cluster_gates:
-                fgates = _make_cluster_gates(_process_gates(gate.gates))
+                fgates = _make_cluster_gates(
+                    _process_gates(gate.gates, circuit.nqubits)
+                )
             else:
-                fgates = _process_gates(gate.gates)
+                fgates = _process_gates(gate.gates, circuit.nqubits)
 
             l_gates = len(gate.gates)
             equal_qbits = False
@@ -736,7 +722,7 @@ def plot_circuit(circuit, scale=0.6, cluster_gates=True, style=None):
         else:
             all_gates.append(gate)
 
-    gates_plot = _process_gates(all_gates)
+    gates_plot = _process_gates(all_gates, circuit.nqubits)
 
     if cluster_gates and len(gates_plot) > 0:
         gates_cluster = _make_cluster_gates(gates_plot)

From 09a323382aae8fbc813beb56fa12fc6b7609bf4d Mon Sep 17 00:00:00 2001
From: Matteo Robbiati <62071516+MatteoRobbiati@users.noreply.github.com>
Date: Wed, 11 Sep 2024 12:14:01 +0200
Subject: [PATCH 34/40] Apply suggestions from code review

Co-authored-by: Renato Mello <renato.msf@gmail.com>
---
 src/qibo/ui/mpldrawer.py | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py
index de8df49900..21e17218b5 100644
--- a/src/qibo/ui/mpldrawer.py
+++ b/src/qibo/ui/mpldrawer.py
@@ -599,10 +599,8 @@ def _process_gates(array_gates, nqubits):
                     item += ("q_" + str(qbit),)
 
             for qbit in gate._control_qubits:
-                if type(qbit) is tuple:
-                    item += ("q_" + str(qbit[0]),)
-                else:
-                    item += ("q_" + str(qbit),)
+                item_add = ("q_" + str(qbit[0]),) if isinstance(qbit, tuple) else  ("q_" + str(qbit),)
+                item += item_add
 
             gates_plot.append(item)
 

From bf626f5540073ce29aad3efb36a194653127e629 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Wed, 11 Sep 2024 10:15:18 +0000
Subject: [PATCH 35/40] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/qibo/ui/mpldrawer.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py
index 21e17218b5..439541d38d 100644
--- a/src/qibo/ui/mpldrawer.py
+++ b/src/qibo/ui/mpldrawer.py
@@ -599,7 +599,11 @@ def _process_gates(array_gates, nqubits):
                     item += ("q_" + str(qbit),)
 
             for qbit in gate._control_qubits:
-                item_add = ("q_" + str(qbit[0]),) if isinstance(qbit, tuple) else  ("q_" + str(qbit),)
+                item_add = (
+                    ("q_" + str(qbit[0]),)
+                    if isinstance(qbit, tuple)
+                    else ("q_" + str(qbit),)
+                )
                 item += item_add
 
             gates_plot.append(item)

From c1d5e09ffc7f168bfb51d30c9f974f75d59a2baa Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Wed, 11 Sep 2024 16:26:08 +0400
Subject: [PATCH 36/40] improve docstring

---
 src/qibo/quantum_info/basis.py | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/qibo/quantum_info/basis.py b/src/qibo/quantum_info/basis.py
index cc22f268c6..e3bf042a60 100644
--- a/src/qibo/quantum_info/basis.py
+++ b/src/qibo/quantum_info/basis.py
@@ -153,6 +153,7 @@ def comp_basis_to_pauli(
     where :math:`|P_{k})` is the vectorization of the :math:`k`-th
     Pauli operator :math:`P_{k}`, and :math:`|k)` is the vectorization
     of the :math:`k`-th computational basis element.
+    For a definition of vectorization, see :func:`qibo.quantum_info.vectorization`.
 
     Example:
         .. code-block:: python
@@ -233,7 +234,12 @@ def pauli_to_comp_basis(
     The unitary :math:`U` is given by
 
     .. math::
-        U = \\sum_{k = 0}^{d^{2} - 1} \\, \\ketbra{P_{k}}{b_{k}} \\, .
+        U = \\sum_{k = 0}^{d^{2} - 1} \\, |P_{k})(b_{k}| \\, ,
+
+    where :math:`|P_{k})` is the vectorization of the :math:`k`-th
+    Pauli operator :math:`P_{k}`, and :math:`|k)` is the vectorization
+    of the :math:`k`-th computational basis element.
+    For a definition of vectorization, see :func:`qibo.quantum_info.vectorization`.
 
     Args:
         nqubits (int): number of qubits.

From 4b62f5268c4f78ab850566666dfd29a2290ff2ec Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Thu, 12 Sep 2024 13:41:07 +0400
Subject: [PATCH 37/40] unifying notation

---
 src/qibo/gates/channels.py                    |  7 ++--
 .../superoperator_transformations.py          | 34 +++++++++++--------
 2 files changed, 25 insertions(+), 16 deletions(-)

diff --git a/src/qibo/gates/channels.py b/src/qibo/gates/channels.py
index bde8c50273..bdab7ee552 100644
--- a/src/qibo/gates/channels.py
+++ b/src/qibo/gates/channels.py
@@ -48,8 +48,11 @@ def to_choi(self, nqubits: Optional[int] = None, order: str = "row", backend=Non
         of the Kraus channel :math:`\\{K_{\\alpha}\\}_{\\alpha}`.
 
         .. math::
-            \\mathcal{E} = \\sum_{\\alpha} \\, |K_{\\alpha}\\rangle\\rangle
-                \\langle\\langle K_{\\alpha}|
+            \\mathcal{E} = \\sum_{\\alpha} \\, |K_{\\alpha})(K_{\\alpha}| \\, ,
+
+        where :math:`|K_{\\alpha})` is the vectorization of the Kraus operator 
+        :math:`K_{\\alpha}`.
+        For a definition of vectorization, see :func:`qibo.quantum_info.vectorization`.
 
         Args:
             nqubits (int, optional): total number of qubits to be considered
diff --git a/src/qibo/quantum_info/superoperator_transformations.py b/src/qibo/quantum_info/superoperator_transformations.py
index 73bce85f97..7fbe0a36cc 100644
--- a/src/qibo/quantum_info/superoperator_transformations.py
+++ b/src/qibo/quantum_info/superoperator_transformations.py
@@ -14,18 +14,17 @@
 
 
 def vectorization(state, order: str = "row", backend=None):
-    """Returns state :math:`\\rho` in its Liouville
-    representation :math:`|\\rho\\rangle\\rangle`.
+    """Returns state :math:`\\rho` in its Liouville representation :math:`|\\rho)`.
 
     If ``order="row"``, then:
 
     .. math::
-        |\\rho\\rangle\\rangle = \\sum_{k, l} \\, \\rho_{kl} \\, \\ket{k} \\otimes \\ket{l}
+        |\\rho) = \\sum_{k, l} \\, \\rho_{kl} \\, \\ket{k} \\otimes \\ket{l}
 
     If ``order="column"``, then:
 
     .. math::
-        |\\rho\\rangle\\rangle = \\sum_{k, l} \\, \\rho_{kl} \\, \\ket{l} \\otimes \\ket{k}
+        |\\rho) = \\sum_{k, l} \\, \\rho_{kl} \\, \\ket{l} \\otimes \\ket{k}
 
     Args:
         state: state vector or density matrix.
@@ -88,12 +87,12 @@ def vectorization(state, order: str = "row", backend=None):
 
 def unvectorization(state, order: str = "row", backend=None):
     """Returns state :math:`\\rho` from its Liouville
-    representation :math:`|\\rho\\rangle\\rangle`. This operation is
+    representation :math:`|\\rho)`. This operation is
     the inverse function of :func:`vectorization`, i.e.
 
     .. math::
         \\begin{align}
-            \\rho &= \\text{unvectorization}(|\\rho\\rangle\\rangle) \\nonumber \\\\
+            \\rho &= \\text{unvectorization}(|\\rho)) \\nonumber \\\\
             &= \\text{unvectorization}(\\text{vectorization}(\\rho)) \\nonumber
         \\end{align}
 
@@ -152,9 +151,9 @@ def to_choi(channel, order: str = "row", backend=None):
     """Converts quantum ``channel`` :math:`U` to its Choi representation :math:`\\Lambda`.
 
     .. math::
-        \\Lambda = | U \\rangle\\rangle \\langle\\langle U | \\, ,
+        \\Lambda = | U ) ( U | \\, ,
 
-    where :math:`| \\cdot \\rangle\\rangle` is the :func:`qibo.quantum_info.vectorization`
+    where :math:`| \\cdot )` is the :func:`qibo.quantum_info.vectorization`
     operation.
 
     Args:
@@ -376,7 +375,9 @@ def choi_to_kraus(
 
     .. math::
         \\Lambda = \\sum_{\\alpha} \\, \\lambda_{\\alpha}^{2} \\,
-            |\\tilde{K}_{\\alpha}\\rangle\\rangle \\langle\\langle \\tilde{K}_{\\alpha}| \\, .
+            |\\tilde{K}_{\\alpha})(\\tilde{K}_{\\alpha}| \\, .
+
+    where :math:`|\\cdot)` is the :func:`qibo.quantum_info.vectorization` operation.
 
     This is the spectral decomposition of :math:`\\Lambda`, Hence, the set
     :math:`\\{\\lambda_{\\alpha}, \\, \\tilde{K}_{\\alpha}\\}_{\\alpha}`
@@ -385,7 +386,7 @@ def choi_to_kraus(
 
     .. math::
         K_{\\alpha} = \\lambda_{\\alpha} \\,
-            \\text{unvectorization}(|\\tilde{K}_{\\alpha}\\rangle\\rangle) \\, .
+            \\text{unvectorization}(|\\tilde{K}_{\\alpha})) \\, .
 
     If :math:`\\mathcal{E}` is not CP, then spectral composition is replaced by
     a singular value decomposition (SVD), i.e.
@@ -638,7 +639,11 @@ def kraus_to_choi(kraus_ops, order: str = "row", backend=None):
     of quantum channel to its Choi representation :math:`\\Lambda`.
 
     .. math::
-        \\Lambda = \\sum_{\\alpha} \\, |K_{\\alpha}\\rangle\\rangle \\langle\\langle K_{\\alpha}|
+        \\Lambda = \\sum_{\\alpha} \\, |K_{\\alpha})( K_{\\alpha}|
+
+    where :math:`|K_{\\alpha})` is the vectorization of the Kraus operator 
+    :math:`K_{\\alpha}`.
+    For a definition of vectorization, see :func:`qibo.quantum_info.vectorization`.
 
     Args:
         kraus_ops (list): List of Kraus operators as pairs ``(qubits, Ak)``
@@ -757,10 +762,11 @@ def kraus_to_chi(
     of quantum channel to  its :math:`\\chi`-matrix representation.
 
     .. math::
-        \\chi = \\sum_{\\alpha} \\, |c_{\\alpha}\\rangle\\rangle \\langle\\langle c_{\\alpha}|,
+        \\chi = \\sum_{\\alpha} \\, |c_{\\alpha})( c_{\\alpha}|,
 
-    where :math:`|c_{\\alpha}\\rangle\\rangle \\cong |K_{\\alpha}\\rangle\\rangle`
-    in Pauli-Liouville basis.
+    where :math:`|c_{\\alpha}) \\cong |K_{\\alpha})` in Pauli-Liouville basis,
+    and :math:`| \\cdot )` is the :func:`qibo.quantum_info.vectorization`
+    operation.
 
     Args:
         kraus_ops (list): List of Kraus operators as pairs ``(qubits, Ak)``

From 5a7fe1e50cee1d2e8453e79ee0b1ceff032e1292 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Thu, 12 Sep 2024 09:41:34 +0000
Subject: [PATCH 38/40] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/qibo/gates/channels.py                             | 2 +-
 src/qibo/quantum_info/superoperator_transformations.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/qibo/gates/channels.py b/src/qibo/gates/channels.py
index bdab7ee552..be43678318 100644
--- a/src/qibo/gates/channels.py
+++ b/src/qibo/gates/channels.py
@@ -50,7 +50,7 @@ def to_choi(self, nqubits: Optional[int] = None, order: str = "row", backend=Non
         .. math::
             \\mathcal{E} = \\sum_{\\alpha} \\, |K_{\\alpha})(K_{\\alpha}| \\, ,
 
-        where :math:`|K_{\\alpha})` is the vectorization of the Kraus operator 
+        where :math:`|K_{\\alpha})` is the vectorization of the Kraus operator
         :math:`K_{\\alpha}`.
         For a definition of vectorization, see :func:`qibo.quantum_info.vectorization`.
 
diff --git a/src/qibo/quantum_info/superoperator_transformations.py b/src/qibo/quantum_info/superoperator_transformations.py
index 7fbe0a36cc..dbdb136ad1 100644
--- a/src/qibo/quantum_info/superoperator_transformations.py
+++ b/src/qibo/quantum_info/superoperator_transformations.py
@@ -641,7 +641,7 @@ def kraus_to_choi(kraus_ops, order: str = "row", backend=None):
     .. math::
         \\Lambda = \\sum_{\\alpha} \\, |K_{\\alpha})( K_{\\alpha}|
 
-    where :math:`|K_{\\alpha})` is the vectorization of the Kraus operator 
+    where :math:`|K_{\\alpha})` is the vectorization of the Kraus operator
     :math:`K_{\\alpha}`.
     For a definition of vectorization, see :func:`qibo.quantum_info.vectorization`.
 

From c6452378729fb66cb65cbbd7c092d6a046161368 Mon Sep 17 00:00:00 2001
From: Stavros Efthymiou <35475381+stavros11@users.noreply.github.com>
Date: Mon, 9 Sep 2024 17:08:19 +0400
Subject: [PATCH 39/40] fix: add measurement and nshots in Shor example
 (outdated from #1039)

---
 examples/shor/functions.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/examples/shor/functions.py b/examples/shor/functions.py
index f4b2b36646..f36f2b507a 100644
--- a/examples/shor/functions.py
+++ b/examples/shor/functions.py
@@ -393,8 +393,9 @@ def quantum_order_finding_semiclassical(N, a):
         circuit.add(gates.U1(q_reg, -angle))
         circuit.add(gates.H(q_reg))
         results.append(circuit.add(gates.M(q_reg, collapse=True)))
+    circuit.add(gates.M(q_reg))
 
-    circuit()  # execute
+    circuit(nshots=1)  # execute
     s = sum(int(r.symbols[0].outcome()) * (2**i) for i, r in enumerate(results))
     print(f"The quantum circuit measures s = {s}.\n")
     return s

From 02e22f99d4710fe3638a7a6941db96a82e91466e Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Fri, 13 Sep 2024 15:34:11 +0400
Subject: [PATCH 40/40] fix bug

---
 src/qibo/quantum_info/superoperator_transformations.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/qibo/quantum_info/superoperator_transformations.py b/src/qibo/quantum_info/superoperator_transformations.py
index dbdb136ad1..158dd73ac4 100644
--- a/src/qibo/quantum_info/superoperator_transformations.py
+++ b/src/qibo/quantum_info/superoperator_transformations.py
@@ -2136,8 +2136,6 @@ def _reshuffling(super_op, order: str = "row", backend=None):
     Returns:
         ndarray: Choi (Liouville) representation of the quantum channel.
     """
-    super_op = backend.cast(super_op)
-
     if not isinstance(order, str):
         raise_error(TypeError, f"order must be type str, but it is type {type(order)}.")
 
@@ -2156,6 +2154,8 @@ def _reshuffling(super_op, order: str = "row", backend=None):
 
     backend = _check_backend(backend)
 
+    super_op = backend.cast(super_op, dtype=super_op.dtype)
+
     dim = np.sqrt(super_op.shape[0])
 
     if (