[arithmetic] Organize Subtract (#964)

Author: mpharrigan

qualtran/bloqs/arithmetic/__init__.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from qualtran.bloqs.arithmetic.addition import Add, AddK, OutOfPlaceAdder, Subtract
+from qualtran.bloqs.arithmetic.addition import Add, AddK, OutOfPlaceAdder
 from qualtran.bloqs.arithmetic.comparison import (
     BiQubitsMixer,
     EqualsAConstant,
@@ -34,5 +34,6 @@
     SumOfSquares,
 )
 from qualtran.bloqs.arithmetic.sorting import BitonicSort, Comparator
+from qualtran.bloqs.arithmetic.subtraction import Subtract
 
-from ._shims import CHalf, Lt, MultiCToffoli, Negate, Sub
+from ._shims import CHalf, Lt, MultiCToffoli, Negate

qualtran/bloqs/arithmetic/_shims.py

@@ -40,15 +40,6 @@ def build_call_graph(self, ssa: 'SympySymbolAllocator') -> Set['BloqCountT']:
         return {(Toffoli(), self.n - 2)}
 
 
-@frozen
-class Sub(Bloq):
-    n: int
-
-    @cached_property
-    def signature(self) -> 'Signature':
-        return Signature([Register('x', QUInt(self.n)), Register('y', QUInt(self.n))])
-
-
 @frozen
 class Lt(Bloq):
     n: int

qualtran/bloqs/arithmetic/addition.py

@@ -47,14 +47,14 @@
     GateWithRegisters,
     QBit,
     QInt,
+    QMontgomeryUInt,
     QUInt,
     Register,
     Side,
     Signature,
     Soquet,
     SoquetT,
 )
-from qualtran._infra.data_types import QMontgomeryUInt
 from qualtran.bloqs import util_bloqs
 from qualtran.bloqs.basic_gates import CNOT, XGate
 from qualtran.bloqs.mcmt.and_bloq import And
@@ -575,145 +575,3 @@ def _add_k_large() -> AddK:
 
 
 _ADD_K_DOC = BloqDocSpec(bloq_cls=AddK, examples=[_add_k, _add_k_small, _add_k_large])
