Global call graph test (#1018)

* All call graph

* Fixes

* propogate nb changes

Author: mpharrigan

dev_tools/qualtran_dev_tools/all_call_graph.py

@@ -0,0 +1,78 @@
+#  Copyright 2024 Google LLC
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""Generate the library-wide call graph from all bloq examples."""
+import warnings
+from typing import Iterable
+
+import networkx as nx
+
+from qualtran import Bloq, BloqExample, DecomposeNotImplementedError, DecomposeTypeError
+from qualtran.bloqs.basic_gates import Rx, Ry, Rz, TGate, Toffoli, XPowGate, YPowGate, ZPowGate
+from qualtran.resource_counting import SympySymbolAllocator
+from qualtran.resource_counting._call_graph import _build_call_graph
+from qualtran.resource_counting._generalization import _make_composite_generalizer
+from qualtran.resource_counting.generalizers import (
+    generalize_cvs,
+    generalize_rotation_angle,
+    ignore_alloc_free,
+    ignore_cliffords,
+    ignore_split_join,
+)
+
+
+def get_all_call_graph(bes: Iterable[BloqExample]):
+    """Create a call graph that is the union of all of the bloqs in the list of bloq examples.
+
+    This applies some standard generalizers, and will stop at a larger-than-default set
+    of leaf bloqs in accordance with https://github.com/quantumlib/Qualtran/issues/873
+    """
+    generalize = _make_composite_generalizer(
+        ignore_split_join,
+        generalize_cvs,
+        generalize_rotation_angle,
+        ignore_alloc_free,
+        ignore_cliffords,
+    )
+
+    def keep(b: Bloq) -> bool:
+        if b == Toffoli():
+            return True
+
+        if b == TGate():
+            return True
+
+        if isinstance(b, (Rx, Ry, Rz, XPowGate, YPowGate, ZPowGate)):
+            return True
+
+        try:
+            _ = b.build_call_graph(SympySymbolAllocator())
+        except DecomposeTypeError:
+            return True
+        except DecomposeNotImplementedError:
+            warnings.warn(f"{b} lacks a call graph.")
+            return True
+
+        return False
+
+    g = nx.DiGraph()
+    ssa = SympySymbolAllocator()
+
+    for be in bes:
+        bloq = be.make()
+        _build_call_graph(
+            bloq=bloq, generalizer=generalize, ssa=ssa, keep=keep, max_depth=None, g=g, depth=0
+        )
+
+    return g

dev_tools/qualtran_dev_tools/all_call_graph_test.py

@@ -0,0 +1,29 @@
+#  Copyright 2024 Google LLC
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+import networkx as nx
+import pytest
+
+from .all_call_graph import get_all_call_graph
+from .bloq_finder import get_bloq_examples
+
+
+@pytest.mark.slow
+def test_get_all_call_graph():
+    # This test generates a union of the call graphs of every bloq example in the library.
+    # This test makes sure that there aren't any bloq examples with broken call graphs.
+    bes = get_bloq_examples()
+    g = get_all_call_graph(bes)
+    res = list(nx.simple_cycles(g))
+    assert res == []

qualtran/bloqs/arithmetic/comparison.py

@@ -756,8 +756,8 @@ def on_classical_vals(
     def build_composite_bloq(
         self, bb: 'BloqBuilder', a: Soquet, b: Soquet, target: SoquetT
     ) -> Dict[str, 'SoquetT']:
-        if not isinstance(self.bitsize, int):
-            raise NotImplementedError(f'symbolic decomposition is not supported for {self}')
+        if isinstance(self.bitsize, sympy.Expr):
+            raise DecomposeTypeError(f"Cannot decompose symbolic {self}.")
 
         # Base Case: Comparing two qubits.
         # Signed doesn't matter because we can't represent signed integers with 1 qubit.

qualtran/bloqs/rotations/hamming_weight_phasing.ipynb

@@ -234,7 +234,7 @@
    "outputs": [],
    "source": [
     "hamming_weight_phasing_via_phase_gradient = HammingWeightPhasingViaPhaseGradient(4, np.pi / 2.0)\n",
-    "print(\"Applying this unitary to |1111> should be the identity, and |0101> will flip the sign.\")"
+    "# Applying this unitary to |1111> should be the identity, and |0101> will flip the sign."
    ]
   },
   {

qualtran/bloqs/rotations/hamming_weight_phasing.py

@@ -198,7 +198,7 @@ def pretty_name(self) -> str:
 @bloq_example
 def _hamming_weight_phasing_via_phase_gradient() -> HammingWeightPhasingViaPhaseGradient:
     hamming_weight_phasing_via_phase_gradient = HammingWeightPhasingViaPhaseGradient(4, np.pi / 2.0)
-    print("Applying this unitary to |1111> should be the identity, and |0101> will flip the sign.")
+    # Applying this unitary to |1111> should be the identity, and |0101> will flip the sign.
     return hamming_weight_phasing_via_phase_gradient