Fix default options for GraphMapper

Author: Takishima

projectq/cengines/_gate_manager.py

@@ -28,6 +28,20 @@
 # ==============================================================================
 
 
+class defaults(object):
+    """
+    Class containing default values for some options
+    """
+
+    delta = 0.001
+    max_lifetime = 5
+    near_term_layer_depth = 1
+    W = 0.5
+
+
+# ==============================================================================
+
+
 def _topological_sort(dag):
     """
     Returns a generator of nodes in topologically sorted order.
@@ -154,7 +168,7 @@ def nearest_neighbours_cost_fun(gates_dag, mapping, distance_matrix, swap,
     Returns:
         Score of current swap operations
     """
-    #pylint: disable=unused-argument
+    # pylint: disable=unused-argument
     return _sum_distance_over_gates(gates_dag.front_layer_2qubit, mapping,
                                     distance_matrix)
 
@@ -212,7 +226,7 @@ def look_ahead_parallelism_cost_fun(gates_dag, mapping, distance_matrix, swap,
               - Weighting factor (see cost function formula)
     """
     decay = opts['decay']
-    near_term_weight = opts['W']
+    near_term_weight = opts.get('W', defaults.W)
 
     n_front = len(gates_dag.front_layer_2qubit)
     n_near = len(gates_dag.near_term_layer)
@@ -668,8 +682,9 @@ def __init__(self, graph, decay_opts=None):
         if decay_opts is None:
             decay_opts = {}
         self.dag = CommandDAG()
-        self._decay = DecayManager(decay_opts.get('delta', 0.001),
-                                   decay_opts.get('max_lifetime', 5))
+        self._decay = DecayManager(
+            decay_opts.get('delta', defaults.delta),
+            decay_opts.get('max_lifetime', defaults.max_lifetime))
         self._stats = {
             'simul_exec': [],
             '2qubit_gates_loc': {},
@@ -754,7 +769,9 @@ def generate_swaps(self,
         self._decay.clear()
         opts['decay'] = self._decay
 
-        self.dag.calculate_near_term_layer(current_mapping)
+        self.dag.calculate_near_term_layer(
+            current_mapping,
+            opts.get('near_term_layer_depth', defaults.near_term_layer_depth))
 
         mapping = current_mapping.copy()
         swaps = []
@@ -836,7 +853,8 @@ def _add_to_execute_list(node):
                         has_command_to_execute = True
                         self._stats['simul_exec'][-1] += 1
                         _add_to_execute_list(node)
-                elif node.logical_id0 in mapping and node.logical_id1 in mapping:
+                elif (node.logical_id0 in mapping
+                      and node.logical_id1 in mapping):
                     if self.graph.has_edge(mapping[node.logical_id0],
                                            mapping[node.logical_id1]):
                         has_command_to_execute = True
@@ -938,7 +956,8 @@ def _generate_one_swap_step(self, mapping, cost_fun, opts):
 
         # Rank swap candidates using the provided cost function
         scores = []
-        for logical_id0, backend_id0, logical_id1, backend_id1 in swap_candidates:
+        for (logical_id0, backend_id0, logical_id1,
+             backend_id1) in swap_candidates:
             new_mapping = mapping.copy()
 
             _apply_swap_to_mapping(new_mapping, logical_id0, logical_id1,

projectq/cengines/_gate_manager_test.py

@@ -511,10 +511,17 @@ def test_command_dag_near_term_layer(command_dag):
     command_dag.add_command(cmd14)
     dag_node12 = search_cmd(command_dag, cmd12)
     dag_node34 = search_cmd(command_dag, cmd34)
+    dag_node23b = search_cmd(command_dag, cmd23b)
+    dag_node46 = search_cmd(command_dag, cmd46)
 
-    command_dag.calculate_near_term_layer({i: i for i in range(7)})
+    command_dag.calculate_near_term_layer({i: i for i in range(7)}, depth=1)
     assert command_dag.near_term_layer == [dag_node12, dag_node34]
 
+    command_dag.calculate_near_term_layer({i: i for i in range(7)}, depth=2)
+    assert command_dag.near_term_layer == [
+        dag_node12, dag_node34, dag_node23b, dag_node46
+    ]
+
 
 def test_command_dag_calculate_interaction_list(command_dag):
     cmd01 = gen_cmd(0, 1)

projectq/cengines/_graphmapper.py

@@ -15,11 +15,12 @@
 Mapper for a quantum circuit to an arbitrary connected graph.
 
 Input: Quantum circuit with 1 and 2 qubit gates on n qubits. Gates are assumed
-       to be applied in parallel if they act on disjoint qubit(s) and any pair
-       of qubits can perform a 2 qubit gate (all-to-all connectivity)
+to be applied in parallel if they act on disjoint qubit(s) and any pair of
+qubits can perform a 2 qubit gate (all-to-all connectivity)
+
 Output: Quantum circuit in which qubits are placed in 2-D square grid in which
-        only nearest neighbour qubits can perform a 2 qubit gate. The mapper
-        uses Swap gates in order to move qubits next to each other.
+only nearest neighbour qubits can perform a 2 qubit gate. The mapper uses Swap
+gates in order to move qubits next to each other.
 """
 from copy import deepcopy
 
@@ -39,12 +40,12 @@
 if sys.version_info[0] >= 3 and sys.version_info[1] > 6:  # pragma: no cover
 
     def uniquify_list(seq):
-        #pylint: disable=missing-function-docstring
+        # pylint: disable=missing-function-docstring
         return list(dict.fromkeys(seq))
 else:  # pragma: no cover
 
     def uniquify_list(seq):
-        #pylint: disable=missing-function-docstring
+        # pylint: disable=missing-function-docstring
         seen = set()
         seen_add = seen.add
         return [x for x in seq if x not in seen and not seen_add(x)]
@@ -53,6 +54,18 @@ def uniquify_list(seq):
 # ==============================================================================
 
 
+class defaults(object):
+    """
+    Class containing default values for some options
+    """
+    #: Defaults to :py:func:`.look_ahead_parallelism_cost_fun`
+    cost_fun = look_ahead_parallelism_cost_fun
+    max_swap_steps = 30
+
+
+# ==============================================================================
+
+
 class GraphMapperError(Exception):
     """Base class for all exceptions related to the GraphMapper."""
 
@@ -78,7 +91,7 @@ def _add_qubits_to_mapping_fcfs(current_mapping, graph, new_logical_qubit_ids,
 
     Returns: A new mapping
     """
-    #pylint: disable=unused-argument
+    # pylint: disable=unused-argument
 
     mapping = deepcopy(current_mapping)
     currently_used_nodes = sorted([v for _, v in mapping.items()])
@@ -337,26 +350,20 @@ def __init__(self,
                * - Key
                  - Type
                  - Description
-               * - cost_fun
-                 - ``function``
-                 -  | Cost function to be called when generating a new
-                    | list of swap operations.
-                    | Defaults to :py:func:`.look_ahead_parallelism_cost_fun`
                * - decay_opts
                  - ``dict``
                  -  | Options to pass onto the :py:class:`.DecayManager`
                       constructor
-                    | Defaults to ``{'delta': 0.001, 'max_lifetime': 5}``.
-               * - opts
+                    | (see :py:class:`._gate_manager.defaults`)
+               * - swap_opts
                  - ``dict``
-                 -  | 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
+                 -  | Extra options used when generating a list of swap
+                    | operations.
+                    | Acceptable keys: W, cost_fun, near_term_layer_depth,
+                    | max_swap_steps
+                    | (see :py:meth:`.GateManager.generate_swaps`,
+                    |  :py:class:`._graphmapper.defaults` and
+                    |  :py:class:`._gate_manager.defaults`)
         """
         BasicMapperEngine.__init__(self)
 
@@ -542,12 +549,14 @@ def _run(self):
         if not self.qubit_manager.size():
             return
 
+        # NB: default values are taken care of at place of access
+        swap_opts = self._opts.get('swap_opts', {})
+
         swaps, all_swapped_qubits = self.qubit_manager.generate_swaps(
             self._current_mapping,
-            cost_fun=self._opts.get('cost_fun',
-                                    look_ahead_parallelism_cost_fun),
-            opts=self._opts.get('opts', {'W': 0.5}),
-            max_steps=self._opts.get('max_swap_steps', 30))
+            cost_fun=swap_opts.get('cost_fun', defaults.cost_fun),
+            opts=swap_opts,
+            max_steps=swap_opts.get('max_swap_steps', defaults.max_swap_steps))
 
         if swaps:
             # Get a list of the qubits we need to allocate just to perform the

projectq/cengines/_graphmapper_test.py

@@ -535,6 +535,68 @@ def test_run_and_receive(simple_graph, simple_mapper):
     assert mapper.num_mappings == 1
 
 
+@pytest.mark.parametrize("opts", [{}, {
+    'swap_opts': {
+    }
+}, {
+    'swap_opts': {
+        'W': 0.5,
+    }
+}, {
+    'swap_opts': {
+        'W': 0.5,
+        'near_term_layer_depth': 2
+    }
+}])
+def test_run_and_receive_with_opts(simple_graph, opts):
+    mapper = graphm.GraphMapper(graph=simple_graph,
+                                add_qubits_to_mapping="fcfs",
+                                opts=opts)
+    backend = DummyEngine(save_commands=True)
+    backend.is_last_engine = True
+    mapper.next_engine = backend
+
+    qb, allocate_cmds = allocate_all_qubits_cmd(mapper)
+
+    gates = [
+        Command(None, X, qubits=([qb[0]], ), controls=[qb[1]]),
+        Command(None, X, qubits=([qb[1]], ), controls=[qb[2]]),
+        Command(None, X, qubits=([qb[1]], ), controls=[qb[5]]),
+        Command(None, X, qubits=([qb[2]], ), controls=[qb[3]]),
+        Command(None, X, qubits=([qb[5]], ), controls=[qb[3]]),
+        Command(None, X, qubits=([qb[3]], ), controls=[qb[4]]),
+        Command(None, X, qubits=([qb[3]], ), controls=[qb[6]]),
+        Command(None, X, qubits=([qb[4]], ), controls=[qb[6]]),
+    ]
+    deallocate_cmds = [
+        Command(engine=None, gate=Deallocate, qubits=([qb[1]], ))
+    ]
+
+    allocated_qubits_ref = set([0, 2, 3, 4, 5, 6])
+
+    all_cmds = list(itertools.chain(allocate_cmds, gates, deallocate_cmds))
+    mapper.receive(all_cmds)
+    qb_flush = WeakQubitRef(engine=None, idx=-1)
+    cmd_flush = Command(engine=None, gate=FlushGate(), qubits=([qb_flush], ))
+    mapper.receive([cmd_flush])
+    assert mapper.qubit_manager.size() == 0
+    assert len(backend.received_commands) == len(all_cmds) + 1
+    assert mapper._currently_allocated_ids == allocated_qubits_ref
+
+    mapping = dict(enumerate(range(len(simple_graph))))
+    del mapping[1]
+    assert mapper.current_mapping == mapping
+
+    cmd9 = Command(None, X, qubits=([qb[0]], ), controls=[qb[6]])
+    mapper.receive([cmd9, cmd_flush])
+    assert mapper._currently_allocated_ids == allocated_qubits_ref
+    for idx in allocated_qubits_ref:
+        assert idx in mapper.current_mapping
+    assert mapper.qubit_manager.size() == 0
+    assert len(mapper.current_mapping) == 6
+    assert mapper.num_mappings == 1
+
+
 def test_send_two_qubit_gate_before_swap(simple_mapper):
     qb, all_cmds = allocate_all_qubits_cmd(simple_mapper[0])