Add support to CouplingMap for disjoint qubits

qiskit/transpiler/coupling.py

@@ -19,9 +19,9 @@
 onto a device with this coupling.
 """
 
+from typing import List
 import warnings
 
-import numpy as np
 import rustworkx as rx
 from rustworkx.visualization import graphviz_draw
 
@@ -37,7 +37,16 @@ class CouplingMap:
  and target qubits, respectively.
  """
 
- __slots__ = ("description", "graph", "_dist_matrix", "_qubit_list", "_size", "_is_symmetric")
+ __slots__ = (
+ "description",
+ "graph",
+ "_dist_matrix",
+ "_qubit_list",
+ "_size",
+ "_is_symmetric",
+ "_strong_components",
+ "_weak_components",
+ )
 
  def __init__(self, couplinglist=None, description=None):
  """
@@ -60,6 +69,8 @@ def __init__(self, couplinglist=None, description=None):
  # number of qubits in the graph
  self._size = None
  self._is_symmetric = None
+ self._strong_components = None
+ self._weak_components = None
 
  if couplinglist is not None:
  self.graph.extend_from_edge_list([tuple(x) for x in couplinglist])
@@ -100,6 +111,8 @@ def add_physical_qubit(self, physical_qubit):
  self._dist_matrix = None # invalidate
  self._qubit_list = None # invalidate
  self._size = None # invalidate
+ self._weak_components = None # invalidate
+ self._strong_components = None # invalidate
 
  def add_edge(self, src, dst):
  """
@@ -115,6 +128,8 @@ def add_edge(self, src, dst):
  self.graph.add_edge(src, dst, None)
  self._dist_matrix = None # invalidate
  self._is_symmetric = None # invalidate
+ self._weak_components = None # invalidate
+ self._strong_components = None # invalidate
 
  def subgraph(self, nodelist):
  """Return a CouplingMap object for a subgraph of self.
@@ -175,8 +190,6 @@ def compute_distance_matrix(self):
  those or want to pre-generate it.
  """
  if self._dist_matrix is None:
- if not self.is_connected():
- raise CouplingError("coupling graph not connected")
  self._dist_matrix = rx.digraph_distance_matrix(self.graph, as_undirected=True)
 
  def distance(self, physical_qubit1, physical_qubit2):
@@ -197,7 +210,10 @@ def distance(self, physical_qubit1, physical_qubit2):
  if physical_qubit2 >= self.size():
  raise CouplingError("%s not in coupling graph" % physical_qubit2)
  self.compute_distance_matrix()
- return int(self._dist_matrix[physical_qubit1, physical_qubit2])
+ res = int(self._dist_matrix[physical_qubit1, physical_qubit2])
+ if res == 0:
+ raise CouplingError(f"No path from {physical_qubit1} to {physical_qubit2}")
+ return res
 
  def shortest_undirected_path(self, physical_qubit1, physical_qubit2):
  """Returns the shortest undirected path between physical_qubit1 and physical_qubit2.
@@ -268,9 +284,6 @@ def reduce(self, mapping):
  Raises:
  CouplingError: Reduced coupling map must be connected.
  """
- from scipy.sparse import coo_matrix, csgraph
-
- reduced_qubits = len(mapping)
  inv_map = [None] * (max(mapping) + 1)
  for idx, val in enumerate(mapping):
  inv_map[val] = idx
@@ -281,16 +294,6 @@ def reduce(self, mapping):
  if edge[0] in mapping and edge[1] in mapping:
  reduced_cmap.append([inv_map[edge[0]], inv_map[edge[1]]])
 
- # Verify coupling_map is connected
- rows = np.array([edge[0] for edge in reduced_cmap], dtype=int)
- cols = np.array([edge[1] for edge in reduced_cmap], dtype=int)
- data = np.ones_like(rows)
-
- mat = coo_matrix((data, (rows, cols)), shape=(reduced_qubits, reduced_qubits)).tocsr()
-
- if csgraph.connected_components(mat)[0] != 1:
- raise CouplingError("coupling_map must be connected.")
-
  return CouplingMap(reduced_cmap)
 
  @classmethod
@@ -403,6 +406,53 @@ def largest_connected_component(self):
  """Return a set of qubits in the largest connected component."""
  return max(rx.weakly_connected_components(self.graph), key=len)
 
