Moving FLASQ into Qualtran

.github/workflows/pr.yaml

@@ -79,6 +79,7 @@ jobs:
           python dev_tools/execute-notebooks.py --n-workers=8
         env:
           NUMBA_NUM_THREADS: 4
+          FLASQ_FAST_MODE_OVERRIDE: 'True'
 
   format:
     runs-on: ubuntu-24.04

.gitignore

@@ -142,3 +142,6 @@ jupyter_kernel.lock
 
 # Mac OS
 .DS_Store
+
+# FLASQ generated PDFs
+*.pdf

pyproject.toml

@@ -58,6 +58,13 @@ dependencies = [
 
     # rotation_synthesis
     "mpmath",
+
+    # flasq integration
+    "frozendict",
+    "pandas >= 2.0",
+    "seaborn",
+    "joblib",
+    "tqdm",
 ]
 
 [tool.hatch.version]

qualtran/resource_counting/__init__.py

@@ -34,5 +34,6 @@
 from ._success_prob import SuccessProb
 from ._qubit_counts import QubitCount
 from ._bloq_counts import BloqCount, QECGatesCost, GateCounts
+from .classify_bloqs import bloq_is_t_like
 
 from . import generalizers

qualtran/surface_code/flasq/__init__.py

@@ -0,0 +1,85 @@
+#  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.
+
+"""qualtran.surface_code.flasq: FLASQ cost model for fault-tolerant quantum resource estimation."""
+
+from qualtran.surface_code.flasq import cultivation_analysis  # noqa: F401 — imported as module
+from qualtran.surface_code.flasq.cirq_interop import convert_circuit_for_flasq_analysis
+from qualtran.surface_code.flasq.error_mitigation import (
+    calculate_error_mitigation_metrics,
+    calculate_failure_probabilities,
+)
+from qualtran.surface_code.flasq.flasq_model import (
+    apply_flasq_cost_model,
+    conservative_FLASQ_costs,
+    FLASQCostModel,
+    FLASQSummary,
+    get_rotation_depth,
+    optimistic_FLASQ_costs,
+)
+from qualtran.surface_code.flasq.measurement_depth import MeasurementDepth, TotalMeasurementDepth
+from qualtran.surface_code.flasq.naive_grid_qubit_manager import NaiveGridQubitManager
+from qualtran.surface_code.flasq.optimization import (
+    ErrorBudget,
+    generate_circuit_specific_configs,
+    generate_configs_for_constrained_qec,
+    generate_configs_from_cultivation_data,
+    post_process_for_failure_budget,
+    post_process_for_logical_depth,
+    post_process_for_pec_runtime,
+    run_sweep,
+)
+from qualtran.surface_code.flasq.span_counting import BloqWithSpanInfo, GateSpan, TotalSpanCost
+from qualtran.surface_code.flasq.symbols import (
+    MIXED_FALLBACK_T_COUNT,
+    ROTATION_ERROR,
+    T_REACT,
+    V_CULT_FACTOR,
+)
+from qualtran.surface_code.flasq.utils import substitute_until_fixed_point
+from qualtran.surface_code.flasq.volume_counting import FLASQGateCounts, FLASQGateTotals
+
+__all__ = [
+    "FLASQCostModel",
+    "FLASQSummary",
+    "apply_flasq_cost_model",
+    "conservative_FLASQ_costs",
+    "optimistic_FLASQ_costs",
+    "get_rotation_depth",
+    "FLASQGateTotals",
+    "TotalSpanCost",
+    "TotalMeasurementDepth",
+    "convert_circuit_for_flasq_analysis",
+    "NaiveGridQubitManager",
+    "ErrorBudget",
+    "run_sweep",
+    "generate_configs_for_constrained_qec",
+    "generate_configs_from_cultivation_data",
+    "generate_circuit_specific_configs",
+    "post_process_for_failure_budget",
+    "post_process_for_pec_runtime",
+    "post_process_for_logical_depth",
+    "calculate_error_mitigation_metrics",
+    "calculate_failure_probabilities",
+    "MIXED_FALLBACK_T_COUNT",
+    "ROTATION_ERROR",
+    "V_CULT_FACTOR",
+    "T_REACT",
+    "substitute_until_fixed_point",
+    "cultivation_analysis",
+    "FLASQGateCounts",
+    "GateSpan",
+    "MeasurementDepth",
+    "BloqWithSpanInfo",
+]

