Clean up and maintenance of checks (#902)

* Clean up and maintenance of checks

* note slowness

* lint

* serialization skips

Author: mpharrigan

dev_tools/qualtran_dev_tools/bloq_report_card.py

@@ -11,6 +11,8 @@
 #  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 time
+import warnings
 from typing import Any, Dict, Iterable, List, Optional, Set, Type
 
 import pandas as pd
@@ -21,8 +23,8 @@
     BloqCheckResult,
     check_bloq_example_decompose,
     check_bloq_example_make,
-    check_bloq_example_serialize,
-    check_connections_preserve_preserves_types,
+    check_bloq_example_qtyping,
+    check_bloq_example_serializes,
     check_equivalent_bloq_example_counts,
 )
 
@@ -67,33 +69,31 @@ def bloq_classes_with_no_examples(
 
 
 IDCOLS = ['package', 'bloq_cls', 'name']
-CHECKCOLS = ['make', 'decomp', 'counts', 'serialize', 'typing']
+CHECKCOLS = ['make', 'decomp', 'counts', 'serialize', 'qtyping']
 
 
 def record_for_class_with_no_examples(k: Type[Bloq]) -> Dict[str, Any]:
-    return {
-        'bloq_cls': k.__name__,
-        'package': _get_package(k),
-        'name': '-',
-        'make': BloqCheckResult.MISSING,
-        'decomp': BloqCheckResult.MISSING,
-        'counts': BloqCheckResult.MISSING,
-        'serialize': BloqCheckResult.MISSING,
-        'typing': BloqCheckResult.MISSING,
+    return {'bloq_cls': k.__name__, 'package': _get_package(k), 'name': '-'} | {
+        check_name: BloqCheckResult.MISSING for check_name in CHECKCOLS
     }
 
 
 def record_for_bloq_example(be: BloqExample) -> Dict[str, Any]:
-    return {
+    start = time.perf_counter()
+    record = {
         'bloq_cls': be.bloq_cls.__name__,
         'package': _get_package(be.bloq_cls),
         'name': be.name,
         'make': check_bloq_example_make(be)[0],
         'decomp': check_bloq_example_decompose(be)[0],
         'counts': check_equivalent_bloq_example_counts(be)[0],
-        'serialize': check_bloq_example_serialize(be)[0],
-        'typing': check_connections_preserve_preserves_types(be)[0],
+        'serialize': check_bloq_example_serializes(be)[0],
+        'qtyping': check_bloq_example_qtyping(be)[0],
     }
+    dur = time.perf_counter() - start
+    if dur > 1.0:
+        warnings.warn(f"{be.name} took {dur} to check.")
+    return record
 
 
 def show_bloq_report_card(df: pd.DataFrame) -> pandas.io.formats.style.Styler:
@@ -110,6 +110,10 @@ def get_bloq_report_card(
         bclasses = get_bloq_classes()
     if bexamples is None:
         bexamples = get_bloq_examples()
+        # Default exclusions: pass explicit bexamples to override.
+        # qubitization_qpi_hubbard_model_xxx -- too slow
+        skips = ['qubitization_qpe_hubbard_model_small', 'qubitization_qpe_hubbard_model_large']
+        bexamples = [bex for bex in bexamples if bex.name not in skips]
 
     records: List[Dict[str, Any]] = []
     missing_bclasses = bloq_classes_with_no_examples(bclasses, bexamples)

qualtran/bloqs/hamiltonian_simulation/hamiltonian_simulation_by_gqsp_test.py

@@ -39,8 +39,6 @@ def test_examples(bloq_autotester):
 
 
 def test_symbolic_examples(bloq_autotester):
-    if bloq_autotester.check_name == 'serialization':
-        pytest.xfail(f"serialization for {_symbolic_hamsim_by_gqsp.name} not yet supported")
     bloq_autotester(_symbolic_hamsim_by_gqsp)
 
 

qualtran/bloqs/qsp/generalized_qsp_test.py

@@ -227,8 +227,6 @@ def _gqsp_1d_ising() -> GeneralizedQSP:
 
 
 def test_gqsp_1d_ising_example(bloq_autotester):
-    if bloq_autotester.check_name == 'serialization':
-        pytest.xfail("Skipping serialization test for bloq examples that cannot yet be serialized.")
     bloq_autotester(_gqsp_1d_ising)
 
 

qualtran/conftest.py

@@ -75,7 +75,7 @@ def assert_equivalent_bloq_example_counts_for_pytest(bloq_ex: BloqExample):
         raise bce from bce
 
 
-def assert_bloq_example_serialize_for_pytest(bloq_ex: BloqExample):
+def assert_bloq_example_serializes_for_pytest(bloq_ex: BloqExample):
     if bloq_ex.name in [
         'prep_sparse',
         'thc_prep',
@@ -88,19 +88,21 @@ def assert_bloq_example_serialize_for_pytest(bloq_ex: BloqExample):
         'select_pauli_lcu',
         'walk_op',
         'trott_unitary',
-        "hubbard_time_evolution_by_gqsp",
+        'hubbard_time_evolution_by_gqsp',
+        'symbolic_hamsim_by_gqsp',
+        'gqsp_1d_ising',
     ]:
         pytest.xfail("Skipping serialization test for bloq examples that cannot yet be serialized.")
 
     try:
-        qlt_testing.assert_bloq_example_serialize(bloq_ex)
+        qlt_testing.assert_bloq_example_serializes(bloq_ex)
     except qlt_testing.BloqCheckException as bce:
         raise bce from bce
 
 
-def assert_bloq_example_typing_for_pytest(bloq_ex: BloqExample):
+def assert_bloq_example_qtyping_for_pytest(bloq_ex: BloqExample):
     try:
-        qlt_testing.assert_bloq_example_preserves_types(bloq_ex)
+        qlt_testing.assert_bloq_example_qtyping(bloq_ex)
     except qlt_testing.BloqCheckException as bce:
         if bce.check_result is qlt_testing.BloqCheckResult.NA:
             pytest.skip(bce.msg)
@@ -112,8 +114,8 @@ def assert_bloq_example_typing_for_pytest(bloq_ex: BloqExample):
     ('make', assert_bloq_example_make_for_pytest),
     ('decompose', assert_bloq_example_decompose_for_pytest),
     ('counts', assert_equivalent_bloq_example_counts_for_pytest),
-    ('serialization', assert_bloq_example_serialize_for_pytest),
-    ('typing', assert_bloq_example_typing_for_pytest),
+    ('serialize', assert_bloq_example_serializes_for_pytest),
+    ('qtyping', assert_bloq_example_qtyping_for_pytest),
 ]
 
 

qualtran/testing.py

@@ -136,11 +136,17 @@ def assert_connections_compatible(cbloq: CompositeBloq):
             raise BloqError(f"{cxn}'s right side is associated with a register with side {rr.side}")
 
 
-def assert_connections_preserve_types(
+def assert_connections_consistent_qdtypes(
     cbloq: CompositeBloq,
     type_checking_severity: QDTypeCheckingSeverity = QDTypeCheckingSeverity.LOOSE,
 ):
-    """Check that connections have consistent dtypes accounting for type_checking_severity."""
+    """Check that a composite bloq's connections have consistent qdtypes.
+
+    Args:
+         cbloq: The composite bloq.
+         type_checking_severity: How strict to be in type checking. See the documentation
+            for the QDTypeCheckingSeverity enum for details.
+    """
     for cxn in cbloq.connections:
         lr = cxn.left.reg
         rr = cxn.right.reg
@@ -525,7 +531,23 @@ def check_equivalent_bloq_example_counts(bloq_ex: BloqExample) -> Tuple[BloqChec
     return BloqCheckResult.PASS, ''
 
 
-def assert_bloq_example_serialize(bloq_ex: BloqExample) -> Tuple[BloqCheckResult, str]:
+def assert_bloq_example_serializes(bloq_ex: BloqExample) -> None:
+    """Assert that the BloqExample has consistent serialization.
+
+    This function asserts that the given bloq can be serialized to a proto format and the
+    corresponding proto can be deserialized back to a bloq which is equal to the original
+    bloq.
+
+    If the given Bloq cannot be serialized / deserialized OR if the deserialized Bloq is not
+    equal to the given Bloq, then the result is `FAIL`. If the roundtrip succeeds, the result
+    is `PASS`.
+
+    Returns:
+        None if the assertions are satisfied.
+
+    Raises:
+        BloqCheckException if any assertions are violated.
+    """
     from qualtran.serialization.bloq import bloqs_from_proto, bloqs_to_proto
 
     bloq = bloq_ex.make()
@@ -547,7 +569,7 @@ def assert_bloq_example_serialize(bloq_ex: BloqExample) -> Tuple[BloqCheckResult
         ) from e
 
 
-def check_bloq_example_serialize(bloq_ex: BloqExample) -> Tuple[BloqCheckResult, str]:
+def check_bloq_example_serializes(bloq_ex: BloqExample) -> Tuple[BloqCheckResult, str]:
     """Check that the BloqExample has consistent serialization.
 
     This function checks that the given bloq can be serialized to a proto format and the
@@ -563,7 +585,7 @@ def check_bloq_example_serialize(bloq_ex: BloqExample) -> Tuple[BloqCheckResult,
         msg: A message providing details from the check.
     """
     try:
-        assert_bloq_example_serialize(bloq_ex)
+        assert_bloq_example_serializes(bloq_ex)
     except BloqCheckException as bce:
         return bce.check_result, bce.msg
     except Exception as e:  # pylint: disable=broad-except
@@ -572,55 +594,73 @@ def check_bloq_example_serialize(bloq_ex: BloqExample) -> Tuple[BloqCheckResult,
     return BloqCheckResult.PASS, ''
 
 
-def assert_bloq_example_preserves_types(bloq_ex: BloqExample) -> Tuple[BloqCheckResult, str]:
-    """Check a bloq example preserves types throughout its decomposition.
+def assert_bloq_example_qtyping(bloq_ex: BloqExample) -> Tuple[BloqCheckResult, str]:
+    """Assert that the bloq example has valid quantum data types throughout its decomposition.
 
-    Args:
-        bloq_ex: The bloq example to test.
+    If the bloq has no decomposition, this check is not applicable. Otherwise: we check the
+    `connections` in the decomposed bloq with increasing levels of type checking severity.
+    First, we check loose type checking (allowing conversions between numeric types). A
+    failure here is raised as a FAIL.
+
+    Then `QDTypeCheckingSeverity.ANY` checking (allowing just conversions to and from QAny) and
+    finally strict checking are performed. Currently, these are coded as an UNVERIFIED bloq
+    check result.
 
     Returns:
-        None
+        None if the assertions are satisfied.
 
     Raises:
-        BloqCheckException if any assertions are violated. Will raise a failure
-        if loose type checking fails, and unverified if the stricter type checks
-        fail.
+        BloqCheckException if any assertions are violated.
     """
     bloq = bloq_ex.make()
-    # First check it's not atomic / doesn't decompose
+    # First check for the presence of a decomposition
     try:
         cbloq = bloq.decompose_bloq()
-    except (DecomposeTypeError, DecomposeNotImplementedError) as exc:
-        raise BloqCheckException.missing(
-            r"Atomic bloqs or non-decomposable bloqs don't require type checking."
-        )
+    except (DecomposeTypeError, DecomposeNotImplementedError) as e:
+        raise BloqCheckException.na(
+            r"QDType checking is only applicable for bloqs with decompositions"
+        ) from e
+
     try:
-        assert_connections_preserve_types(
+        assert_connections_consistent_qdtypes(
             cbloq, type_checking_severity=QDTypeCheckingSeverity.LOOSE
         )
     except Exception as e:
         raise BloqCheckException.fail('Loose type checking failed.\n' + str(e)) from e
+
     try:
-        assert_connections_preserve_types(cbloq, type_checking_severity=QDTypeCheckingSeverity.ANY)
+        assert_connections_consistent_qdtypes(
+            cbloq, type_checking_severity=QDTypeCheckingSeverity.ANY
+        )
     except Exception as e:
         raise BloqCheckException.unverified('QAny and QBit type checking failed.\n' + str(e)) from e
+
     try:
-        assert_connections_preserve_types(
+        assert_connections_consistent_qdtypes(
             cbloq, type_checking_severity=QDTypeCheckingSeverity.STRICT
         )
     except Exception as e:
         raise BloqCheckException.unverified('Strict type checking failed.\n' + str(e)) from e
 
 
-def check_connections_preserve_preserves_types(bloq_ex: BloqExample) -> Tuple[BloqCheckResult, str]:
-    """Check that the BloqExample has consistent typing.
+def check_bloq_example_qtyping(bloq_ex: BloqExample) -> Tuple[BloqCheckResult, str]:
+    """Check that the bloq example has valid quantum data types throughout its decomposition.
+
+    If the bloq has no decomposition, this check is not applicable. Otherwise: we check the
+    `connections` in the decomposed bloq with increasing levels of type checking severity.
+    First, we check loose type checking (allowing conversions between numeric types). A
+    failure here is returned as a FAIL.
+
+    Then `QDTypeCheckingSeverity.ANY` checking (allowing just conversions to and from QAny) and
+    finally strict checking are performed. Currently, these are coded as an UNVERIFIED bloq
+    check result.
 
     Returns:
         result: The `BloqCheckResult`.
         msg: A message providing details from the check.
     """
     try:
-        assert_bloq_example_preserves_types(bloq_ex)
+        assert_bloq_example_qtyping(bloq_ex)
     except BloqCheckException as bce:
         return bce.check_result, bce.msg
     except Exception as e:  # pylint: disable=broad-except