qiskit 2.0.0rc1__tar.gz → 2.0.1__tar.gz

{qiskit-2.0.0rc1 → qiskit-2.0.1}/Cargo.lock

@@ -1064,9 +1064,9 @@ dependencies = [
 
 [[package]]
 name = "numpy"
-version = "0.23.0"
+version = "0.24.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b94caae805f998a07d33af06e6a3891e38556051b8045c615470a71590e13e78"
+checksum = "a7cfbf3f0feededcaa4d289fe3079b03659e85c5b5a177f4ba6fb01ab4fb3e39"
 dependencies = [
  "libc",
  "nalgebra",
@@ -1075,6 +1075,7 @@ dependencies = [
  "num-integer",
  "num-traits",
  "pyo3",
+ "pyo3-build-config",
  "rustc-hash 2.1.1",
 ]
 
@@ -1341,9 +1342,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.23.5"
+version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7778bffd85cf38175ac1f545509665d0b9b92a198ca7941f131f85f7a4f9a872"
+checksum = "17da310086b068fbdcefbba30aeb3721d5bb9af8db4987d6735b2183ca567229"
 dependencies = [
  "cfg-if",
  "hashbrown 0.15.2",
@@ -1364,9 +1365,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.23.5"
+version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94f6cbe86ef3bf18998d9df6e0f3fc1050a8c5efa409bf712e661a4366e010fb"
+checksum = "e27165889bd793000a098bb966adc4300c312497ea25cf7a690a9f0ac5aa5fc1"
 dependencies = [
  "once_cell",
  "target-lexicon",
@@ -1374,9 +1375,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.23.5"
+version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e9f1b4c431c0bb1c8fb0a338709859eed0d030ff6daa34368d3b152a63dfdd8d"
+checksum = "05280526e1dbf6b420062f3ef228b78c0c54ba94e157f5cb724a609d0f2faabc"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -1384,9 +1385,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.23.5"
+version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fbc2201328f63c4710f68abdf653c89d8dbc2858b88c5d88b0ff38a75288a9da"
+checksum = "5c3ce5686aa4d3f63359a5100c62a127c9f15e8398e5fdeb5deef1fed5cd5f44"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -1396,9 +1397,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.23.5"
+version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fca6726ad0f3da9c9de093d6f116a93c1a38e417ed73bf138472cf4064f72028"
+checksum = "f4cf6faa0cbfb0ed08e89beb8103ae9724eb4750e3a78084ba4017cbe94f3855"
 dependencies = [
  "heck 0.5.0",
  "proc-macro2",
@@ -1409,7 +1410,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-accelerate"
-version = "2.0.0"
+version = "2.0.1"
 dependencies = [
  "ahash 0.8.11",
  "approx",
@@ -1426,7 +1427,6 @@ dependencies = [
  "num-complex",
  "num-traits",
  "numpy",
- "once_cell",
  "pulp 0.21.4",
  "pyo3",
  "qiskit-circuit",
@@ -1442,18 +1442,19 @@ dependencies = [
 
 [[package]]
 name = "qiskit-cext"
-version = "2.0.0"
+version = "2.0.1"
 dependencies = [
  "cbindgen",
  "num-complex",
  "pyo3",
+ "pyo3-build-config",
  "qiskit-accelerate",
  "thiserror 2.0.12",
 ]
 
 [[package]]
 name = "qiskit-circuit"
-version = "2.0.0"
+version = "2.0.1"
 dependencies = [
  "ahash 0.8.11",
  "approx",
@@ -1475,7 +1476,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-pyext"
-version = "2.0.0"
+version = "2.0.1"
 dependencies = [
  "pyo3",
  "qiskit-accelerate",
@@ -1487,7 +1488,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-qasm2"
-version = "2.0.0"
+version = "2.0.1"
 dependencies = [
  "hashbrown 0.15.2",
  "num-bigint",
@@ -1497,7 +1498,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-qasm3"
-version = "2.0.0"
+version = "2.0.1"
 dependencies = [
  "ahash 0.8.11",
  "hashbrown 0.15.2",
@@ -1929,9 +1930,9 @@ dependencies = [
 
 [[package]]
 name = "target-lexicon"
-version = "0.12.16"
+version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+checksum = "e502f78cdbb8ba4718f566c418c52bc729126ffd16baee5baa718cf25dd5a69a"
 
 [[package]]
 name = "tempfile"

{qiskit-2.0.0rc1 → qiskit-2.0.1}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/*"]
 resolver = "2"
 
 [workspace.package]
-version = "2.0.0"
+version = "2.0.1"
 edition = "2021"
 rust-version = "1.79"  # Keep in sync with README.md, rust-toolchain.toml, and tools/install_rust_msrv.sh
 license = "Apache-2.0"
@@ -21,7 +21,7 @@ hashbrown.version = "0.15.2"
 num-bigint = "0.4"
 num-complex = "0.4"
 nalgebra = "0.33"
-numpy = "0.23"
+numpy = "0.24"
 ndarray = "0.16"
 smallvec = "1.14"
 thiserror = "2.0"
@@ -36,7 +36,7 @@ rayon = "1.10"
 # distributions).  We only activate that feature when building the C extension module; we still need
 # it disabled for Rust-only tests to avoid linker errors with it not being loaded.  See
 # https://pyo3.rs/main/features#extension-module for more.
-pyo3 = { version = "0.23", features = ["abi3-py39"] }
+pyo3 = { version = "0.24", features = ["abi3-py39"] }
 
 # These are our own crates.
 qiskit-accelerate = { path = "crates/accelerate" }

{qiskit-2.0.0rc1 → qiskit-2.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: qiskit
-Version: 2.0.0rc1
+Version: 2.0.1
 Summary: An open-source SDK for working with quantum computers at the level of extended quantum circuits, operators, and primitives.
 Author-email: Qiskit Development Team <qiskit@us.ibm.com>
 License: Apache 2.0
@@ -51,6 +51,7 @@ Provides-Extra: csp-layout-pass
 Requires-Dist: python-constraint>=1.4; extra == "csp-layout-pass"
 Provides-Extra: all
 Requires-Dist: qiskit[crosstalk-pass,csp-layout-pass,qasm3-import,visualization]; extra == "all"
+Dynamic: license-file
 
 # Qiskit
 
@@ -121,7 +122,7 @@ from qiskit.primitives import StatevectorSampler
 sampler = StatevectorSampler()
 job = sampler.run([qc_measured], shots=1000)
 result = job.result()
-print(f" > Counts: {result[0].data["meas"].get_counts()}")
+print(f" > Counts: {result[0].data['meas'].get_counts()}")
 ```
 Running this will give an outcome similar to `{'000': 497, '111': 503}` which is `000` 50% of the time and `111` 50% of the time up to statistical fluctuations.
 To illustrate the power of the Estimator, we now use the quantum information toolbox to create the operator $XXY+XYX+YXX-YYY$ and pass it to the `run()` function, along with our quantum circuit. Note that the Estimator requires a circuit _**without**_ measurements, so we use the `qc` circuit we created earlier.

{qiskit-2.0.0rc1 → qiskit-2.0.1}/README.md

@@ -67,7 +67,7 @@ from qiskit.primitives import StatevectorSampler
 sampler = StatevectorSampler()
 job = sampler.run([qc_measured], shots=1000)
 result = job.result()
-print(f" > Counts: {result[0].data["meas"].get_counts()}")
+print(f" > Counts: {result[0].data['meas'].get_counts()}")
 ```
 Running this will give an outcome similar to `{'000': 497, '111': 503}` which is `000` 50% of the time and `111` 50% of the time up to statistical fluctuations.
 To illustrate the power of the Estimator, we now use the quantum information toolbox to create the operator $XXY+XYX+YXX-YYY$ and pass it to the `run()` function, along with our quantum circuit. Note that the Estimator requires a circuit _**without**_ measurements, so we use the `qc` circuit we created earlier.

{qiskit-2.0.0rc1 → qiskit-2.0.1}/crates/accelerate/Cargo.toml

@@ -28,7 +28,6 @@ itertools.workspace = true
 qiskit-circuit.workspace = true
 thiserror.workspace = true
 ndarray-einsum = "0.8.0"
-once_cell = "1.20.3"
 rustiq-core = "0.0.10"
 bytemuck.workspace = true
 nalgebra.workspace = true

{qiskit-2.0.0rc1 → qiskit-2.0.1}/crates/accelerate/src/basis/basis_translator/mod.rs

@@ -762,45 +762,52 @@ fn replace_node(
             )?;
         }
 
-        if let Param::ParameterExpression(old_phase) = target_dag.global_phase() {
-            let bound_old_phase = old_phase.bind(py);
-            let bind_dict = PyDict::new(py);
-            for key in target_dag.global_phase().iter_parameters(py)? {
-                let key = key?;
-                bind_dict.set_item(&key, parameter_map.get_item(&key)?)?;
-            }
-            let mut new_phase: Bound<PyAny>;
-            if bind_dict.values().iter().any(|param| {
-                param
-                    .is_instance(PARAMETER_EXPRESSION.get_bound(py))
-                    .is_ok_and(|x| x)
-            }) {
-                new_phase = bound_old_phase.clone();
-                for key_val in bind_dict.items() {
-                    new_phase =
-                        new_phase.call_method1(intern!(py, "assign"), key_val.downcast()?)?;
+        match target_dag.global_phase() {
+            Param::ParameterExpression(old_phase) => {
+                let bound_old_phase = old_phase.bind(py);
+                let bind_dict = PyDict::new(py);
+                for key in target_dag.global_phase().iter_parameters(py)? {
+                    let key = key?;
+                    bind_dict.set_item(&key, parameter_map.get_item(&key)?)?;
                 }
-            } else {
-                new_phase = bound_old_phase.call_method1(intern!(py, "bind"), (bind_dict,))?;
-            }
-            if !new_phase.getattr(intern!(py, "parameters"))?.is_truthy()? {
-                new_phase = new_phase.call_method0(intern!(py, "numeric"))?;
-                if new_phase.is_instance(&PyComplex::type_object(py))? {
-                    return Err(TranspilerError::new_err(format!(
-                        "Global phase must be real, but got {}",
-                        new_phase.repr()?
-                    )));
+                let mut new_phase: Bound<PyAny>;
+                if bind_dict.values().iter().any(|param| {
+                    param
+                        .is_instance(PARAMETER_EXPRESSION.get_bound(py))
+                        .is_ok_and(|x| x)
+                }) {
+                    new_phase = bound_old_phase.clone();
+                    for key_val in bind_dict.items() {
+                        new_phase =
+                            new_phase.call_method1(intern!(py, "assign"), key_val.downcast()?)?;
+                    }
+                } else {
+                    new_phase = bound_old_phase.call_method1(intern!(py, "bind"), (bind_dict,))?;
                 }
+                if !new_phase.getattr(intern!(py, "parameters"))?.is_truthy()? {
+                    new_phase = new_phase.call_method0(intern!(py, "numeric"))?;
+                    if new_phase.is_instance(&PyComplex::type_object(py))? {
+                        return Err(TranspilerError::new_err(format!(
+                            "Global phase must be real, but got {}",
+                            new_phase.repr()?
+                        )));
+                    }
+                }
+                let new_phase: Param = new_phase.extract()?;
+                dag.add_global_phase(py, &new_phase)?;
             }
-            let new_phase: Param = new_phase.extract()?;
-            dag.add_global_phase(py, &new_phase)?;
+
+            Param::Float(_) => {
+                dag.add_global_phase(py, target_dag.global_phase())?;
+            }
+
+            _ => {}
         }
     }
 
     Ok(())
 }
 
-#[pymodule]
 pub fn basis_translator(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(run))?;
     Ok(())

qiskit-2.0.1/crates/accelerate/src/basis/mod.rs

@@ -0,0 +1,13 @@
+// This code is part of Qiskit.
+//
+// (C) Copyright IBM 2024
+//
+// This code is licensed under the Apache License, Version 2.0. You may
+// obtain a copy of this license in the LICENSE.txt file in the root directory
+// of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+//
+// Any modifications or derivative works of this code must retain this
+// copyright notice, and modified files need to carry a notice indicating
+// that they have been altered from the originals.
+
+pub mod basis_translator;

{qiskit-2.0.0rc1 → qiskit-2.0.1}/crates/accelerate/src/circuit_library/iqp.rs

@@ -27,7 +27,7 @@ use smallvec::{smallvec, SmallVec};
 use crate::CircuitError;
 
 const PI2: f64 = PI / 2.0;
-const PI8: f64 = PI / 8.0;
+const PI4: f64 = PI / 4.0;
 
 fn iqp(
     interactions: ArrayView2<i64>,
@@ -54,7 +54,7 @@ fn iqp(
             })
     });
 
-    // The layer of T gates. Again we use the PhaseGate, now with powers of Pi/8. The powers
+    // The layer of T gates. Again we use the PhaseGate, now with powers of Pi/4. The powers
     // are given by the diagonal of the ``interactions`` matrix.
     let shifts = (0..num_qubits)
         .map(move |i| interactions[(i, i)])
@@ -63,7 +63,7 @@ fn iqp(
         .map(|(i, value)| {
             (
                 StandardGate::PhaseGate,
-                smallvec![Param::Float(PI8 * value as f64)],
+                smallvec![Param::Float(PI4 * value as f64)],
                 smallvec![Qubit(i as u32)],
             )
         });

{qiskit-2.0.0rc1 → qiskit-2.0.1}/crates/accelerate/src/commutation_checker.rs

@@ -15,7 +15,6 @@ use ndarray::linalg::kron;
 use ndarray::Array2;
 use num_complex::Complex64;
 use num_complex::ComplexFloat;
-use once_cell::sync::Lazy;
 use qiskit_circuit::bit_data::VarAsKey;
 use smallvec::SmallVec;
 use std::fmt::Debug;
@@ -33,7 +32,7 @@ use qiskit_circuit::dag_node::DAGOpNode;
 use qiskit_circuit::imports::QI_OPERATOR;
 use qiskit_circuit::operations::OperationRef::{Gate as PyGateType, Operation as PyOperationType};
 use qiskit_circuit::operations::{
-    get_standard_gate_names, Operation, OperationRef, Param, StandardGate,
+    Operation, OperationRef, Param, StandardGate, STANDARD_GATE_SIZE,
 };
 use qiskit_circuit::{BitType, Clbit, Qubit};
 
@@ -41,49 +40,61 @@ use crate::gate_metrics;
 use crate::unitary_compose;
 use crate::QiskitError;
 
-// These gates do not commute with other gates, we do not check them.
-static SKIPPED_NAMES: [&str; 4] = ["measure", "reset", "delay", "initialize"];
+const fn build_supported_ops() -> [bool; STANDARD_GATE_SIZE] {
+    let mut lut = [false; STANDARD_GATE_SIZE];
+    lut[StandardGate::RXXGate as usize] = true;
+    lut[StandardGate::RYYGate as usize] = true;
+    lut[StandardGate::RZZGate as usize] = true;
+    lut[StandardGate::RZXGate as usize] = true;
+    lut[StandardGate::HGate as usize] = true;
+    lut[StandardGate::XGate as usize] = true;
+    lut[StandardGate::YGate as usize] = true;
+    lut[StandardGate::ZGate as usize] = true;
+    lut[StandardGate::SXGate as usize] = true;
+    lut[StandardGate::SXdgGate as usize] = true;
+    lut[StandardGate::TGate as usize] = true;
+    lut[StandardGate::TdgGate as usize] = true;
+    lut[StandardGate::SGate as usize] = true;
+    lut[StandardGate::SdgGate as usize] = true;
+    lut[StandardGate::CXGate as usize] = true;
+    lut[StandardGate::CYGate as usize] = true;
+    lut[StandardGate::CZGate as usize] = true;
+    lut[StandardGate::SwapGate as usize] = true;
+    lut[StandardGate::ISwapGate as usize] = true;
+    lut[StandardGate::ECRGate as usize] = true;
+    lut[StandardGate::CCXGate as usize] = true;
+    lut[StandardGate::CSwapGate as usize] = true;
+    lut
+}
 
-// We keep a hash-set of operations eligible for commutation checking. This is because checking
-// eligibility is not for free.
-static SUPPORTED_OP: Lazy<HashSet<&str>> = Lazy::new(|| {
-    HashSet::from([
-        "rxx", "ryy", "rzz", "rzx", "h", "x", "y", "z", "sx", "sxdg", "t", "tdg", "s", "sdg", "cx",
-        "cy", "cz", "swap", "iswap", "ecr", "ccx", "cswap",
-    ])
-});
+static SUPPORTED_OP: [bool; STANDARD_GATE_SIZE] = build_supported_ops();
 
 // Map rotation gates to their generators (or to ``None`` if we cannot currently efficiently
 // represent the generator in Rust and store the commutation relation in the commutation dictionary)
 // and their pi-periodicity. Here we mean a gate is n-pi periodic, if for angles that are
 // multiples of n*pi, the gate is equal to the identity up to a global phase.
 // E.g. RX is generated by X and 2-pi periodic, while CRX is generated by CX and 4-pi periodic.
-static SUPPORTED_ROTATIONS: Lazy<HashMap<&str, Option<OperationRef>>> = Lazy::new(|| {
-    HashMap::from([
-        ("rx", Some(OperationRef::StandardGate(StandardGate::XGate))),
-        ("ry", Some(OperationRef::StandardGate(StandardGate::YGate))),
-        ("rz", Some(OperationRef::StandardGate(StandardGate::ZGate))),
-        ("p", Some(OperationRef::StandardGate(StandardGate::ZGate))),
-        ("u1", Some(OperationRef::StandardGate(StandardGate::ZGate))),
-        ("rxx", None), // None means the gate is in the commutation dictionary
-        ("ryy", None),
-        ("rzx", None),
-        ("rzz", None),
-        (
-            "crx",
-            Some(OperationRef::StandardGate(StandardGate::CXGate)),
-        ),
-        (
-            "cry",
-            Some(OperationRef::StandardGate(StandardGate::CYGate)),
-        ),
-        (
-            "crz",
-            Some(OperationRef::StandardGate(StandardGate::CZGate)),
-        ),
-        ("cp", Some(OperationRef::StandardGate(StandardGate::CZGate))),
-    ])
-});
+const fn build_supported_rotations() -> [Option<Option<StandardGate>>; STANDARD_GATE_SIZE] {
+    let mut lut = [None; STANDARD_GATE_SIZE];
+    lut[StandardGate::RXGate as usize] = Some(Some(StandardGate::XGate));
+    lut[StandardGate::RYGate as usize] = Some(Some(StandardGate::YGate));
+    lut[StandardGate::RZGate as usize] = Some(Some(StandardGate::ZGate));
+    lut[StandardGate::PhaseGate as usize] = Some(Some(StandardGate::ZGate));
+    lut[StandardGate::U1Gate as usize] = Some(Some(StandardGate::ZGate));
+    lut[StandardGate::CRXGate as usize] = Some(Some(StandardGate::CXGate));
+    lut[StandardGate::CRYGate as usize] = Some(Some(StandardGate::CYGate));
+    lut[StandardGate::CRZGate as usize] = Some(Some(StandardGate::CZGate));
+    lut[StandardGate::CPhaseGate as usize] = Some(Some(StandardGate::CZGate));
+    // RXXGate, RYYGate, RZXGate, and RZZGate are supported by the commutation dictionary
+    lut[StandardGate::RXXGate as usize] = Some(None);
+    lut[StandardGate::RYYGate as usize] = Some(None);
+    lut[StandardGate::RZXGate as usize] = Some(None);
+    lut[StandardGate::RZZGate as usize] = Some(None);
+    lut
+}
+
+static SUPPORTED_ROTATIONS: [Option<Option<StandardGate>>; STANDARD_GATE_SIZE] =
+    build_supported_rotations();
 
 fn get_bits<T>(bits1: &Bound<PyTuple>, bits2: &Bound<PyTuple>) -> PyResult<(Vec<T>, Vec<T>)>
 where
@@ -132,8 +143,6 @@ impl CommutationChecker {
         gates: Option<HashSet<String>>,
     ) -> Self {
         // Initialize sets before they are used in the commutation checker
-        Lazy::force(&SUPPORTED_OP);
-        Lazy::force(&SUPPORTED_ROTATIONS);
         CommutationChecker {
             library: CommutationLibrary::new(standard_gate_commutations),
             cache: HashMap::new(),
@@ -287,14 +296,24 @@ impl CommutationChecker {
 
         // if we have rotation gates, we attempt to map them to their generators, for example
         // RX -> X or CPhase -> CZ
-        let (op1, params1, trivial1) = map_rotation(op1, params1, tol);
+        let (op1_gate, params1, trivial1) = map_rotation(op1, params1, tol);
         if trivial1 {
             return Ok(true);
         }
-        let (op2, params2, trivial2) = map_rotation(op2, params2, tol);
+        let op1 = if let Some(gate) = op1_gate {
+            &OperationRef::StandardGate(gate)
+        } else {
+            op1
+        };
+        let (op2_gate, params2, trivial2) = map_rotation(op2, params2, tol);
         if trivial2 {
             return Ok(true);
         }
+        let op2 = if let Some(gate) = op2_gate {
+            &OperationRef::StandardGate(gate)
+        } else {
+            op2
+        };
 
         if let Some(gates) = &self.gates {
             if !gates.is_empty() && (!gates.contains(op1.name()) || !gates.contains(op2.name())) {
@@ -339,14 +358,15 @@ impl CommutationChecker {
         // the cache for
         //  * gates we know are in the cache (SUPPORTED_OPS), or
         //  * standard gates with float params (otherwise we cannot cache them)
-        let standard_gates = get_standard_gate_names();
-        let is_cachable = |name: &str, params: &[Param]| {
-            SUPPORTED_OP.contains(name)
-                || (standard_gates.contains(&name)
-                    && params.iter().all(|p| matches!(p, Param::Float(_))))
+        let is_cachable = |op: &OperationRef, params: &[Param]| {
+            if let Some(gate) = op.standard_gate() {
+                SUPPORTED_OP[gate as usize] || params.iter().all(|p| matches!(p, Param::Float(_)))
+            } else {
+                false
+            }
         };
-        let check_cache = is_cachable(first_op.name(), first_params)
-            && is_cachable(second_op.name(), second_params);
+        let check_cache =
+            is_cachable(first_op, first_params) && is_cachable(second_op, second_params);
 
         if !check_cache {
             return self.commute_matmul(
@@ -544,11 +564,25 @@ fn commutation_precheck(
         return Some(false);
     }
 
-    if SUPPORTED_OP.contains(op1.name()) && SUPPORTED_OP.contains(op2.name()) {
-        return None;
+    if let Some(gate_1) = op1.standard_gate() {
+        if let Some(gate_2) = op2.standard_gate() {
+            if SUPPORTED_OP[gate_1 as usize] && SUPPORTED_OP[gate_2 as usize] {
+                return None;
+            }
+        }
+    }
+
+    if matches!(
+        op1,
+        OperationRef::StandardInstruction(_) | OperationRef::Instruction(_)
+    ) || matches!(
+        op2,
+        OperationRef::StandardInstruction(_) | OperationRef::Instruction(_)
+    ) {
+        return Some(false);
     }
 
-    if is_commutation_skipped(op1, params1) || is_commutation_skipped(op2, params2) {
+    if is_parameterized(params1) || is_parameterized(params2) {
         return Some(false);
     }
 
@@ -580,15 +614,10 @@ fn matrix_via_operator(py: Python, py_obj: &PyObject) -> PyResult<Array2<Complex
         .to_owned())
 }
 
-fn is_commutation_skipped<T>(op: &T, params: &[Param]) -> bool
-where
-    T: Operation,
-{
-    op.directive()
-        || SKIPPED_NAMES.contains(&op.name())
-        || params
-            .iter()
-            .any(|x| matches!(x, Param::ParameterExpression(_)))
+fn is_parameterized(params: &[Param]) -> bool {
+    params
+        .iter()
+        .any(|x| matches!(x, Param::ParameterExpression(_)))
 }
 
 /// Check if a given operation can be mapped onto a generator.
@@ -604,36 +633,33 @@ fn map_rotation<'a>(
     op: &'a OperationRef<'a>,
     params: &'a [Param],
     tol: f64,
-) -> (&'a OperationRef<'a>, &'a [Param], bool) {
-    let name = op.name();
-
-    if let Some(generator) = SUPPORTED_ROTATIONS.get(name) {
-        // If the rotation angle is below the tolerance, the gate is assumed to
-        // commute with everything, and we simply return the operation with the flag that
-        // it commutes trivially.
-        if let Param::Float(angle) = params[0] {
-            let gate = op
-                .standard_gate()
-                .expect("Supported gates are standard gates");
-            let (tr_over_dim, dim) = gate_metrics::rotation_trace_and_dim(gate, angle)
-                .expect("All rotation should be covered at this point");
-            let gate_fidelity = tr_over_dim.abs().powi(2);
-            let process_fidelity = (dim * gate_fidelity + 1.) / (dim + 1.);
-            if (1. - process_fidelity).abs() <= tol {
-                return (op, params, true);
+) -> (Option<StandardGate>, &'a [Param], bool) {
+    if let Some(gate) = op.standard_gate() {
+        if let Some(generator) = SUPPORTED_ROTATIONS[gate as usize] {
+            // If the rotation angle is below the tolerance, the gate is assumed to
+            // commute with everything, and we simply return the operation with the flag that
+            // it commutes trivially.
+            if let Param::Float(angle) = params[0] {
+                let (tr_over_dim, dim) = gate_metrics::rotation_trace_and_dim(gate, angle)
+                    .expect("All rotation should be covered at this point");
+                let gate_fidelity = tr_over_dim.abs().powi(2);
+                let process_fidelity = (dim * gate_fidelity + 1.) / (dim + 1.);
+                if (1. - process_fidelity).abs() <= tol {
+                    return (Some(gate), params, true);
+                };
             };
-        };
 
-        // Otherwise we need to cover two cases -- either a generator is given, in which case
-        // we return it, or we don't have a generator yet, but we know we have the operation
-        // stored in the commutation library. For example, RXX does not have a generator in Rust
-        // yet (PauliGate is not in Rust currently), but it is stored in the library, so we
-        // can strip the parameters and just return the gate.
-        if let Some(gate) = generator {
-            return (gate, &[], false);
-        };
+            // Otherwise we need to cover two cases -- either a generator is given, in which case
+            // we return it, or we don't have a generator yet, but we know we have the operation
+            // stored in the commutation library. For example, RXX does not have a generator in Rust
+            // yet (PauliGate is not in Rust currently), but it is stored in the library, so we
+            // can strip the parameters and just return the gate.
+            if let Some(gate) = generator {
+                return (Some(gate), &[], false);
+            };
+        }
     }
-    (op, params, false)
+    (None, params, false)
 }
 
 fn get_relative_placement(

{qiskit-2.0.0rc1 → qiskit-2.0.1}/crates/accelerate/src/equivalence.rs

@@ -817,7 +817,6 @@ where
     Ok(graph.unbind())
 }
 
-#[pymodule]
 pub fn equivalence(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<EquivalenceLibrary>()?;
     m.add_class::<NodeData>()?;

{qiskit-2.0.0rc1 → qiskit-2.0.1}/crates/accelerate/src/gate_direction.rs

@@ -582,7 +582,6 @@ fn rzx_replacement_dag(py: Python, param: &[Param]) -> PyResult<DAGCircuit> {
     Ok(new_dag.clone())
 }
 
-#[pymodule]
 pub fn gate_direction(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(py_check_direction_coupling_map))?;
     m.add_wrapped(wrap_pyfunction!(py_check_direction_target))?;