qiskit 1.4.1__tar.gz → 1.4.3__tar.gz

{qiskit-1.4.1 → qiskit-1.4.3}/Cargo.lock

@@ -1150,7 +1150,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-accelerate"
-version = "1.4.1"
+version = "1.4.3"
 dependencies = [
  "ahash 0.8.11",
  "approx 0.5.1",
@@ -1182,7 +1182,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-circuit"
-version = "1.4.1"
+version = "1.4.3"
 dependencies = [
  "ahash 0.8.11",
  "approx 0.5.1",
@@ -1202,7 +1202,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-pyext"
-version = "1.4.1"
+version = "1.4.3"
 dependencies = [
  "pyo3",
  "qiskit-accelerate",
@@ -1213,7 +1213,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-qasm2"
-version = "1.4.1"
+version = "1.4.3"
 dependencies = [
  "hashbrown 0.14.5",
  "num-bigint",
@@ -1223,7 +1223,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-qasm3"
-version = "1.4.1"
+version = "1.4.3"
 dependencies = [
  "ahash 0.8.11",
  "hashbrown 0.14.5",

{qiskit-1.4.1 → qiskit-1.4.3}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/*"]
 resolver = "2"
 
 [workspace.package]
-version = "1.4.1"
+version = "1.4.3"
 edition = "2021"
 rust-version = "1.70"  # Keep in sync with README.md and rust-toolchain.toml.
 license = "Apache-2.0"

{qiskit-1.4.1 → qiskit-1.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: qiskit
-Version: 1.4.1
+Version: 1.4.3
 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-1.4.1 → qiskit-1.4.3}/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-1.4.1 → qiskit-1.4.3}/crates/accelerate/src/basis/basis_translator/mod.rs

@@ -767,38 +767,46 @@ 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_bound(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_bound(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_bound(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_bound(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())?;
+            }
+
+            _ => {}
         }
     }
 

{qiskit-1.4.1 → qiskit-1.4.3}/crates/accelerate/src/split_2q_unitaries.rs

@@ -42,10 +42,10 @@ pub fn split_2q_unitaries(
             if qubits.len() != 2 || inst.op.name() != "unitary" {
                 continue;
             }
-            let matrix = inst
-                .op
-                .matrix(inst.params_view())
-                .expect("'unitary' gates should always have a matrix form");
+            let matrix = match inst.op.matrix(inst.params_view()) {
+                Some(mat) => mat,
+                None => continue,
+            };
             let decomp = TwoQubitWeylDecomposition::new_inner(
                 matrix.view(),
                 Some(requested_fidelity),

{qiskit-1.4.1 → qiskit-1.4.3}/crates/circuit/src/dag_circuit.rs

@@ -208,10 +208,8 @@ pub struct DAGCircuit {
     /// Global phase.
     global_phase: Param,
     /// Duration.
-    #[pyo3(set)]
     duration: Option<PyObject>,
     /// Unit of duration.
-    #[pyo3(set)]
     unit: String,
 
     // Note: these are tracked separately from `qubits` and `clbits`
@@ -346,13 +344,25 @@ fn reject_new_register(reg: &Bound<PyAny>) -> PyResult<()> {
 
 #[pyclass(module = "qiskit._accelerate.circuit")]
 #[derive(Clone, Debug)]
-struct BitLocations {
+pub(crate) struct BitLocations {
     #[pyo3(get)]
     index: usize,
     #[pyo3(get)]
     registers: Py<PyList>,
 }
 
+#[pymethods]
+impl BitLocations {
+    #[new]
+    fn new(index: usize, registers: Py<PyList>) -> Self {
+        Self { index, registers }
+    }
+
+    fn __getnewargs__(&self, py: Python) -> (usize, Py<PyList>) {
+        (self.index, self.registers.clone_ref(py))
+    }
+}
+
 #[derive(Copy, Clone, Debug)]
 enum DAGVarType {
     Input = 0,
@@ -403,11 +413,11 @@ impl DAGCircuit {
         })
     }
 
-    /// The total duration of the circuit, set by a scheduling transpiler pass. Its unit is
+    /// Returns the total duration of the circuit, set by a scheduling transpiler pass. Its unit is
     /// specified by :attr:`.unit`
     ///
-    /// DEPRECATED since Qiskit 1.3.0 and will be removed in Qiskit 2.0.0
-    #[getter]
+    /// DEPRECATED since Qiskit 1.3.0 and will be removed in Qiskit 3.0.0
+    #[getter("duration")]
     fn get_duration(&self, py: Python) -> PyResult<Option<Py<PyAny>>> {
         imports::WARNINGS_WARN.get_bound(py).call1((
             intern!(
@@ -418,12 +428,49 @@ impl DAGCircuit {
                 )
             ),
             py.get_type_bound::<PyDeprecationWarning>(),
-            2,
+            1,
         ))?;
+        self.get_internal_duration(py)
+    }
+
+    /// Returns the total duration of the circuit for internal use (no deprecation warning).
+    ///
+    /// To be removed with get_duration.
+    #[getter("_duration")]
+    fn get_internal_duration(&self, py: Python) -> PyResult<Option<Py<PyAny>>> {
         Ok(self.duration.as_ref().map(|x| x.clone_ref(py)))
     }
 
-    /// The unit that duration is specified in.
+    /// Sets the total duration of the circuit, set by a scheduling transpiler pass. Its unit is
+    /// specified by :attr:`.unit`
+    ///
+    /// DEPRECATED since Qiskit 1.3.0 and will be removed in Qiskit 3.0.0
+    #[setter("duration")]
+    fn set_duration(&mut self, py: Python, duration: Option<PyObject>) -> PyResult<()> {
+        imports::WARNINGS_WARN.get_bound(py).call1((
+            intern!(
+                py,
+                concat!(
+                    "The property ``qiskit.dagcircuit.dagcircuit.DAGCircuit.duration`` is ",
+                    "deprecated as of Qiskit 1.3.0. It will be removed in Qiskit 3.0.0.",
+                )
+            ),
+            py.get_type_bound::<PyDeprecationWarning>(),
+            1,
+        ))?;
+        self.set_internal_duration(duration);
+        Ok(())
+    }
+
+    /// Sets the total duration of the circuit for internal use (no deprecation warning).
+    ///
+    /// To be removed with set_duration.
+    #[setter("_duration")]
+    fn set_internal_duration(&mut self, duration: Option<PyObject>) {
+        self.duration = duration
+    }
+
+    /// Returns the unit that duration is specified in.
     ///
     /// DEPRECATED since Qiskit 1.3.0 and will be removed in Qiskit 2.0.0
     #[getter]
@@ -437,11 +484,47 @@ impl DAGCircuit {
                 )
             ),
             py.get_type_bound::<PyDeprecationWarning>(),
-            2,
+            1,
         ))?;
+        self.get_internal_unit()
+    }
+
+    /// Returns the unit that duration is specified in for internal use (no deprecation warning).
+    ///
+    /// To be removed with get_unit.
+    #[getter("_unit")]
+    fn get_internal_unit(&self) -> PyResult<String> {
         Ok(self.unit.clone())
     }
 
+    /// Sets the unit that duration is specified in.
+    ///
+    /// DEPRECATED since Qiskit 1.3.0 and will be removed in Qiskit 3.0.0
+    #[setter("unit")]
+    fn set_unit(&mut self, py: Python, unit: String) -> PyResult<()> {
+        imports::WARNINGS_WARN.get_bound(py).call1((
+            intern!(
+                py,
+                concat!(
+                    "The property ``qiskit.dagcircuit.dagcircuit.DAGCircuit.unit`` is ",
+                    "deprecated as of Qiskit 1.3.0. It will be removed in Qiskit 3.0.0.",
+                )
+            ),
+            py.get_type_bound::<PyDeprecationWarning>(),
+            1,
+        ))?;
+        self.set_internal_unit(unit);
+        Ok(())
+    }
+
+    /// Sets the unit that duration is specified in for internal use (no deprecation warning).
+    ///
+    /// To be removed with set_unit.
+    #[setter("_unit")]
+    fn set_internal_unit(&mut self, unit: String) {
+        self.unit = unit
+    }
+
     #[getter]
     fn input_map(&self, py: Python) -> PyResult<Py<PyDict>> {
         let out_dict = PyDict::new_bound(py);
@@ -528,6 +611,8 @@ impl DAGCircuit {
         out_dict.set_item("qregs", self.qregs.clone_ref(py))?;
         out_dict.set_item("cregs", self.cregs.clone_ref(py))?;
         out_dict.set_item("global_phase", self.global_phase.clone())?;
+        out_dict.set_item("qubit_locations", self.qubit_locations.clone_ref(py))?;
+        out_dict.set_item("clbit_locations", self.clbit_locations.clone_ref(py))?;
         out_dict.set_item(
             "qubit_io_map",
             self.qubit_io_map
@@ -617,6 +702,8 @@ impl DAGCircuit {
         self.qregs = dict_state.get_item("qregs")?.unwrap().extract()?;
         self.cregs = dict_state.get_item("cregs")?.unwrap().extract()?;
         self.global_phase = dict_state.get_item("global_phase")?.unwrap().extract()?;
+        self.qubit_locations = dict_state.get_item("qubit_locations")?.unwrap().extract()?;
+        self.clbit_locations = dict_state.get_item("clbit_locations")?.unwrap().extract()?;
         self.op_names = dict_state.get_item("op_name")?.unwrap().extract()?;
         self.vars_by_type = dict_state.get_item("vars_by_type")?.unwrap().extract()?;
         let binding = dict_state.get_item("vars_info")?.unwrap();
@@ -5575,7 +5662,7 @@ impl DAGCircuit {
             } else if wire.is_instance(imports::CLBIT.get_bound(py))? {
                 NodeType::ClbitOut(self.clbits.find(wire).unwrap())
             } else {
-                NodeType::VarIn(self.vars.find(wire).unwrap())
+                NodeType::VarOut(self.vars.find(wire).unwrap())
             }
         } else if let Ok(op_node) = b.downcast::<DAGOpNode>() {
             let op_node = op_node.borrow();

{qiskit-1.4.1 → qiskit-1.4.3}/crates/circuit/src/lib.rs

@@ -125,6 +125,7 @@ impl From<Clbit> for BitType {
 pub fn circuit(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_class::<circuit_data::CircuitData>()?;
     m.add_class::<circuit_instruction::CircuitInstruction>()?;
+    m.add_class::<dag_circuit::BitLocations>()?;
     m.add_class::<dag_circuit::DAGCircuit>()?;
     m.add_class::<dag_node::DAGNode>()?;
     m.add_class::<dag_node::DAGInNode>()?;

qiskit-1.4.3/qiskit/VERSION.txt

@@ -0,0 +1 @@
+1.4.3

{qiskit-1.4.1 → qiskit-1.4.3}/qiskit/circuit/duration.py

@@ -65,29 +65,29 @@ def convert_durations_to_dt(qc: QuantumCircuit, dt_in_sec: float, inplace=True):
 
     for instruction in circ.data:
         operation = instruction.operation
-        if operation.unit == "dt" or operation.duration is None:
+        if operation._unit == "dt" or operation._duration is None:
             continue
 
-        if not operation.unit.endswith("s"):
-            raise CircuitError(f"Invalid time unit: '{operation.unit}'")
+        if not operation._unit.endswith("s"):
+            raise CircuitError(f"Invalid time unit: '{operation._unit}'")
 
-        duration = operation.duration
-        if operation.unit != "s":
-            duration = apply_prefix(duration, operation.unit)
+        duration = operation._duration
+        if operation._unit != "s":
+            duration = apply_prefix(duration, operation._unit)
 
-        operation.duration = duration_in_dt(duration, dt_in_sec)
-        operation.unit = "dt"
+        operation._duration = duration_in_dt(duration, dt_in_sec)
+        operation._unit = "dt"
 
-    if circ.duration is not None and circ.unit != "dt":
-        if not circ.unit.endswith("s"):
-            raise CircuitError(f"Invalid time unit: '{circ.unit}'")
+    if circ._duration is not None and circ._unit != "dt":
+        if not circ._unit.endswith("s"):
+            raise CircuitError(f"Invalid time unit: '{circ._unit}'")
 
-        duration = circ.duration
-        if circ.unit != "s":
-            duration = apply_prefix(duration, circ.unit)
+        duration = circ._duration
+        if circ._unit != "s":
+            duration = apply_prefix(duration, circ._unit)
 
-        circ.duration = duration_in_dt(duration, dt_in_sec)
-        circ.unit = "dt"
+        circ._duration = duration_in_dt(duration, dt_in_sec)
+        circ._unit = "dt"
 
     if not inplace:
         return circ

{qiskit-1.4.1 → qiskit-1.4.3}/qiskit/circuit/library/standard_gates/r.py

@@ -33,9 +33,10 @@ class RGate(Gate):
 
     .. code-block:: text
 
-             ┌──────┐
-        q_0: ┤ R(ϴ) ├
-             └──────┘
+               ┌─────────┐
+        q_0:   ┤ R(θ,ϕ)  ├ 
+               └─────────┘
+
 
     **Matrix Representation:**
 

{qiskit-1.4.1 → qiskit-1.4.3}/qiskit/circuit/library/standard_gates/x.py

@@ -306,8 +306,7 @@ class CCXGate(SingletonControlledGate):
     r"""CCX gate, also known as Toffoli gate.
 
     Can be applied to a :class:`~qiskit.circuit.QuantumCircuit`
-    with the :meth:`~qiskit.circuit.QuantumCircuit.ccx` and
-    :meth:`~qiskit.circuit.QuantumCircuit.toffoli` methods.
+    with the :meth:`~qiskit.circuit.QuantumCircuit.ccx` method.
 
     **Circuit symbol:**
 

{qiskit-1.4.1 → qiskit-1.4.3}/qiskit/circuit/parameterexpression.py

@@ -25,7 +25,7 @@ import operator
 import numpy
 import symengine
 
-from qiskit.circuit.exceptions import CircuitError
+from qiskit.circuit.exceptions import CircuitError, QiskitError
 
 # This type is redefined at the bottom to insert the full reference to "ParameterExpression", so it
 # can safely be used by runtime type-checkers like Sphinx.  Mypy does not need this because it
@@ -528,6 +528,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):
@@ -608,6 +611,8 @@ 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-1.4.1 → qiskit-1.4.3}/qiskit/circuit/quantumcircuit.py

@@ -1546,8 +1546,8 @@ class QuantumCircuit:
         for instruction in reversed(self.data):
             reverse_circ._append(instruction.replace(operation=instruction.operation.reverse_ops()))
 
-        reverse_circ.duration = self.duration
-        reverse_circ.unit = self.unit
+        reverse_circ._duration = self._duration
+        reverse_circ._unit = self._unit
         return reverse_circ
 
     def reverse_bits(self) -> "QuantumCircuit":
@@ -2620,8 +2620,8 @@ class QuantumCircuit:
         """
         if _standard_gate:
             self._data.append(instruction)
-            self.duration = None
-            self.unit = "dt"
+            self._duration = None
+            self._unit = "dt"
             return instruction
 
         old_style = not isinstance(instruction, CircuitInstruction)
@@ -2643,8 +2643,8 @@ class QuantumCircuit:
             self._data.append_manual_params(instruction, params)
 
         # Invalidate whole circuit duration if an instruction is added
-        self.duration = None
-        self.unit = "dt"
+        self._duration = None
+        self._unit = "dt"
         return instruction.operation if old_style else instruction
 
     @typing.overload
@@ -6584,7 +6584,7 @@ class QuantumCircuit:
         Raises:
             CircuitError: if ``self`` is a not-yet scheduled circuit.
         """
-        if self.duration is None:
+        if self._duration is None:
             # circuit has only delays, this is kind of scheduled
             for instruction in self._data:
                 if not isinstance(instruction.operation, Delay):
@@ -6626,7 +6626,7 @@ class QuantumCircuit:
         Raises:
             CircuitError: if ``self`` is a not-yet scheduled circuit.
         """
-        if self.duration is None:
+        if self._duration is None:
             # circuit has only delays, this is kind of scheduled
             for instruction in self._data:
                 if not isinstance(instruction.operation, Delay):
@@ -6637,7 +6637,7 @@ class QuantumCircuit:
 
         qubits = [self.qubits[q] if isinstance(q, int) else q for q in qubits]
 
-        stops = {q: self.duration for q in qubits}
+        stops = {q: self._duration for q in qubits}
         dones = {q: False for q in qubits}
         for instruction in reversed(self._data):
             for q in qubits:

{qiskit-1.4.1 → qiskit-1.4.3}/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:

{qiskit-1.4.1 → qiskit-1.4.3}/qiskit/converters/circuit_to_dag.py

@@ -73,6 +73,6 @@ def circuit_to_dag(circuit, copy_operations=True, *, qubit_order=None, clbit_ord
 
     dagcircuit = core_circuit_to_dag(circuit, copy_operations, qubit_order, clbit_order)
 
-    dagcircuit.duration = circuit._duration
-    dagcircuit.unit = circuit._unit
+    dagcircuit._duration = circuit._duration
+    dagcircuit._unit = circuit._unit
     return dagcircuit

{qiskit-1.4.1 → qiskit-1.4.3}/qiskit/converters/dag_to_circuit.py

@@ -74,7 +74,6 @@ def dag_to_circuit(dag, copy_operations=True):
     circuit._calibrations_prop = dag._calibrations_prop
 
     circuit._data = circuit_data
-
-    circuit._duration = dag.duration
-    circuit._unit = dag.unit
+    circuit._duration = dag._duration
+    circuit._unit = dag._unit
     return circuit

{qiskit-1.4.1 → qiskit-1.4.3}/qiskit/dagcircuit/dagdependency_v2.py

@@ -525,8 +525,6 @@ class _DAGDependencyV2:
         target_dag = _DAGDependencyV2()
         target_dag.name = self.name
         target_dag._global_phase = self._global_phase
-        target_dag.duration = self.duration
-        target_dag.unit = self.unit
         target_dag.metadata = self.metadata
         target_dag._key_cache = self._key_cache
         target_dag.comm_checker = self.comm_checker
@@ -534,6 +532,9 @@ class _DAGDependencyV2:
         target_dag.add_qubits(self.qubits)
         target_dag.add_clbits(self.clbits)
 
+        target_dag.duration = self.duration
+        target_dag.unit = self.unit
+
         for qreg in self.qregs.values():
             target_dag.add_qreg(qreg)
         for creg in self.cregs.values():

{qiskit-1.4.1 → qiskit-1.4.3}/qiskit/primitives/statevector_estimator.py

@@ -33,7 +33,7 @@ class StatevectorEstimator(BaseEstimatorV2):
     Simple implementation of :class:`BaseEstimatorV2` with full state vector simulation.
 
     This class is implemented via :class:`~.Statevector` which turns provided circuits into
-    pure state vectors. These states are subsequently acted on by :class:~.SparsePauliOp`,
+    pure state vectors. These states are subsequently acted on by :class:`~.SparsePauliOp`,
     which implies that, at present, this implementation is only compatible with Pauli-based
     observables.