Fix some more bugs and linting issues and increase test coverage

Author: Takishima

projectq/cengines/_graphmapper.py

@@ -149,15 +149,15 @@ def _add_qubits_to_mapping_smart_init(current_mapping, graph,
 
     Returns: A new mapping
     """
-    qubit_interaction_subgraphs = \
-        commands_dag.calculate_qubit_interaction_subgraphs(max_order=2)
+    if not current_mapping:
+        qubit_interaction_subgraphs = \
+            commands_dag.calculate_qubit_interaction_subgraphs(max_order=2)
 
-    # Interaction subgraph list can be empty if only single qubit gates are
-    # present
-    if not qubit_interaction_subgraphs:
-        qubit_interaction_subgraphs = [list(new_logical_qubit_ids)]
+        # Interaction subgraph list can be empty if only single qubit gates are
+        # present
+        if not qubit_interaction_subgraphs:
+            qubit_interaction_subgraphs = [list(new_logical_qubit_ids)]
 
-    if not current_mapping:
         return _generate_mapping_minimize_swaps(graph,
                                                 qubit_interaction_subgraphs)
     return _add_qubits_to_mapping_fcfs(current_mapping, graph,
@@ -185,15 +185,15 @@ def _add_qubits_to_mapping(current_mapping, graph, new_logical_qubit_ids,
 
     Returns: A new mapping
     """
-    qubit_interaction_subgraphs = \
-        commands_dag.calculate_qubit_interaction_subgraphs(max_order=2)
+    if not current_mapping:
+        qubit_interaction_subgraphs = \
+            commands_dag.calculate_qubit_interaction_subgraphs(max_order=2)
 
-    # Interaction subgraph list can be empty if only single qubit gates are
-    # present
-    if not qubit_interaction_subgraphs:
-        qubit_interaction_subgraphs = [list(new_logical_qubit_ids)]
+        # Interaction subgraph list can be empty if only single qubit gates are
+        # present
+        if not qubit_interaction_subgraphs:
+            qubit_interaction_subgraphs = [list(new_logical_qubit_ids)]
 
-    if not current_mapping:
         return _generate_mapping_minimize_swaps(graph,
                                                 qubit_interaction_subgraphs)
 
@@ -213,17 +213,24 @@ def _add_qubits_to_mapping(current_mapping, graph, new_logical_qubit_ids,
         backend_id = None
 
         if len(qubit_interactions) == 1:
+            # If there's only a single qubit interacting and it is already
+            # present within the mapping, find the neighbour with the highest
+            # degree
+
             qubit = qubit_interactions[0]
 
             if qubit in mapping:
-                candidates = sorted([
-                    n for n in graph[mapping[qubit]]
-                    if n not in currently_used_nodes
-                ],
-                                    key=lambda n: len(graph[n]))
+                candidates = sorted(
+                    [n for n in graph[mapping[qubit]] if n in available_nodes],
+                    key=lambda n: len(graph[n]))
                 if candidates:
                     backend_id = candidates[-1]
         elif qubit_interactions:
+            # If there are multiple qubits interacting, find out all the
+            # neighbouring nodes for each interaction. Then within those
+            # nodes, try to find the one that maximizes the number of
+            # interactions without swapping
+
             neighbours = []
             for qubit in qubit_interactions:
                 if qubit in mapping:
@@ -233,14 +240,18 @@ def _add_qubits_to_mapping(current_mapping, graph, new_logical_qubit_ids,
                 else:
                     break
 
+            # Try to find an intersection that maximizes the number of
+            # interactions by iteratively reducing the number of considered
+            # interactions
+
             intersection = set()
-            while neighbours:
+            while neighbours and not intersection:
                 intersection = neighbours[0].intersection(*neighbours[1:])
-                if intersection:
-                    backend_id = intersection.pop()
-                    break
                 neighbours.pop()
 
+            if intersection:
+                backend_id = intersection.pop()
+
         if backend_id is None:
             backend_id = available_nodes.pop()
         else:
@@ -342,6 +353,11 @@ def __init__(self,
                  -  | Extra options to pass onto the cost function
                     | (see :py:meth:`.MultiQubitGateManager.generate_swaps`)
                     | Defaults to ``{'W': 0.5}``.
+               * - max_swap_steps
+                 - ``int``
+                 -  | Maximum number of swap steps per mapping
+                    | (see :py:meth:`.MultiQubitGateManager.generate_swaps`)
+                    | Defaults to 30
         """
         BasicMapperEngine.__init__(self)
 
@@ -483,7 +499,7 @@ def _send_possible_commands(self):
         if allocate_cmds and num_available_qubits > 0:
 
             def rank_allocate_cmds(cmds_list, dag):
-                #pylint: disable=unused-argument
+                # pylint: disable=unused-argument
                 return cmds_list
 
             allocate_cmds = rank_allocate_cmds(
@@ -663,7 +679,7 @@ def __str__(self):
 
         Returns:
             A summary (string) of resources used, including depth of swaps and
-            statistics about the paths generated
+            statistics about the swaps themselves
         """
 
         depth_of_swaps_str = ""

projectq/cengines/_graphmapper_test.py

@@ -182,19 +182,18 @@ def test_invalid_gates(simple_mapper):
         mapper.receive([cmd0, cmd1, cmd2, cmd3, cmd_flush])
 
 
-# def test_run_infinite_loop_detection(simple_mapper):
-#     mapper, backend = simple_mapper
-#     mapper.current_mapping = {i: i for i in range(7)}
+def test_init(simple_graph):
+    opts = {'decay_opts': {'delta': 0.002}}
 
-#     qb0 = WeakQubitRef(engine=None, idx=0)
-#     qb1 = WeakQubitRef(engine=None, idx=6)
+    mapper = graphm.GraphMapper(graph=simple_graph, opts=opts)
+    assert mapper.qubit_manager._decay._delta == 0.002
+    assert mapper.qubit_manager._decay._cutoff == 5
 
-#     qb_flush = WeakQubitRef(engine=None, idx=-1)
-#     cmd_flush = Command(engine=None, gate=FlushGate(), qubits=([qb_flush], ))
+    opts = {'decay_opts': {'delta': 0.002, 'max_lifetime': 10}}
 
-#     cmd0 = Command(engine=None, gate=X, qubits=([qb0], ), controls=[qb1])
-#     with pytest.raises(RuntimeError):
-#         mapper.receive([cmd0, cmd_flush])
+    mapper = graphm.GraphMapper(graph=simple_graph, opts=opts)
+    assert mapper.qubit_manager._decay._delta == 0.002
+    assert mapper.qubit_manager._decay._cutoff == 10
 
 
 def test_resetting_mapping_to_none(simple_graph):
@@ -215,6 +214,27 @@ def test_add_qubits_to_mapping_methods_failure(simple_graph):
         graphm.GraphMapper(graph=simple_graph, add_qubits_to_mapping="as")
 
 
+@pytest.mark.parametrize("add_qubits", ["fcfs", "fcfs_init", "FCFS"])
+def test_add_qubits_to_mapping_methods_only_single(simple_graph, add_qubits):
+    mapper = graphm.GraphMapper(graph=simple_graph,
+                                add_qubits_to_mapping=add_qubits)
+    backend = DummyEngine(save_commands=True)
+    backend.is_last_engine = True
+    mapper.next_engine = backend
+
+    qb, allocate_cmds = allocate_all_qubits_cmd(mapper)
+
+    qb_flush = WeakQubitRef(engine=None, idx=-1)
+    cmd_flush = Command(engine=None, gate=FlushGate(), qubits=([qb_flush], ))
+    gates = [
+        Command(None, X, qubits=([qb[1]], )),
+        Command(None, X, qubits=([qb[2]], )),
+    ]
+
+    mapper.receive(list(itertools.chain(allocate_cmds, gates, [cmd_flush])))
+    assert mapper.num_mappings == 0
+
+
 @pytest.mark.parametrize("add_qubits", ["fcfs", "fcfs_init", "FCFS"])
 def test_add_qubits_to_mapping_methods(simple_graph, add_qubits):
     mapper = graphm.GraphMapper(graph=simple_graph,
@@ -594,7 +614,7 @@ def test_send_two_qubit_gate_before_swap_nonallocated_qubits(simple_mapper):
         assert mapper.current_mapping[4] == 4
         assert mapper.current_mapping[5] == 5
         assert mapper.current_mapping[6] in [3, 6]
-        
+
         if mapper.current_mapping[6] == 3:
             # qb[6] is on position 3, all commands are possible
             assert mapper.qubit_manager.size() == 0