Fix a bug in Target::py_instruction_supported and remove the py token parameter (Qiskit#14765)

* Remove py token argument from py_instruction_supported

This commit removes the py token from py_instruction_supported.
 `python::with_gil` is still used when the function is called with `operation_class`
or with `operation_name` and `parameters`.

Also fixed a bug where qargs checking was skipped when the
function was called with an operation name and a parameters list
that matched an existing instruction, even if the order of qargs differed.

* Address review comments

Author: eliarbel

crates/transpiler/src/passes/gate_direction.rs

@@ -210,7 +210,6 @@ pub fn fix_direction_target(
                 StandardGate::RXX | StandardGate::RYY | StandardGate::RZZ | StandardGate::RZX => {
                     return target
                         .py_instruction_supported(
-                            py,
                             None,
                             qargs.into(),
                             Some(

crates/transpiler/src/target/mod.rs

@@ -522,7 +522,6 @@ impl Target {
     )]
     pub fn py_instruction_supported(
         &self,
-        py: Python,
         operation_name: Option<String>,
         qargs: Qargs,
         operation_class: Option<&Bound<PyAny>>,
@@ -552,6 +551,7 @@ impl Target {
                         }
                     }
                     TargetOperation::Normal(normal) => {
+                        let py = _operation_class.py();
                         if normal.into_pyobject(py)?.is_instance(_operation_class)? {
                             if let Some(parameters) = &parameters {
                                 if parameters.len() != normal.params.len() {
@@ -610,19 +610,21 @@ impl Target {
                     if parameters.len() != obj_params.len() {
                         return Ok(false);
                     }
+
                     for (index, params) in parameters.iter().enumerate() {
-                        let mut matching_params = false;
                         let obj_at_index = &obj_params[index];
-                        if matches!(obj_at_index, Param::ParameterExpression(_))
-                            || python_compare(py, params, &obj_params[index])?
-                        {
-                            matching_params = true;
-                        }
+                        let matching_params = match (obj_at_index, params) {
+                            (Param::Float(obj_f), Param::Float(param_f)) => obj_f == param_f,
+                            (Param::ParameterExpression(_), _) => true,
+                            _ => Python::with_gil(|py| {
+                                python_compare(py, params, &obj_params[index])
+                            })?,
+                        };
+
                         if !matching_params {
                             return Ok(false);
                         }
                     }
-                    return Ok(true);
                 }
             }
             Ok(self.instruction_supported(&operation_name, &qargs))

releasenotes/notes/fix-instruction-supported-qargs-3e7b03210fa23a65.yaml

@@ -0,0 +1,6 @@
+---
+fixes:
+  - |
+    Fixed a bug in :meth:`.Target.instruction_supported` where the check of instruction's qubit order
+    was skipped when the method was called with ``operation_name`` and ``parameters`` arguments
+    that matched an existing instruction.

test/python/transpiler/test_target.py

@@ -1090,6 +1090,9 @@ def test_instruction_supported_parameters(self):
         self.assertTrue(
             mumbai.target.instruction_supported("rzx_45", qargs=(0, 1), parameters=[math.pi / 4])
         )
+        self.assertFalse(
+            mumbai.target.instruction_supported("rzx_45", qargs=(1, 0), parameters=[math.pi / 4])
+        )
         self.assertTrue(mumbai.target.instruction_supported("rzx_45", qargs=(0, 1)))
         self.assertTrue(mumbai.target.instruction_supported("rzx_45", parameters=[math.pi / 4]))
         self.assertFalse(mumbai.target.instruction_supported("rzx_45", parameters=[math.pi / 6]))