[Costs] Success probability

qualtran/bloqs/for_testing/costing.py

@@ -24,14 +24,23 @@ def _convert_callees(callees: Sequence[BloqCountT]) -> Tuple[BloqCountT, ...]:
     return tuple(callees)
 
 
+def _convert_static_costs(
+    static_costs: Sequence[Tuple[CostKey, Any]]
+) -> Tuple[Tuple[CostKey, Any], ...]:
+    # Convert to tuples in a type-checked way.
+    return tuple(static_costs)
+
+
 @frozen
 class CostingBloq(Bloq):
     """A bloq that lets you set the costs via attributes."""
 
     name: str
     num_qubits: int
     callees: Sequence[BloqCountT] = field(converter=_convert_callees, factory=tuple)
-    static_costs: Sequence[Tuple[CostKey, Any]] = field(converter=tuple, factory=tuple)
+    static_costs: Sequence[Tuple[CostKey, Any]] = field(
+        converter=_convert_static_costs, factory=tuple
+    )
 
     @property
     def signature(self) -> 'Signature':

qualtran/resource_counting/__init__.py

@@ -31,4 +31,6 @@
 
 from ._costing import GeneralizerT, get_cost_value, get_cost_cache, query_costs, CostKey, CostValT
 
+from ._success_prob import SuccessProb
+
 from . import generalizers

qualtran/resource_counting/_success_prob.py

@@ -0,0 +1,49 @@
+#  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 logging
+from typing import Callable
+
+from attrs import frozen
+
+from qualtran import Bloq
+
+from ._call_graph import get_bloq_callee_counts
+from ._costing import CostKey
+
+logger = logging.getLogger(__name__)
+
+
+@frozen
+class SuccessProb(CostKey[float]):
+    """The success probability of a bloq.
+
+    A bloq's success probability is the multiplicative product of its callees'
+    success probabilities. Bloqs that have a specific success probability should override
+    `my_static_costs` to provide their actual success probability.
+    """
+
+    def compute(self, bloq: 'Bloq', get_callee_cost: Callable[['Bloq'], float]) -> float:
+        tot: float = 1.0
+        callees = get_bloq_callee_counts(bloq)
+        logger.info("Computing %s for %s from %d callee(s)", self, bloq, len(callees))
+        for callee, n in callees:
+            v = get_callee_cost(callee)
+            tot *= v**n
+        return tot
+
+    def zero(self) -> float:
+        return 1.0  # under multiplication, 1 is the identity.
+
+    def __str__(self):
+        return 'success prob'

qualtran/resource_counting/_success_prob_test.py

@@ -0,0 +1,26 @@
+#  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.
+from qualtran.bloqs.for_testing.costing import CostingBloq
+from qualtran.resource_counting import get_cost_cache, get_cost_value, SuccessProb
+
+
+def test_coin_flip():
+    flip = CostingBloq('CoinFlip', num_qubits=1, static_costs=[(SuccessProb(), 0.5)])
+    algo = CostingBloq('Algo', num_qubits=0, callees=[(flip, 4)])
+
+    p = get_cost_value(algo, SuccessProb())
+    assert p == 0.5**4
+
+    costs = get_cost_cache(algo, SuccessProb())
+    assert costs == {algo: p, flip: 0.5}