Updated get_subgraphs_of_size to use a Redelmeier/ESU hybrid

Author: jclark-ce

bqskit/qis/graph.py

@@ -429,7 +429,11 @@ def get_subgraph(
                 subgraph.append((renumbering[q_i], renumbering[q_i_neighbor]))
         return CouplingGraph(subgraph, len(location))
 
-    def get_subgraphs_of_size(self, size: int) -> list[CircuitLocation]:
+    def get_subgraphs_of_size(
+        self,
+        size: int,
+        include_smaller: bool = False,
+    ) -> list[CircuitLocation]:
         """
         Find all sets of indices that form connected subgraphs on their own.
 
@@ -441,6 +445,9 @@ def get_subgraphs_of_size(self, size: int) -> list[CircuitLocation]:
         Args:
             size (int): The size of each location in the final list.
 
+            include_smaller (bool): Includes subgraphs with size less
+                than `size`. (Default: False)
+
         Returns:
             list[CircuitLocation]: The locations compliant with the machine.
 
@@ -466,67 +473,77 @@ def get_subgraphs_of_size(self, size: int) -> list[CircuitLocation]:
         if size <= 0:
             raise ValueError(f'Nonpositive size; got {size}.')
 
-        locations: set[frozenset[int]] = set()
+        subgraphs: list[tuple[int, ...]] = list()
 
         for qudit in range(self.num_qudits):
-            # Get every valid set containing `qudit` with size <= size
-            self._location_search(locations, set(), qudit, size)
+            subgraph = [qudit]
+            extension = {q for q in self._adj[qudit] if q > qudit}
+            exclusion = {qudit}
+            self._extend_subgraph(
+                size, subgraph, extension,
+                exclusion, qudit, subgraphs, include_smaller,
+            )
 
-        # filter groups with size < size and convert remaining
-        # groups to CircuitLocation
         locations: list[CircuitLocation] = [
-            CircuitLocation(
-                list(group),
-            ) for group in locations if len(group) == size
+            CircuitLocation(list(group)) for group in subgraphs
         ]
 
         return locations
 
-    def _location_search(
+    def _extend_subgraph(
         self,
-        locations: set[frozenset[int]],
-        path: set[int],
+        size: int,
+        subgraph: list[int],
+        extension: set[int],
+        exclusion: set[int],
         vertex: int,
-        limit: int,
+        subgraphs: list[tuple[int, ...]],
+        include_smaller: bool,
     ) -> None:
         """
-        Add paths with length equal to limit to the `locations` set.
+        Add subgraphs with size equal to `size` to the `subgraphs` list.
 
         Args:
-            locations (set[frozenset[int]]): A list that contains all paths
-                found so far of length equal to `limit`.
+            size (int): The desired size of subgraphs in the
+                `subgraphs` set.
 
-            path (set[int]): The qudit vertices currently included in
-                the path.
+            subgraph (list[int]): The qudit vertices currently included
+                in the subgraph.
 
-            vertex (int): The vertex in the graph currently being examined.
+            extension (set[int]): The qudit vertices currently being
+                considered for addition to the subgraph.
 
-            limit (int): The desired length of paths in the `locations`
-                list.
-        """
-        if vertex in path:
-            return
+            exclusion (set[int]): The qudit vertices which have already
+                been searched.
 
-        curr_path = path.copy()
-        curr_path.add(vertex)
+            vertex (int): The vertex in the graph currently being examined.
 
-        if frozenset(curr_path) in locations:
-            return
+            subgraphs (list[tuple[int,...]]): A list that contains all subgraphs
+                found so far of length equal to `size`.
 
-        if len(curr_path) <= limit:
-            locations.add(frozenset(curr_path))
-            if len(curr_path) == limit:
+            include_smaller (bool): Includes subgraphs with size less
+                than `size`.
+        """
+        if len(subgraph) == size or (include_smaller and len(subgraph) < size):
+            subgraphs.append(tuple(subgraph))
+            if len(subgraph) == size:
                 return
 
-        frontier: set[int] = {
-            qudit
-            for node in curr_path
-            for qudit in self._adj[node]
-            if qudit not in curr_path
-        }
-
-        for neighbor in frontier:
-            self._location_search(locations, curr_path, neighbor, limit)
+        while len(extension) > 0:
+            w = extension.pop()
+            exclusion.add(w)
+            new_extension = set(extension)
+            for neighbor in self._adj[w]:
+                if neighbor > vertex and neighbor not in exclusion:
+                    new_extension.add(neighbor)
+
+            subgraph.append(w)
+            self._extend_subgraph(
+                size, subgraph, new_extension, set(
+                    exclusion,
+                ), vertex, subgraphs, include_smaller,
+            )
+            subgraph.pop()
 
     @staticmethod
     def is_valid_coupling_graph(