Add explicit adjoint for qubitization walk operator (#937)

Author: tanujkhattar

qualtran/bloqs/hamiltonian_simulation/hamiltonian_simulation_by_gqsp.py

@@ -177,7 +177,7 @@ def build_composite_bloq(self, bb: 'BloqBuilder', **soqs: 'SoquetT') -> Dict[str
                 bb.free(soq)
             else:
                 for soq_element in soq:
-                    bb.free(cast(Soquet, soq))
+                    bb.free(cast(Soquet, soq_element))
 
         return soqs
 

qualtran/bloqs/hamiltonian_simulation/hamiltonian_simulation_by_gqsp_test.py

@@ -95,3 +95,8 @@ def test_hamiltonian_simulation_by_gqsp(
             select_bitsize, target_bitsize, random_state=random_state
         )
         verify_hamiltonian_simulation_by_gqsp(W, H.matrix(), t=t, precision=precision)
+
+
+def test_hamiltonian_simulation_by_gqsp_t_complexity():
+    hubbard_time_evolution_by_gqsp = _hubbard_time_evolution_by_gqsp.make()
+    _ = hubbard_time_evolution_by_gqsp.t_complexity()

qualtran/bloqs/qubitization_walk_operator.py

@@ -65,6 +65,7 @@ class QubitizationWalkOperator(SpecializedSingleQubitControlledGate):
     select: SelectOracle
     prepare: PrepareOracle
     control_val: Optional[int] = None
+    uncompute: bool = False
 
     def __attrs_post_init__(self):
         assert self.select.control_registers == self.reflect.control_registers
@@ -102,10 +103,15 @@ def decompose_from_registers(
         **quregs: NDArray[cirq.Qid],  # type:ignore[type-var]
     ) -> Iterator[cirq.OP_TREE]:
         select_reg = {reg.name: quregs[reg.name] for reg in self.select.signature}
-        yield self.select.on_registers(**select_reg)
 
         reflect_reg = {reg.name: quregs[reg.name] for reg in self.reflect.signature}
-        yield self.reflect.on_registers(**reflect_reg)
+        if self.uncompute:
+            yield self.reflect.adjoint().on_registers(**reflect_reg)
+            yield self.select.adjoint().on_registers(**select_reg)
+
+        else:
+            yield self.select.on_registers(**select_reg)
+            yield self.reflect.on_registers(**reflect_reg)
 
     def get_single_qubit_controlled_bloq(self, control_val: int) -> 'QubitizationWalkOperator':
         assert self.control_val is None
@@ -122,6 +128,9 @@ def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.Circ
         wire_symbols += ['W'] * (total_bits(self.signature) - total_bits(self.control_registers))
         return cirq.CircuitDiagramInfo(wire_symbols=wire_symbols)
 
+    def adjoint(self) -> 'QubitizationWalkOperator':
+        return attrs.evolve(self, uncompute=not self.uncompute)
+
 
 @bloq_example(generalizer=[cirq_to_bloqs, ignore_split_join, ignore_cliffords])
 def _walk_op() -> QubitizationWalkOperator:

qualtran/bloqs/qubitization_walk_operator_test.py

@@ -97,6 +97,22 @@ def test_qubitization_walk_operator(num_sites: int, eps: float):
         )
 
 
+def test_qubitization_walk_operator_adjoint():
+    num_sites, eps = 4, 2e-1
+    ham = get_1d_ising_hamiltonian(cirq.LineQubit.range(num_sites))
+    walk = walk_operator_for_pauli_hamiltonian(ham, eps)
+    walk_inv_tensor = walk.adjoint().tensor_contract()
+    walk_adj_tensor = Adjoint(walk).tensor_contract()
+    np.testing.assert_allclose(walk_inv_tensor, walk_adj_tensor)
+
+
+def test_t_complexity_for_controlled_and_adjoint():
+    num_sites, eps = 4, 2e-1
+    ham = get_1d_ising_hamiltonian(cirq.LineQubit.range(num_sites))
+    walk = walk_operator_for_pauli_hamiltonian(ham, eps)
+    assert walk.controlled().adjoint().t_complexity() == walk.adjoint().controlled().t_complexity()
+
+
 def test_qubitization_walk_operator_diagrams():
     num_sites, eps = 4, 1e-1
     walk = get_walk_operator_for_1d_ising_model(num_sites, eps)