Improved adjoint Select implementation (#2729)

This check-in improves implementation of adjoin variant of Select
operation (Unlookup operation). Previously it was based on May [2019
paper by Craig Gidney](https://arxiv.org/abs/1905.07682), and this
proposed implementation is based on [2025 paper by Craig
Gidney](https://arxiv.org/abs/2505.15917).

The implementation of Unlookup is measurement-based with phase
correction via Phase Lookup operation described in the aforementioned
paper. Phase Lookup is implemented by splitting address register and
computing power products for both halves. Then the necessary phase
corrections are applied and power products are uncomputed.

This implementation uses fast Boolean Mobius transform instead of matrix
multiplication as in the paper to convert classical data from truth
table representation to coefficients of an algebraic normal form over
GF(2) field. This results in simpler code.

A test is added to check that address register remains in correct state
after uncomputation.

This implementation may reduce required resources to uncompute lookup
operation. As one example, the circuit to uncompute **one particular
case** with previous and proposed approaches. This is a highly dynamic
algorithm that uses results of measurements to apply gates
conditionally; actual execution trace and actual savings may vary.

Before:
<img width="1456" height="476" alt="Unlookup"
src="https://github.com/user-attachments/assets/0e2a28f0-0298-4ef8-be51-fc02ccd85b02"
/>
After:
<img width="822" height="640" alt="Phaseup"
src="https://github.com/user-attachments/assets/96305720-ae1f-4dad-bc40-dcd990bcb125"
/>

---------

Co-authored-by: Dmitry Vasilevsky <[email protected]>

Author: DmitryVasilevsky

library/src/tests/resources/src/select.qs

@@ -28,6 +28,38 @@ namespace Test {
         }
     }
 
+    internal operation TestSelectPhase() : Unit {
+        use addressRegister = Qubit[3];
+        use targetRegister = Qubit[4];
+
+        // Could be random, but fixed for reproducibility
+        let data = [
+            [false, false, false, false],
+            [false, false, true, false],
+            [true, true, false, false],
+            [false, true, false, false],
+            [true, true, true, true],
+            [true, false, false, false],
+            [true, true, true, false],
+            [true, false, true, false],
+        ];
+
+        // Select followed by unselect. This should be equivalent to identity.
+        let selunsel = (addr) => {
+            within {
+                Select(data, addr, targetRegister);
+            } apply {
+                // Do nothing.
+            }
+        };
+
+        // This test checks that the implementation of unselect
+        // doesn't change address register phases and returns target register to |0⟩ state.
+        let equal = CheckOperationsAreEqual(3, selunsel, (addr) => {});
+        Fact(CheckAllZero(targetRegister), "Target register must be in |0⟩ state after unlookup.");
+        Fact(equal, "Select+Unselect should be equivalent to identity up to global phase.");
+    }
+
     internal operation TestSelectFuzz(rounds : Int) : Unit {
         for _ in 1..rounds {
             let addressBits = DrawRandomInt(2, 6);

library/src/tests/table_lookup.rs

@@ -61,3 +61,12 @@ fn check_select_fuzz() {
         &Value::Tuple(vec![].into(), None),
     );
 }
+
+#[test]
+fn check_select_phase() {
+    test_expression_with_lib(
+        "Test.TestSelectPhase()",
+        SELECT_TEST_LIB,
+        &Value::Tuple(vec![].into(), None),
+    );
+}