+ def components(self, respect_direction: bool = False) -> List["CouplingMap"]:
+ """Separate a CouplingMap into subgraph Coupling Maps for each connected component.
+
+ This method will return a list of :class:`~.CouplingMap` objects for each connected
+ component in this :class:`~.CouplingMap`. The data payload of each node in the
+ :attr:`~.CouplingMap.graph` attribute will contain the qubit number in the original
+ graph. This will enables mapping the qubit index in a component subgraph to
+ the original qubit in the combined :class:`~.CouplingMap`. For example::
+
+ from qiskit.transpiler import CouplingMap
+
+ cmap = CouplingMap([[0, 1], [1, 2], [2, 0], [3, 4], [4, 5], [5, 3]])
+ component_cmaps = cmap.get_component_subgraphs()
+ print(component_cmaps[1].graph[0])
+
+ will print ``3`` as index ``0`` in the second component is qubit 3 in the original cmap.
+
+ Args:
+ respect_direction: If set to ``True`` the connected components will be strongly connected
+
+ Returns:
+ list: A list of :class:`~.CouplingMap` objects for each connected
+ components.
+ """
+ if respect_direction and self._strong_components is not None:
+ return self._strong_components
+ if self._weak_components is not None:
+ return self._weak_components
+
+ # Set payload to index
+ for node in self.graph.node_indices():
+ self.graph[node] = node
+ if not respect_direction:
+ components = rx.weakly_connected_components(self.graph)
+ else:
+ components = rx.strongly_connected_components(self.graph)
+ output_list = []
+ for component in components:
+ new_cmap = CouplingMap()
+ new_cmap.graph = self.graph.subgraph(list(sorted(component)))
+ output_list.append(new_cmap)
+ if respect_direction:
+ self._strong_components = output_list
+ else:
+ self._weak_components = output_list
+ return output_list
+
  def __str__(self):
  """Return a string representation of the coupling graph."""
  string = ""

qiskit/transpiler/passes/layout/csp_layout.py

@@ -19,6 +19,7 @@
 
 from qiskit.transpiler.layout import Layout
 from qiskit.transpiler.basepasses import AnalysisPass
+from qiskit.transpiler.exceptions import TranspilerError
 from qiskit.utils import optionals as _optionals
 
 
