Create ModNeg and CModNeg (#1300)

Author: NoureldinYosri

dev_tools/autogenerate-bloqs-notebooks-v2.py

@@ -499,6 +499,14 @@
             qualtran.bloqs.mod_arithmetic.mod_addition._C_MOD_ADD_DOC,
         ],
     ),
+    NotebookSpecV2(
+        title='Modular Subtraction',
+        module=qualtran.bloqs.mod_arithmetic.mod_subtraction,
+        bloq_specs=[
+            qualtran.bloqs.mod_arithmetic.mod_subtraction._MOD_NEG_DOC,
+            qualtran.bloqs.mod_arithmetic.mod_subtraction._CMOD_NEG_DOC,
+        ],
+    ),
     NotebookSpecV2(
         title='Modular Multiplication',
         module=qualtran.bloqs.factoring.mod_mul,

docs/bloqs/index.rst

@@ -80,6 +80,7 @@ Bloqs Library
     :caption: Modular Arithmetic:
 
     mod_arithmetic/mod_addition.ipynb
+    mod_arithmetic/mod_subtraction.ipynb
     factoring/mod_mul.ipynb
     factoring/mod_exp.ipynb
     factoring/ecc/ec_add.ipynb

qualtran/bloqs/factoring/ecc/ec_add.py

@@ -19,16 +19,8 @@
 
 from qualtran import Bloq, bloq_example, BloqDocSpec, QUInt, Register, Signature
 from qualtran.bloqs.arithmetic._shims import MultiCToffoli
-from qualtran.bloqs.mod_arithmetic import CModAdd, ModAdd
-from qualtran.bloqs.mod_arithmetic._shims import (
-    CModNeg,
-    CModSub,
-    ModDbl,
-    ModInv,
-    ModMul,
-    ModNeg,
-    ModSub,
-)
+from qualtran.bloqs.mod_arithmetic import CModAdd, CModNeg, ModAdd, ModNeg
+from qualtran.bloqs.mod_arithmetic._shims import CModSub, ModDbl, ModInv, ModMul, ModSub
 from qualtran.resource_counting import BloqCountT, SympySymbolAllocator
 
 
@@ -80,8 +72,8 @@ def build_call_graph(self, ssa: 'SympySymbolAllocator') -> Set['BloqCountT']:
             (CModAdd(QUInt(self.n), mod=self.mod), 2),
             (ModSub(n=self.n, mod=self.mod), 2),
             (CModSub(n=self.n, mod=self.mod), 4),
-            (ModNeg(n=self.n, mod=self.mod), 2),
-            (CModNeg(n=self.n, mod=self.mod), 1),
+            (ModNeg(QUInt(self.n), mod=self.mod), 2),
+            (CModNeg(QUInt(self.n), mod=self.mod), 1),
             (ModDbl(n=self.n, mod=self.mod), 2),
             (ModMul(n=self.n, mod=self.mod), 10),
             (ModInv(n=self.n, mod=self.mod), 4),

qualtran/bloqs/factoring/mod_sub.py

@@ -13,7 +13,7 @@
 #  limitations under the License.
 
 from functools import cached_property
-from typing import Dict, Set, TYPE_CHECKING
+from typing import Dict, Set, TYPE_CHECKING, Union
 
 from attrs import frozen
 
@@ -22,6 +22,7 @@
 from qualtran.bloqs.basic_gates import CNOT, XGate
 from qualtran.bloqs.mcmt import MultiControlX
 from qualtran.bloqs.mod_arithmetic import ModAdd
+from qualtran.symbolics import HasLength
 
 if TYPE_CHECKING:
     from qualtran import BloqBuilder
@@ -183,13 +184,14 @@ def pretty_name(self) -> str:
         return f'x = -x mod {self.p}'
 
     def build_call_graph(self, ssa: 'SympySymbolAllocator') -> Set['BloqCountT']:
-        if not isinstance(self.bitsize, int):
-            raise NotImplementedError(f'symbolic call graph is not supported for {self}')
-
-        # TODO: support symbolic cost
+        cvs: Union[list[int], HasLength]
+        if isinstance(self.bitsize, int):
+            cvs = [0] * self.bitsize
+        else:
+            cvs = HasLength(self.bitsize)
         return {
             (XGate(), 2),
-            (MultiControlX(cvs=[0] * self.bitsize), 2),
+            (MultiControlX(cvs=cvs), 2),
             (CNOT(), self.bitsize),
             (AddK(bitsize=self.bitsize, k=self.p + 1, cvs=(1,), signed=False), 1),
         }

qualtran/bloqs/factoring/mod_sub_test.py

@@ -16,6 +16,7 @@
 import sympy
 
 from qualtran.bloqs.factoring.mod_sub import MontgomeryModNeg, MontgomeryModSub
+from qualtran.resource_counting import get_cost_value, QECGatesCost
 from qualtran.resource_counting.generalizers import ignore_alloc_free, ignore_split_join
 from qualtran.testing import assert_equivalent_bloq_counts, assert_valid_bloq_decomposition
 
@@ -71,3 +72,12 @@ def test_classical_action_mod_neg(bitsize, prime):
     valid_range = range(prime)
     for x in valid_range:
         assert b.call_classically(x=x) == cb.call_classically(x=x) == ((-x) % prime,)
+
+
+def test_montgomerymodneg_symbolic_cost():
+    n = sympy.Symbol('n')
+    p = 13
+    b = MontgomeryModNeg(n, p)
+    cost = get_cost_value(b, QECGatesCost()).total_t_and_ccz_count()
+    assert cost['n_t'] == 0
+    assert cost['n_ccz'] == 3 * (n - 1)

qualtran/bloqs/mod_arithmetic/__init__.py

@@ -12,5 +12,6 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from ._shims import CModNeg, CModSub, ModDbl, ModInv, ModMul, ModNeg, ModSub
+from ._shims import CModSub, ModDbl, ModInv, ModMul, ModSub
 from .mod_addition import CModAdd, CModAddK, CtrlScaleModAdd, ModAdd, ModAddK
+from .mod_subtraction import CModNeg, ModNeg

qualtran/bloqs/mod_arithmetic/_shims.py

@@ -207,55 +207,3 @@ def wire_symbol(
         elif reg.name == 'out':
             return TextBox('$2x$')
         raise ValueError(f'Unrecognized register name {reg.name}')
-
-
-@frozen
-class ModNeg(Bloq):
-    n: int
-    mod: int
-
-    @cached_property
-    def signature(self) -> 'Signature':
-        return Signature([Register('x', QUInt(self.n))])
-
-    def build_call_graph(self, ssa: 'SympySymbolAllocator') -> Set['BloqCountT']:
-        # litinski
-        return {
-            (MultiCToffoli(self.n), 2),
-            (CNOT(), self.n),
-            (AddK(self.n, k=self.mod).controlled(), 1),
-        }
-
-    def wire_symbol(
-        self, reg: Optional['Register'], idx: Tuple[int, ...] = tuple()
-    ) -> 'WireSymbol':
-        if reg is None:
-            return Text("")
-        if reg.name == 'x':
-            return TextBox('$-x$')
-        raise ValueError(f'Unrecognized register name {reg.name}')
-
-
-@frozen
-class CModNeg(Bloq):
-    n: int
-    mod: int
-
-    @cached_property
-    def signature(self) -> 'Signature':
-        return Signature([Register('ctrl', QBit()), Register('x', QUInt(self.n))])
-
-    def build_call_graph(self, ssa: 'SympySymbolAllocator') -> Set['BloqCountT']:
-        # Roetteler
-        return {(Toffoli(), ceil(8 * self.n * log2(self.n) - 14.5 * self.n))}
-
-    def wire_symbol(
-        self, reg: Optional['Register'], idx: Tuple[int, ...] = tuple()
-    ) -> 'WireSymbol':
-        if reg is None:
-            return Text("")
-        if reg.name == 'ctrl':
-            return Circle()
-        elif reg.name == 'x':
-            return TextBox('$-x$')
-        raise ValueError(f'Unrecognized register name {reg.name}')