-
-
-@frozen
-class Subtract(Bloq):
-    r"""An n-bit subtraction gate.
-
-    Implements $U|a\rangle|b\rangle \rightarrow |a\rangle|a-b\rangle$ using $4n - 4 T$ gates.
-
-    Args:
-        a_dtype: Quantum datatype used to represent the integer a.
-        b_dtype: Quantum datatype used to represent the integer b. Must be large
-            enough to hold the result in the output register of a - b, or else it simply
-            drops the most significant bits. If not specified, b_dtype is set to a_dtype.
-
-    Registers:
-        a: A a_dtype.bitsize-sized input register (register a above).
-        b: A b_dtype.bitsize-sized input/output register (register b above).
-
-    References:
-        [Halving the cost of quantum addition](https://arxiv.org/abs/1709.06648)
-    """
-
-    a_dtype: Union[QInt, QUInt, QMontgomeryUInt] = field()
-    b_dtype: Union[QInt, QUInt, QMontgomeryUInt] = field()
-
-    @b_dtype.default
-    def b_dtype_default(self):
-        return self.a_dtype
-
-    @a_dtype.validator
-    def _a_dtype_validate(self, field, val):
-        if not isinstance(val, (QInt, QUInt, QMontgomeryUInt)):
-            raise ValueError("Only QInt, QUInt and QMontgomerUInt types are supported.")
-        if isinstance(val.num_qubits, sympy.Expr):
-            return
-        if val.bitsize > self.b_dtype.bitsize:
-            raise ValueError("a_dtype bitsize must be less than or equal to b_dtype bitsize")
-
-    @b_dtype.validator
-    def _b_dtype_validate(self, field, val):
-        if not isinstance(val, (QInt, QUInt, QMontgomeryUInt)):
-            raise ValueError("Only QInt, QUInt and QMontgomerUInt types are supported.")
-
-    @property
-    def dtype(self):
-        if self.a_dtype != self.b_dtype:
-            raise ValueError(
-                "Add.dtype is only supported when both operands have the same dtype: "
-                f"{self.a_dtype=}, {self.b_dtype=}"
-            )
-        return self.a_dtype
-
-    @property
-    def signature(self):
-        return Signature([Register("a", self.a_dtype), Register("b", self.b_dtype)])
-
-    def on_classical_vals(
-        self, a: 'ClassicalValT', b: 'ClassicalValT'
-    ) -> Dict[str, 'ClassicalValT']:
-        unsigned = isinstance(self.a_dtype, (QUInt, QMontgomeryUInt))
-        b_bitsize = self.b_dtype.bitsize
-        N = 2**b_bitsize if unsigned else 2 ** (b_bitsize - 1)
-        return {'a': a, 'b': int(math.fmod(a - b, N))}
-
-    def short_name(self) -> str:
-        return "a-b"
-
-    def _circuit_diagram_info_(self, _) -> cirq.CircuitDiagramInfo:
-        wire_symbols = ["In(x)"] * int(self.a_dtype.bitsize)
-        wire_symbols += ["In(y)/Out(x-y)"] * int(self.b_dtype.bitsize)
-        return cirq.CircuitDiagramInfo(wire_symbols=wire_symbols)
-
-    def wire_symbol(self, soq: 'Soquet') -> 'WireSymbol':
-        from qualtran.drawing import directional_text_box
-
-        if soq.reg.name == 'a':
-            return directional_text_box('a', side=soq.reg.side)
-        elif soq.reg.name == 'b':
-            return directional_text_box('a-b', side=soq.reg.side)
-        else:
-            raise ValueError()
-
-    def build_call_graph(self, ssa: 'SympySymbolAllocator') -> Set['BloqCountT']:
-        a_dtype = (
-            self.a_dtype if not isinstance(self.a_dtype, QInt) else QUInt(self.a_dtype.bitsize)
-        )
-        b_dtype = (
-            self.b_dtype if not isinstance(self.b_dtype, QInt) else QUInt(self.b_dtype.bitsize)
-        )
-        return {
-            (XGate(), self.b_dtype.bitsize),
-            (AddK(self.b_dtype.bitsize, k=1), 1),
-            (Add(a_dtype, b_dtype), 1),
-            (util_bloqs.Split(self.b_dtype), 1),
-            (util_bloqs.Join(self.b_dtype), 1),
-        }
-
-    def build_composite_bloq(self, bb: 'BloqBuilder', a: Soquet, b: Soquet) -> Dict[str, 'SoquetT']:
-        b = np.array([bb.add(XGate(), q=q) for q in bb.split(b)])  # 1s complement of b.
-        b = bb.add(
-            AddK(self.b_dtype.bitsize, k=1), x=bb.join(b, self.b_dtype)
-        )  # 2s complement of b.
-
-        a_dtype = (
-            self.a_dtype if not isinstance(self.a_dtype, QInt) else QUInt(self.a_dtype.bitsize)
-        )
-        b_dtype = (
-            self.b_dtype if not isinstance(self.b_dtype, QInt) else QUInt(self.b_dtype.bitsize)
-        )
-
-        a, b = bb.add(Add(a_dtype, b_dtype), a=a, b=b)  # a - b
-        return {'a': a, 'b': b}
-
-
-@bloq_example
-def _sub_symb() -> Subtract:
-    n = sympy.Symbol('n')
-    sub_symb = Subtract(QInt(bitsize=n))
-    return sub_symb
-
-
-@bloq_example
-def _sub_small() -> Subtract:
-    sub_small = Subtract(QInt(bitsize=4))
-    return sub_small
-
-
-@bloq_example
-def _sub_large() -> Subtract:
-    sub_large = Subtract(QInt(bitsize=64))
-    return sub_large
-
-
-@bloq_example
-def _sub_diff_size_regs() -> Subtract:
-    sub_diff_size_regs = Subtract(QInt(bitsize=4), QInt(bitsize=16))
-    return sub_diff_size_regs
-
-
-_SUB_DOC = BloqDocSpec(
-    bloq_cls=Subtract, examples=[_sub_symb, _sub_small, _sub_large, _sub_diff_size_regs]
-)

qualtran/bloqs/arithmetic/addition_test.py

@@ -21,7 +21,7 @@
 
 import qualtran.testing as qlt_testing
 from qualtran import BloqBuilder, CtrlSpec, QInt, QUInt
-from qualtran.bloqs.arithmetic.addition import Add, AddK, OutOfPlaceAdder, Subtract
+from qualtran.bloqs.arithmetic.addition import Add, AddK, OutOfPlaceAdder
 from qualtran.cirq_interop.bit_tools import iter_bits, iter_bits_twos_complement
 from qualtran.cirq_interop.t_complexity_protocol import TComplexity
 from qualtran.cirq_interop.testing import (
@@ -329,31 +329,6 @@ def test_classical_add_k_signed(bitsize, k, x, cvs, ctrls, result):
     assert bloq_classical[-1] == result
 
 
-@pytest.mark.slow
-def test_subtract_bloq_decomposition():
-    gate = Subtract(QInt(3), QInt(5))
-    qlt_testing.assert_valid_bloq_decomposition(gate)
-
-    want = np.zeros((256, 256))
-    for a_b in range(256):
-        a, b = a_b >> 5, a_b & 31
-        c = (a - b) % 32
-        want[(a << 5) | c][a_b] = 1
-    got = gate.tensor_contract()
-    np.testing.assert_equal(got, want)
-
-
-def test_subtract_bloq_validation():
-    assert Subtract(QUInt(3)) == Subtract(QUInt(3), QUInt(3))
-    with pytest.raises(ValueError, match='bitsize must be less'):
-        _ = Subtract(QInt(5), QInt(3))
-    assert Subtract(QUInt(3)).dtype == QUInt(3)
-
-
-def test_subtract_bloq_consitant_counts():
-    qlt_testing.assert_equivalent_bloq_counts(Subtract(QInt(3), QInt(4)))
-
-
 @pytest.mark.notebook
 def test_notebook():
     qlt_testing.execute_notebook('addition')