@@ -60,6 +61,11 @@ def __init__(
 
  def run(self, dag):
  """run the layout method"""
+ if not self.coupling_map.is_connected():
+ raise TranspilerError(
+ "Coupling Map is disjoint, this pass can't be used with a disconnected coupling "
+ "map."
+ )
  qubits = dag.qubits
  cxs = set()
 

qiskit/transpiler/passes/layout/dense_layout.py

@@ -79,6 +79,11 @@ def run(self, dag):
  raise TranspilerError(
  "A coupling_map or target with constrained qargs is necessary to run the pass."
  )
+ if dag.num_qubits() > self.coupling_map.largest_connected_component():
+ raise TranspilerError(
+ "Coupling Map is disjoint, this pass can't be used with a disconnected coupling "
+ "map for a circuit this wide."
+ )
  num_dag_qubits = len(dag.qubits)
  if num_dag_qubits > self.coupling_map.size():
  raise TranspilerError("Number of qubits greater than device.")

qiskit/transpiler/passes/layout/sabre_layout.py

@@ -166,7 +166,11 @@ def run(self, dag):
  """
  if len(dag.qubits) > self.coupling_map.size():
  raise TranspilerError("More virtual qubits exist than physical.")
-
+ if not self.coupling_map.is_connected():
+ raise TranspilerError(
+ "Coupling Map is disjoint, this pass can't be used with a disconnected coupling "
+ "map."
+ )
  # Choose a random initial_layout.
  if self.routing_pass is not None:
  if self.seed is None:

qiskit/transpiler/passes/layout/trivial_layout.py

@@ -50,6 +50,11 @@ def run(self, dag):
  Raises:
  TranspilerError: if dag wider than self.coupling_map
  """
+ if not self.coupling_map.is_connected():
+ raise TranspilerError(
+ "Coupling Map is disjoint, this pass can't be used with a disconnected coupling "
+ "map."
+ )
  if dag.num_qubits() > self.coupling_map.size():
  raise TranspilerError("Number of qubits greater than device.")
  self.property_set["layout"] = Layout.generate_trivial_layout(

releasenotes/notes/add-cmap-componets-7ed56cdf294150f1.yaml

@@ -0,0 +1,13 @@
+---
+features:
+ - |
+ Added support to the :class:`~.CouplingMap` object to have a disjoint
+ connectivity. Previously, a :class:`~.CouplingMap` could only be
+ constructed if the graph was connected. This will enable using
+ :class:`~.CouplingMap` to represent hardware with disjoint qubits.
+ - |
+ Added a new method :meth:`.CouplingMap.components` which
+ is used to get a list of :class:`~.CouplingMap` component subgraphs for
+ a disjoint :class:`~.CouplingMap`. If the :class:`~.CouplingMap` object
+ is connected this will just return a single :class:`~.CouplingMap`
+ equivalent to the original.

test/python/transpiler/test_coupling.py

@@ -14,6 +14,9 @@
 
 import unittest
 
+import numpy as np
+import rustworkx as rx
+
 from qiskit.transpiler import CouplingMap
 from qiskit.transpiler.exceptions import CouplingError
 from qiskit.providers.fake_provider import FakeRueschlikon
@@ -101,14 +104,6 @@ def test_successful_reduced_map(self):
  ans = [(1, 2), (3, 2), (0, 1)]
  self.assertEqual(set(out), set(ans))
 
- def test_failed_reduced_map(self):
- """Generate a bad disconnected reduced map"""
- fake = FakeRueschlikon()
- cmap = fake.configuration().coupling_map
- coupling_map = CouplingMap(cmap)
- with self.assertRaises(CouplingError):
- coupling_map.reduce([12, 11, 10, 3])
-
  def test_symmetric_small_true(self):
  coupling_list = [[0, 1], [1, 0]]
  coupling = CouplingMap(coupling_list)
@@ -448,6 +443,58 @@ def test_implements_iter(self):
  expected = [(0, 1), (1, 0), (1, 2), (2, 1)]
  self.assertEqual(sorted(coupling), expected)
 
+ def test_disjoint_coupling_map(self):
+ cmap = CouplingMap([[0, 1], [1, 0], [2, 3], [3, 2]])
+ self.assertFalse(cmap.is_connected())
+ distance_matrix = cmap.distance_matrix
+ expected = np.array(
+ [
+ [0, 1, 0, 0],
+ [1, 0, 0, 0],
+ [0, 0, 0, 1],
+ [0, 0, 1, 0],
+ ]
+ )
+ np.testing.assert_array_equal(expected, distance_matrix)
+
+ def test_components_connected_graph(self):
+ cmap = CouplingMap.from_line(5)
+ self.assertTrue(cmap.is_connected())
+ subgraphs = cmap.components()
+ self.assertEqual(len(subgraphs), 1)
+ self.assertTrue(rx.is_isomorphic(cmap.graph, subgraphs[0].graph))
+
+ def test_components_disconnected_graph(self):
+ cmap = CouplingMap([[0, 1], [1, 2], [3, 4], [4, 5]])
+ self.assertFalse(cmap.is_connected())
+ subgraphs = cmap.components()
+ self.assertEqual(len(subgraphs), 2)
+ expected_subgraph = CouplingMap([[0, 1], [1, 2]])
+ self.assertTrue(rx.is_isomorphic(expected_subgraph.graph, subgraphs[0].graph))
+ self.assertTrue(rx.is_isomorphic(expected_subgraph.graph, subgraphs[1].graph))
+
+ def test_strongly_connected_components_disconnected_graph(self):
+ cmap = CouplingMap([[0, 1], [1, 2], [3, 4], [4, 5]])
+ self.assertFalse(cmap.is_connected())
+ subgraphs = cmap.components(True)
+ self.assertEqual(len(subgraphs), 6)
+ expected_subgraph = CouplingMap()
+ expected_subgraph.add_physical_qubit(0)
+ for i in range(6):
+ self.assertTrue(rx.is_isomorphic(expected_subgraph.graph, subgraphs[i].graph))
+
+ def test_components_disconnected_graph_cached(self):
+ cmap = CouplingMap([[0, 1], [1, 2], [3, 4], [4, 5]])
+ self.assertFalse(cmap.is_connected())
+ subgraphs = cmap.components()
+ self.assertEqual(subgraphs, cmap.components())
+
+ def test_strongly_connected_components_disconnected_graph_cached(self):
+ cmap = CouplingMap([[0, 1], [1, 2], [3, 4], [4, 5]])
+ self.assertFalse(cmap.is_connected())
+ subgraphs = cmap.components(True)
+ self.assertEqual(subgraphs, cmap.components(True))
+
 
 class CouplingVisualizationTest(QiskitVisualizationTestCase):
  @unittest.skipUnless(optionals.HAS_GRAPHVIZ, "Graphviz not installed")