qiskit 2.0.0rc1__tar.gz → 2.0.0rc2__tar.gz

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

@@ -1426,7 +1426,6 @@ dependencies = [
  "num-complex",
  "num-traits",
  "numpy",
- "once_cell",
  "pulp 0.21.4",
  "pyo3",
  "qiskit-circuit",

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: qiskit
-Version: 2.0.0rc1
+Version: 2.0.0rc2
 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

{qiskit-2.0.0rc1 → qiskit-2.0.0rc2}/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.0rc2}/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.0rc2}/crates/accelerate/src/unitary_synthesis.rs

@@ -598,7 +598,44 @@ fn get_2q_decomposers_from_target(
     // If there are available 2q gates, start search for decomposers:
     let mut decomposers: Vec<DecomposerElement> = Vec::new();
 
-    // Step 1: Try TwoQubitBasisDecomposers
+    // Step 1: Try TwoQubitControlledUDecomposers
+    for basis_1q in &available_1q_basis {
+        for (_, (gate, _)) in available_2q_param_basis.iter() {
+            let rxx_equivalent_gate = if let Some(std_gate) = gate.operation.try_standard_gate() {
+                RXXEquivalent::Standard(std_gate)
+            } else {
+                let module = PyModule::import(py, "builtins")?;
+                let py_type = module.getattr("type")?;
+                let gate_type = py_type
+                    .call1((gate.clone().into_pyobject(py)?,))?
+                    .downcast_into::<PyType>()?
+                    .unbind();
+
+                RXXEquivalent::CustomPython(gate_type)
+            };
+
+            match TwoQubitControlledUDecomposer::new_inner(rxx_equivalent_gate, basis_1q) {
+                Ok(decomposer) => {
+                    decomposers.push(DecomposerElement {
+                        decomposer: DecomposerType::TwoQubitControlledU(Box::new(decomposer)),
+                        packed_op: gate.operation.clone(),
+                        params: gate.params.clone(),
+                    });
+                }
+                Err(_) => continue,
+            };
+        }
+    }
+    // If the 2q basis gates are a subset of PARAM_SET, exit here
+    if available_2q_param_basis
+        .keys()
+        .all(|gate| PARAM_SET.contains(gate))
+        && !available_2q_param_basis.is_empty()
+    {
+        return Ok(Some(decomposers));
+    }
+
+    // Step 2: Try TwoQubitBasisDecomposers
     #[inline]
     fn is_supercontrolled(op: &NormalOperation) -> bool {
         match op.operation.matrix(&op.params) {
@@ -648,43 +685,6 @@ fn get_2q_decomposers_from_target(
         return Ok(Some(decomposers));
     }
 
-    // Step 2: Try TwoQubitControlledUDecomposers
-    for basis_1q in &available_1q_basis {
-        for (_, (gate, _)) in available_2q_param_basis.iter() {
-            let rxx_equivalent_gate = if let Some(std_gate) = gate.operation.try_standard_gate() {
-                RXXEquivalent::Standard(std_gate)
-            } else {
-                let module = PyModule::import(py, "builtins")?;
-                let py_type = module.getattr("type")?;
-                let gate_type = py_type
-                    .call1((gate.clone().into_pyobject(py)?,))?
-                    .downcast_into::<PyType>()?
-                    .unbind();
-
-                RXXEquivalent::CustomPython(gate_type)
-            };
-
-            match TwoQubitControlledUDecomposer::new_inner(rxx_equivalent_gate, basis_1q) {
-                Ok(decomposer) => {
-                    decomposers.push(DecomposerElement {
-                        decomposer: DecomposerType::TwoQubitControlledU(Box::new(decomposer)),
-                        packed_op: gate.operation.clone(),
-                        params: gate.params.clone(),
-                    });
-                }
-                Err(_) => continue,
-            };
-        }
-    }
-    // If the 2q basis gates are a subset of PARAM_SET, exit here
-    if available_2q_param_basis
-        .keys()
-        .all(|gate| PARAM_SET.contains(gate))
-        && !available_2q_param_basis.is_empty()
-    {
-        return Ok(Some(decomposers));
-    }
-
     // Step 3: Try XXDecomposers (Python)
     #[inline]
     fn is_controlled(op: &NormalOperation) -> bool {

{qiskit-2.0.0rc1 → qiskit-2.0.0rc2}/crates/cext/Cargo.toml

@@ -8,7 +8,7 @@ license.workspace = true
 [lib]
 name = "qiskit_cext"
 doctest = false
-crate-type = ["cdylib", "rlib"]
+crate-type = ["rlib"]
 
 [lints]
 workspace = true

{qiskit-2.0.0rc1 → qiskit-2.0.0rc2}/crates/cext/README.md

@@ -15,6 +15,11 @@ Similarly, the `libqiskit` shared library is stored in `dist/c/lib`.
 
 You can ask Make to build only the header file with `make cheader`, or only the
 shared-object library with `make clib`.
+Instead of ``make clib`` the shared C library can also be compiled via
+```bash
+cargo rustc --release --crate-type cdylib -p qiskit-cext
+```
+note that the `crate-type` should be defined explicitly to build the `cdylib` instead of the `rlib` default.
 
 The following example uses the header to build a 100-qubit observable:
 ```c
@@ -51,14 +56,12 @@ Refer to the C API documentation for more information and examples.
 
 The above program can be compiled by including the header and linking to the `qiskit` library, which
 are located in the standard directory configuration whose root is `dist/c`.
-
 ```bash
 make c
-QISKIT_ROOT=/path/to/qiskit/dist/c
-gcc -I$QISKIT_ROOT/include program.c -lqiskit -L$QISKIT_ROOT/lib
+gcc program.c -I$/path/to/dist/c/include -lqiskit -L/path/to/dist/c/lib
 ```
 
-For which the example program will output
+The example program will then output
 ```bash
 ./a.out
 ```

{qiskit-2.0.0rc1 → qiskit-2.0.0rc2}/crates/circuit/src/dag_circuit.rs

@@ -34,6 +34,7 @@ use crate::operations::{ArrayType, Operation, OperationRef, Param, PyInstruction
 use crate::packed_instruction::{PackedInstruction, PackedOperation};
 use crate::register_data::RegisterData;
 use crate::rustworkx_core_vnext::isomorphism;
+use crate::slice::PySequenceIndex;
 use crate::{BitType, Clbit, Qubit, TupleLikeArg};
 
 use hashbrown::{HashMap, HashSet};
@@ -343,7 +344,7 @@ fn reject_new_register(reg: &Bound<PyAny>) -> PyResult<()> {
     )))
 }
 
-#[pyclass(name = "BitLocations", module = "qiskit._accelerate.circuit")]
+#[pyclass(name = "BitLocations", module = "qiskit._accelerate.circuit", sequence)]
 #[derive(Clone, Debug)]
 pub struct PyBitLocations {
     #[pyo3(get)]
@@ -392,6 +393,30 @@ impl PyBitLocations {
     fn __getnewargs__(slf: Bound<Self>) -> PyResult<(Bound<PyAny>, Bound<PyAny>)> {
         Ok((slf.getattr("index")?, slf.getattr("registers")?))
     }
+
+    fn __getitem__(&self, py: Python, index: PySequenceIndex<'_>) -> PyResult<PyObject> {
+        let getter = |index: usize| -> PyResult<PyObject> {
+            match index {
+                0 => self.index.into_py_any(py),
+                1 => Ok(self.registers.clone_ref(py).into_any()),
+                _ => Err(PyIndexError::new_err("index out of range")),
+            }
+        };
+        if let Ok(index) = index.with_len(2) {
+            match index {
+                crate::slice::SequenceIndex::Int(index) => getter(index),
+                _ => PyTuple::new(py, index.iter().map(|idx| getter(idx).unwrap()))
+                    .map(|obj| obj.into_any().unbind()),
+            }
+        } else {
+            Err(PyIndexError::new_err("index out of range"))
+        }
+    }
+
+    #[staticmethod]
+    fn __len__() -> usize {
+        2
+    }
 }
 
 #[derive(Copy, Clone, Debug)]
@@ -832,6 +857,26 @@ impl DAGCircuit {
             }
         }
         self.dag.remove_node(tmp_node);
+        self.qubit_locations = BitLocator::with_capacity(self.qubits.len());
+        for (index, qubit) in self.qubits.bits().iter().enumerate() {
+            let registers = self
+                .qregs
+                .registers()
+                .iter()
+                .filter_map(|x| x.index_of(qubit).map(|y| (x.clone(), y)));
+            self.qubit_locations
+                .insert(qubit.clone(), BitLocations::new(index as u32, registers));
+        }
+        self.clbit_locations = BitLocator::with_capacity(self.clbits.len());
+        for (index, clbit) in self.clbits.bits().iter().enumerate() {
+            let registers = self
+                .cregs
+                .registers()
+                .iter()
+                .filter_map(|x| x.index_of(clbit).map(|y| (x.clone(), y)));
+            self.clbit_locations
+                .insert(clbit.clone(), BitLocations::new(index as u32, registers));
+        }
         Ok(())
     }
 

qiskit-2.0.0rc2/qiskit/VERSION.txt

@@ -0,0 +1 @@
+2.0.0rc2

{qiskit-2.0.0rc1 → qiskit-2.0.0rc2}/qiskit/circuit/library/standard_gates/r.py

@@ -79,7 +79,7 @@ class RGate(Gate):
         self.definition = qc
 
     def inverse(self, annotated: bool = False):
-        """Invert this gate as: :math:`r(θ, φ)^dagger = r(-θ, φ)`
+        r"""Invert this gate as: :math:`R(θ, φ)^{\dagger} = R(-θ, φ)`
 
         Args:
             annotated: when set to ``True``, this is typically used to return an

{qiskit-2.0.0rc1 → qiskit-2.0.0rc2}/qiskit/circuit/parameterexpression.py

@@ -26,6 +26,7 @@ import numpy
 import symengine
 
 from qiskit.circuit.exceptions import CircuitError
+from qiskit.exceptions import QiskitError
 from qiskit.utils.optionals import HAS_SYMPY
 
 # This type is redefined at the bottom to insert the full reference to "ParameterExpression", so it
@@ -531,6 +532,9 @@ class ParameterExpression:
     def __str__(self):
         from sympy import sympify, sstr
 
+        if not isinstance(self._symbol_expr, symengine.Basic):
+            raise QiskitError("Invalid ParameterExpression")
+
         return sstr(sympify(self._symbol_expr), full_prec=False)
 
     def __complex__(self):
@@ -611,6 +615,9 @@ class ParameterExpression:
                 return False
             from sympy import sympify
 
+            if not isinstance(self._symbol_expr, symengine.Basic):
+                raise QiskitError("Invalid ParameterExpression")
+
             return sympify(self._symbol_expr).equals(sympify(other._symbol_expr))
         elif isinstance(other, numbers.Number):
             return len(self.parameters) == 0 and complex(self._symbol_expr) == other

{qiskit-2.0.0rc1 → qiskit-2.0.0rc2}/qiskit/circuit/tools/pi_check.py

@@ -49,7 +49,10 @@ def pi_check(inpt, eps=1e-9, output="text", ndigits=None):
     if isinstance(inpt, ParameterExpression):
         param_str = str(inpt)
         from sympy import sympify
+        import symengine
 
+        if not isinstance(inpt._symbol_expr, symengine.Basic):
+            raise QiskitError("Invalid ParameterExpression provided")
         expr = sympify(inpt._symbol_expr)
         syms = expr.atoms()
         for sym in syms: