Merge branch 'main' into random-cliff-array-sort

Author: amruthpremjith

crates/transpiler/src/passes/commutative_optimization.rs

@@ -69,7 +69,7 @@ fn compare_params(params1: &[Param], params2: &[Param]) -> PyResult<bool> {
 
 /// List of symmetric gates, that is the gate remains the same under all
 /// permutations of its arguments.
-static SYMMETRIC_GATES: [StandardGate; 13] = [
+static SYMMETRIC_GATES: [StandardGate; 12] = [
     StandardGate::CZ,
     StandardGate::Swap,
     StandardGate::ISwap,
@@ -81,7 +81,6 @@ static SYMMETRIC_GATES: [StandardGate; 13] = [
     StandardGate::RYY,
     StandardGate::RZZ,
     StandardGate::XXMinusYY,
-    StandardGate::XXPlusYY,
     StandardGate::CCZ,
 ];
 
@@ -103,6 +102,35 @@ static MERGEABLE_ROTATION_GATES: [StandardGate; 12] = [
     StandardGate::CU1,
 ];
 
+/// Check if `inst` is symmetric for some special values of its parameters,
+/// taking tolerance into account.
+fn is_special_symmetric(inst: &PackedInstruction, tol: f64) -> bool {
+    // For now, this only handles the standard XXPlusYY gate.
+    if let OperationRef::StandardGate(StandardGate::XXPlusYY) = inst.op.view() {
+        // From the matrix representation, applying XXPlusYY(theta, beta) on reversed qubits [q2, q1]
+        // is the same as applying XXPlusYY(theta, -beta) on [q1, q2].
+        // The direct computation for the average gate fidelity between XXPlusYY(theta, beta) and
+        // XXPlusYY(theta, -beta) gives the following: 1/5 + 4/5 [1-sin^(theta/2) sin^2(beta)]^2.
+        match inst.params_view() {
+            [Param::Float(theta), Param::Float(beta)] => {
+                // If both theta and beta are floating-point, we can evaluate the above condition
+                // directly.
+                let x = (1.0 - (theta / 2.0).sin().powf(2.0) * beta.sin().powf(2.0)).powf(2.0);
+                return x > 1.0 - 5. / 4. * tol;
+            }
+            [Param::ParameterExpression(_theta), Param::Float(beta)] => {
+                // If theta is parametric, we take the estimate that works for all theta.
+                let x = (1.0 - beta.sin().powf(2.0)).powf(2.0);
+                return x > 1.0 - 5. / 4. * tol;
+            }
+            _ => {
+                return false;
+            }
+        }
+    }
+    false
+}
+
 /// Computes the canonical representative of a packed instruction, and in particular:
 /// * replaces all types of Z-rotations by RZ-gates,
 /// * replaces all types of X-rotations by RX-gates,
@@ -114,6 +142,8 @@ static MERGEABLE_ROTATION_GATES: [StandardGate; 12] = [
 /// * `dag` - The output [DAGCircuit]. We use its `qargs_interner` to store sorted
 ///   qubits for symmetric gates.
 /// * `inst` - The instruction to canonicalize.
+/// * `tol` - The tolerance used for fidelity computations (for instance, checking
+///   whether a gate is symmetric within the specified tolerance).
 ///
 /// # Returns:
 ///
@@ -122,6 +152,7 @@ static MERGEABLE_ROTATION_GATES: [StandardGate; 12] = [
 fn canonicalize(
     dag: &mut DAGCircuit,
     inst: &PackedInstruction,
+    tol: f64,
 ) -> Option<(PackedInstruction, Param)> {
     // ToDo: possibly consider other rotations as well (e.g. CS -> CRZ).
     let rotation = match inst.op.view() {
@@ -179,7 +210,7 @@ fn canonicalize(
     }
 
     if let OperationRef::StandardGate(standard_gate) = inst.op.view() {
-        if SYMMETRIC_GATES.contains(&standard_gate) {
+        if SYMMETRIC_GATES.contains(&standard_gate) || is_special_symmetric(inst, tol) {
             let qargs = dag.get_qargs(inst.qubits);
             if !qargs.is_sorted() {
                 let mut sorted_qargs = qargs.to_vec();
@@ -604,7 +635,7 @@ pub fn run_commutative_optimization(
             continue;
         }
 
-        if let Some((new_instruction, phase_update)) = canonicalize(&mut new_dag, instr1) {
+        if let Some((new_instruction, phase_update)) = canonicalize(&mut new_dag, instr1, tol) {
             node_actions[idx1] = NodeAction::Canonical(new_instruction, phase_update);
         }
 

qiskit/circuit/library/generalized_gates/linear_function.py

@@ -19,7 +19,6 @@
 from qiskit.circuit.library.generalized_gates.permutation import PermutationGate
 from qiskit.utils.deprecation import deprecate_func
 
-
 from qiskit.quantum_info import Clifford
 
 
@@ -150,6 +149,19 @@ def __init__(
             name="linear_function", num_qubits=len(linear), params=[linear, original_circuit]
         )
 
+    def inverse(self, annotated: bool = False) -> LinearFunction:
+        """Returns the inverse of this linear function.
+
+        Args:
+            annotated: when set to ``True``, this is typically used to return an
+                :class:`.AnnotatedOperation` with an inverse modifier set instead of a concrete
+                :class:`.Gate`. However, for this class this argument is ignored as the inverse
+                of this gate is always a :class:`.LinearFunction`.
+        """
+        from qiskit.synthesis.linear import calc_inverse_matrix
+
+        return LinearFunction(linear=calc_inverse_matrix(self.linear))
+
     @staticmethod
     def _circuit_to_mat(qc: QuantumCircuit):
         """This creates a nxn matrix corresponding to the given quantum circuit."""

releasenotes/notes/add-linear-function-inverse-0a0db84d48ac1195.yaml

@@ -0,0 +1,11 @@
+---
+fixes:
+  - |
+    Previously, calling ``inverse`` on a :class:`.LinearFunction` raised an error;
+    this is no longer the case.
+    See `#16184 <https://github.com/Qiskit/qiskit/issues/16184>`__.
+
+features_circuits:
+  - |
+    Added a :meth:`.LinearFunction.inverse` method that returns a 
+    :class:`.LinearFunction` representing the inverse transformation.

releasenotes/notes/fix-xxplusyy-in-comm-opt-7a3bc47797ac2990.yaml

@@ -0,0 +1,13 @@
+---
+fixes:
+  - |
+    Fixed a bug in the :class:`.CommutativeOptimization` transpiler pass
+    where pairs of :class:`.XXPlusYYGate` gates acting on the same qubits
+    but in reversed order were incorrectly simplified. However, the
+    simplification is performed in special cases where the gate and its
+    reversed versions are inverse within the specified tolerance, for
+    instance when the argument `beta` is a multiple of `pi`.
+
+    See `#16161 <https://github.com/Qiskit/qiskit/issues/16161>`__.
+
+

test/python/circuit/library/test_linear_function.py

@@ -515,6 +515,16 @@ def test_repeat_method(self, num_qubits):
             linear_function = LinearFunction(linear_circuit)
             self.assertTrue(Operator(linear_function.repeat(2)), operator @ operator)
 
+    def test_inverse(self):
+        """Test correctness of the ``inverse`` method."""
+        mat = [[1, 0, 0], [1, 1, 0], [1, 1, 1]]
+        inverse_mat = [[1, 0, 0], [1, 1, 0], [0, 1, 1]]
+
+        linear_function = LinearFunction(mat)
+        inverse_linear_function = linear_function.inverse()
+        expected_inverse_linear_function = LinearFunction(inverse_mat)
+        self.assertTrue(np.array_equal(inverse_linear_function, expected_inverse_linear_function))
+
 
 if __name__ == "__main__":
     unittest.main()

test/python/transpiler/test_commutative_optimization.py

@@ -167,8 +167,9 @@ def test_consecutive_cancellations(self):
         RXXGate(0.4),
         RYYGate(0.4),
         RZZGate(0.4),
-        XXMinusYYGate(0.4),
-        XXPlusYYGate(0.4),
+        XXPlusYYGate(0.4, 0.0),
+        XXPlusYYGate(0.4, np.pi),
+        XXMinusYYGate(0.4, 0.2),
     )
     def test_symmetric_gates_cancel(self, symmetric_gate):
         """Test that various symmetric gates cancel."""
@@ -183,6 +184,26 @@ def test_symmetric_gates_cancel(self, symmetric_gate):
         self.assertEqual(Operator(expected), Operator(qc))
         self.assertEqual(qct, expected)
 
+    def test_nonsymmetric_gates_do_not_canel(self):
+        """Test that non-symmetric gates do not cancel."""
+        qc = QuantumCircuit(2)
+        qc.append(XXPlusYYGate(0.4, 0.2), [0, 1])
+        qc.append(XXPlusYYGate(0.4, 0.2).inverse(), [1, 0])  # note reversed order of qubits
+
+        qct = CommutativeOptimization()(qc)
+
+        self.assertEqual(qct, qc)
+
+    def test_symmetric_xxplusyy_gates_cancel(self):
+        """Test for cancellation XXPlusYY gates with parametric values of theta."""
+        symmetric_gate = XXPlusYYGate(Parameter("t"), np.pi)
+        qc = QuantumCircuit(2)
+        qc.append(symmetric_gate, [0, 1])
+        qc.append(symmetric_gate.inverse(), [1, 0])  # note reversed order of qubits
+        qct = CommutativeOptimization()(qc)
+        expected = QuantumCircuit(2)
+        self.assertEqual(qct, expected)
+
     def test_symmetric_iswap_gates_cancel(self):
         """Test that iSwap gates cancel."""
         # iSwap is handled separately as its inverse is not a standard gate