Remove remaining adjoint attributes (#909)

* Remove remaining adjoints.

* Fix test failure.

Author: fdmalone

qualtran/bloqs/arithmetic/addition.py

@@ -19,7 +19,7 @@
 import cirq
 import numpy as np
 import sympy
-from attrs import field, frozen
+from attrs import evolve, field, frozen
 from numpy.typing import NDArray
 
 from qualtran import (
@@ -273,11 +273,11 @@ class OutOfPlaceAdder(GateWithRegisters, cirq.ArithmeticGate):
     """
 
     bitsize: int
-    adjoint: bool = False
+    is_adjoint: bool = False
 
     @property
     def signature(self):
-        side = Side.LEFT if self.adjoint else Side.RIGHT
+        side = Side.LEFT if self.is_adjoint else Side.RIGHT
         return Signature(
             [
                 Register('a', QUInt(self.bitsize)),
@@ -292,6 +292,9 @@ def registers(self) -> Sequence[Union[int, Sequence[int]]]:
     def apply(self, a: int, b: int, c: int) -> Tuple[int, int, int]:
         return a, b, c + a + b
 
+    def adjoint(self) -> 'OutOfPlaceAdder':
+        return evolve(self, is_adjoint=not self.is_adjoint)
+
     def on_classical_vals(
         self, *, a: 'ClassicalValT', b: 'ClassicalValT'
     ) -> Dict[str, 'ClassicalValT']:
@@ -315,25 +318,25 @@ def decompose_from_registers(
             ]
             for i in range(self.bitsize)
         ]
-        return cirq.inverse(optree) if self.adjoint else optree
+        return cirq.inverse(optree) if self.is_adjoint else optree
 
     def _t_complexity_(self) -> TComplexity:
-        and_t = And(uncompute=self.adjoint).t_complexity()
+        and_t = And(uncompute=self.is_adjoint).t_complexity()
         num_clifford = self.bitsize * (5 + and_t.clifford)
         num_t = self.bitsize * and_t.t
         return TComplexity(t=num_t, clifford=num_clifford)
 
     def build_call_graph(self, ssa: 'SympySymbolAllocator') -> Set['BloqCountT']:
         return {
-            (And(uncompute=self.adjoint), self.bitsize),
+            (And(uncompute=self.is_adjoint), self.bitsize),
             (ArbitraryClifford(n=2), 5 * self.bitsize),
         }
 
     def __pow__(self, power: int):
         if power == 1:
             return self
         if power == -1:
-            return OutOfPlaceAdder(self.bitsize, adjoint=not self.adjoint)
+            return OutOfPlaceAdder(self.bitsize, is_adjoint=not self.is_adjoint)
         raise NotImplementedError("OutOfPlaceAdder.__pow__ defined only for +1/-1.")
 
 

qualtran/bloqs/arithmetic/multiplication.py

@@ -16,7 +16,7 @@
 
 import cirq
 import numpy as np
-from attrs import frozen
+from attrs import evolve, frozen
 
 from qualtran import (
     Bloq,
@@ -48,10 +48,10 @@ class PlusEqualProduct(GateWithRegisters, cirq.ArithmeticGate):
     a_bitsize: int
     b_bitsize: int
     result_bitsize: int
-    adjoint: bool = False
+    is_adjoint: bool = False
 
     def short_name(self) -> str:
-        return "result -= a*b" if self.adjoint else "result += a*b"
+        return "result -= a*b" if self.is_adjoint else "result += a*b"
 
     @property
     def signature(self) -> 'Signature':
@@ -64,14 +64,17 @@ def signature(self) -> 'Signature':
     def registers(self) -> Sequence[Union[int, Sequence[int]]]:
         return [2] * self.a_bitsize, [2] * self.b_bitsize, [2] * self.result_bitsize
 
+    def adjoint(self) -> 'PlusEqualProduct':
+        return evolve(self, is_adjoint=not self.is_adjoint)
+
     def apply(self, a: int, b: int, result: int) -> Union[int, Iterable[int]]:
-        return a, b, (result + a * b * ((-1) ** self.adjoint)) % (2**self.result_bitsize)
+        return a, b, (result + a * b * ((-1) ** self.is_adjoint)) % (2**self.result_bitsize)
 
     def with_registers(self, *new_registers: Union[int, Sequence[int]]):
         raise NotImplementedError("Not needed.")
 
     def on_classical_vals(self, a: int, b: int, result: int) -> Dict[str, 'ClassicalValT']:
-        result_out = (result + a * b * ((-1) ** self.adjoint)) % (2**self.result_bitsize)
+        result_out = (result + a * b * ((-1) ** self.is_adjoint)) % (2**self.result_bitsize)
         return {'a': a, 'b': b, 'result': result_out}
 
     def _t_complexity_(self) -> 'TComplexity':
@@ -80,15 +83,15 @@ def _t_complexity_(self) -> 'TComplexity':
 
     def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         wire_symbols = ['a'] * self.a_bitsize + ['b'] * self.b_bitsize
-        wire_symbols += ['c-=a*b' if self.adjoint else 'c+=a*b'] * self.result_bitsize
+        wire_symbols += ['c-=a*b' if self.is_adjoint else 'c+=a*b'] * self.result_bitsize
         return cirq.CircuitDiagramInfo(wire_symbols=wire_symbols)
 
     def __pow__(self, power):
         if power == 1:
             return self
         if power == -1:
             return PlusEqualProduct(
-                self.a_bitsize, self.b_bitsize, self.result_bitsize, not self.adjoint
+                self.a_bitsize, self.b_bitsize, self.result_bitsize, not self.is_adjoint
             )
         raise NotImplementedError("PlusEqualProduct.__pow__ defined only for powers +1/-1.")
 

qualtran/bloqs/chemistry/trotter/grid_ham/potential.py

@@ -107,7 +107,7 @@ def build_composite_bloq(
         )
         for xyz in range(3):
             system_i[xyz], system_j[xyz] = bb.add(
-                OutOfPlaceAdder(self.bitsize, adjoint=True),
+                OutOfPlaceAdder(self.bitsize, is_adjoint=True),
                 a=system_i[xyz],
                 b=system_j[xyz],
                 c=diff_ij[xyz],