qualtran/surface_code/flasq/adder_example_test.py

@@ -0,0 +1,112 @@
+#  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.
+
+# test_adder_example.py
+import cirq
+
+from qualtran.resource_counting import get_cost_value
+from qualtran.surface_code.flasq.cirq_interop import convert_circuit_for_flasq_analysis
+
+# Import functions/classes to be tested or used in tests
+from qualtran.surface_code.flasq.examples.adder_example import (
+    analyze_adder_costs,
+    create_adder_circuit_and_decorations,
+)
+from qualtran.surface_code.flasq.span_counting import GateSpan, TotalSpanCost
+from qualtran.surface_code.flasq.volume_counting import FLASQGateCounts, FLASQGateTotals
+
+TEST_BITSIZE = 4
+
+
+def test_analyze_adder_costs_runs():
+    """Tests that analyze_adder_costs executes without exceptions."""
+    analyze_adder_costs(TEST_BITSIZE)
+
+
+def test_create_adder_circuit_runs_and_returns_circuit():
+    """Tests create_adder_circuit runs and returns a Cirq circuit."""
+    circuit, _, _, _ = create_adder_circuit_and_decorations(TEST_BITSIZE)
+    assert isinstance(circuit, cirq.Circuit)
+    assert len(list(circuit.all_operations())) > 0
+
+
+def test_decomposed_adder_flasq_and_span_costs():
+    """
+    Tests applying FLASQ and Span costing to the decomposed adder circuit.
+    Verifies that costs are calculated and no unknown/uncounted bloqs remain.
+    """
+    original_circuit, signature, in_quregs, out_quregs = create_adder_circuit_and_decorations(
+        TEST_BITSIZE
+    )
+    cbloq, decomposed_circuit = convert_circuit_for_flasq_analysis(
+        original_circuit, signature=signature, in_quregs=in_quregs, out_quregs=out_quregs
+    )
+    assert cbloq is not None  # Ensure conversion succeeded
+    assert decomposed_circuit is not None  # Ensure decomposed circuit is returned
+
+    flasq_costs = get_cost_value(cbloq, FLASQGateTotals())
+    assert isinstance(flasq_costs, FLASQGateCounts)
+    assert not flasq_costs.bloqs_with_unknown_cost
+    # Check that some expected gates were counted (Add decomposes to Toffoli/CNOT)
+    assert flasq_costs.toffoli > 0 or flasq_costs.cnot > 0
+    # 4. Calculate Span costs
+    span_info = get_cost_value(cbloq, TotalSpanCost())
+    assert isinstance(span_info, GateSpan)
+    assert not span_info.uncounted_bloqs
+    # Check that some span was counted (multi-qubit gates exist)
+    # Resolve symbols in span_info before making boolean checks
+    assert span_info.connect_span > 0
+    # Check the decomposed circuit from the conversion
+    assert len(list(decomposed_circuit.all_operations())) > 0
+
+
+import cirq
+import numpy as np
+
+from qualtran import QUInt
+from qualtran.bloqs.arithmetic import Add
+from qualtran.bloqs.mcmt import And
+from qualtran.cirq_interop import cirq_optree_to_cbloq
+
+
+def test_self_contained_adder_issue():
+    adder_bloq = Add(a_dtype=QUInt(4), b_dtype=QUInt(4))
+
+    a_qubits = np.asarray([cirq.LineQubit(i * 3 + 0) for i in range(4)])
+    b_qubits = np.asarray([cirq.LineQubit(i * 3 + 1) for i in range(4)])
+
+    adder_op, _ = adder_bloq.as_cirq_op(
+        qubit_manager=cirq.SimpleQubitManager(), a=b_qubits, b=a_qubits
+    )
+    assert adder_op is not None
+    circuit = cirq.Circuit(adder_op)
+
+    def is_and_or_short(op):
+
+        if len(op.qubits) <= 2:
+            return True
+
+        if isinstance(op.gate, And):
+            return True
+
+        return False
+
+    circuit = cirq.Circuit(cirq.decompose(circuit, keep=is_and_or_short))
+
+    cbloq = cirq_optree_to_cbloq(
+        circuit.all_operations(),
+        signature=adder_bloq.signature,
+        in_quregs={"a": a_qubits, "b": b_qubits},
+        out_quregs={"a": a_qubits, "b": b_qubits},
+    )