qiskit 2.0.0rc1__cp39-abi3-macosx_11_0_arm64.whl → 2.0.1__cp39-abi3-macosx_11_0_arm64.whl

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/converters/circuit_to_dag.py

@@ -75,6 +75,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/converters/dag_to_circuit.py

@@ -74,7 +74,6 @@ def dag_to_circuit(dag, copy_operations=True):
         circuit.add_stretch(stretch)
     circuit.metadata = dag.metadata or {}
     circuit._data = circuit_data
-
-    circuit._duration = dag.duration
-    circuit._unit = dag.unit
+    circuit._duration = dag._duration
+    circuit._unit = dag._unit
     return circuit

qiskit/dagcircuit/dagdependency_v2.py

@@ -447,8 +447,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
@@ -456,6 +454,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/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.
 

qiskit/qpy/__init__.py

@@ -194,6 +194,27 @@ of QPY in qiskit-terra 0.18.0.
    * - Qiskit (qiskit-terra for < 1.0.0) version
      - :func:`.dump` format(s) output versions
      - :func:`.load` maximum supported version (older format versions can always be read)
+   * - 2.0.0
+     - 13, 14
+     - 14
+   * - 1.4.2
+     - 10, 11, 12, 13
+     - 13
+   * - 1.4.1
+     - 10, 11, 12, 13
+     - 13
+   * - 1.4.0
+     - 10, 11, 12, 13
+     - 13
+   * - 1.3.3
+     - 10, 11, 12, 13
+     - 13
+   * - 1.3.2
+     - 10, 11, 12, 13
+     - 13
+   * - 1.3.1
+     - 10, 11, 12, 13
+     - 13
    * - 1.3.0
      - 10, 11, 12, 13
      - 13

qiskit/qpy/binary_io/circuits.py

@@ -783,6 +783,11 @@ def _write_instruction(
         custom_operations[gate_class_name] = instruction.operation
         custom_operations_list.append(gate_class_name)
 
+    elif isinstance(instruction.operation, library.MCMTGate):
+        gate_class_name = instruction.operation.name + "_" + str(uuid.uuid4())
+        custom_operations[gate_class_name] = instruction.operation
+        custom_operations_list.append(gate_class_name)
+
     condition_type = type_keys.Condition.NONE
     condition_register = b""
     condition_value = 0

qiskit/qpy/binary_io/parse_sympy_repr.py

@@ -0,0 +1,121 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2025.
+#
+# 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.
+
+"""Parser for sympy expressions srepr from ParameterExpression internals."""
+
+import ast
+
+from qiskit.qpy.exceptions import QpyError
+
+
+ALLOWED_CALLERS = {
+    "Abs",
+    "Add",
+    "Sub",
+    "Mul",
+    "Div",
+    "Pow",
+    "Symbol",
+    "Integer",
+    "Rational",
+    "Complex",
+    "Float",
+    "log",
+    "sin",
+    "cos",
+    "tan",
+    "atan",
+    "acos",
+    "asin",
+    "exp",
+    "conjugate",
+}
+
+UNARY = {
+    "sin",
+    "cos",
+    "tan",
+    "atan",
+    "acos",
+    "asin",
+    "conjugate",
+    "Symbol",
+    "Integer",
+    "Complex",
+    "Abs",
+    "Float",
+}
+
+
+class ParseSympyWalker(ast.NodeVisitor):
+    """A custom ast walker that is passed the sympy srepr from QPY < 13 and creates a custom
+    expression."""
+
+    def __init__(self):
+        self.stack = []
+
+    def visit_UnaryOp(self, node: ast.UnaryOp):  # pylint: disable=invalid-name
+        """Visit a python unary op node"""
+        self.visit(node.operand)
+        arg = self.stack.pop()
+        if isinstance(node.op, ast.UAdd):
+            self.stack.append(+arg)
+        elif isinstance(node.op, ast.USub):
+            self.stack.append(-arg)
+        elif isinstance(node.op, ast.Not):
+            self.stack.append(not arg)
+        elif isinstance(node.op, ast.Invert):
+            self.stack.append(~arg)
+        else:
+            raise QpyError(f"Invalid unary op as part of sympy srepr: {node.op}")
+
+    def visit_Constant(self, node: ast.Constant):  # pylint: disable=invalid-name
+        """Visit a constant node."""
+        self.stack.append(node.value)
+
+    def visit_Call(self, node: ast.Call):  # pylint: disable=invalid-name
+        """Visit a call node
+
+        This can only be parameter expression allowed sympy call types.
+        """
+        import sympy
+
+        if isinstance(node.func, ast.Name):
+            name = node.func.id
+        else:
+            raise QpyError("Unknown node type")
+
+        if name not in ALLOWED_CALLERS:
+            raise QpyError(f"{name} is not part of a valid sympy expression srepr")
+
+        args = node.args
+        if name in UNARY:
+            if len(args) != 1:
+                raise QpyError(f"{name} has an invalid number of args in sympy srepr")
+            self.visit(args[0])
+            obj = getattr(sympy, name)(self.stack.pop())
+            self.stack.append(obj)
+        else:
+            for arg in args:
+                self.visit(arg)
+            out_args = [self.stack.pop() for _ in range(len(args))]
+            out_args.reverse()
+            obj = getattr(sympy, name)(*out_args)
+            self.stack.append(obj)
+
+
+def parse_sympy_repr(sympy_repr: str):
+    """Parse a given sympy srepr into a symbolic expression object."""
+    tree = ast.parse(sympy_repr, mode="eval")
+    visitor = ParseSympyWalker()
+    visitor.visit(tree)
+    return visitor.stack.pop()

qiskit/qpy/binary_io/value.py

@@ -34,6 +34,7 @@ from qiskit.circuit.parameterexpression import (
 )
 from qiskit.circuit.parametervector import ParameterVector, ParameterVectorElement
 from qiskit.qpy import common, formats, exceptions, type_keys
+from qiskit.qpy.binary_io.parse_sympy_repr import parse_sympy_repr
 
 
 def _write_parameter(file_obj, obj):
@@ -473,9 +474,9 @@ def _read_parameter_expression(file_obj):
     data = formats.PARAMETER_EXPR(
         *struct.unpack(formats.PARAMETER_EXPR_PACK, file_obj.read(formats.PARAMETER_EXPR_SIZE))
     )
-    from sympy.parsing.sympy_parser import parse_expr
 
-    expr_ = symengine.sympify(parse_expr(file_obj.read(data.expr_size).decode(common.ENCODE)))
+    sympy_str = file_obj.read(data.expr_size).decode(common.ENCODE)
+    expr_ = symengine.sympify(parse_sympy_repr(sympy_str))
     symbol_map = {}
     for _ in range(data.map_elements):
         elem_data = formats.PARAM_EXPR_MAP_ELEM(
@@ -514,9 +515,8 @@ def _read_parameter_expression_v3(file_obj, vectors, use_symengine):
     if use_symengine:
         expr_ = common.load_symengine_payload(payload)
     else:
-        from sympy.parsing.sympy_parser import parse_expr
-
-        expr_ = symengine.sympify(parse_expr(payload.decode(common.ENCODE)))
+        sympy_str = payload.decode(common.ENCODE)
+        expr_ = symengine.sympify(parse_sympy_repr(sympy_str))
 
     symbol_map = {}
     for _ in range(data.map_elements):

qiskit/result/models.py

@@ -145,8 +145,7 @@ class ExperimentResult:
             status (str): The status of the experiment
             seed (int): The seed used for simulation (if run on a simulator)
             meas_return (str): The type of measurement returned
-            header (dict): A free form dictionary
-                header for the experiment
+            header (dict): A free form dictionary header for the experiment
             kwargs: Arbitrary extra fields
 
         Raises:

qiskit/result/result.py

@@ -34,6 +34,9 @@ class Result:
             each experiment success)
         results (list[ExperimentResult]): corresponding results for array of
             experiments of the input
+        date (str): optional date field
+        status (str): optional status field
+        header (dict): an optional free form dictionary header
     """
 
     _metadata = {}
@@ -88,7 +91,7 @@ class Result:
             "backend_name": self.backend_name,
             "backend_version": self.backend_version,
             "date": self.date,
-            "header": None if self.header is None else self.header.to_dict(),
+            "header": self.header,
             "job_id": self.job_id,
             "status": self.status,
             "success": self.success,
@@ -128,11 +131,10 @@ class Result:
         the get_xxx method, and the data will be post-processed for the data type.
 
         Args:
-            experiment (str or QuantumCircuit or Schedule or int or None): the index of the
+            experiment (str or QuantumCircuit or int or None): the index of the
                 experiment. Several types are accepted for convenience::
                 * str: the name of the experiment.
                 * QuantumCircuit: the name of the circuit instance will be used.
-                * Schedule: the name of the schedule instance will be used.
                 * int: the position of the experiment.
                 * None: if there is only one experiment, returns it.
 
@@ -179,7 +181,7 @@ class Result:
         ['00000', '01000', '10100', '10100', '11101', '11100', '00101', ..., '01010']
 
         Args:
-            experiment (str or QuantumCircuit or Schedule or int or None): the index of the
+            experiment (str or QuantumCircuit or int or None): the index of the
                 experiment, as specified by ``data()``.
 
         Returns:
@@ -231,7 +233,7 @@ class Result:
         """Get the histogram data of an experiment.
 
         Args:
-            experiment (str or QuantumCircuit or Schedule or int or None): the index of the
+            experiment (str or QuantumCircuit or int or None): the index of the
                 experiment, as specified by ``data([experiment])``.
 
         Returns:
@@ -283,7 +285,7 @@ class Result:
         """Get the final statevector of an experiment.
 
         Args:
-            experiment (str or QuantumCircuit or Schedule or int or None): the index of the
+            experiment (str or QuantumCircuit or int or None): the index of the
                 experiment, as specified by ``data()``.
             decimals (int): the number of decimals in the statevector.
                 If None, does not round.
@@ -305,7 +307,7 @@ class Result:
         """Get the final unitary of an experiment.
 
         Args:
-            experiment (str or QuantumCircuit or Schedule or int or None): the index of the
+            experiment (str or QuantumCircuit or int or None): the index of the
                 experiment, as specified by ``data()``.
             decimals (int): the number of decimals in the unitary.
                 If None, does not round.
@@ -326,7 +328,7 @@ class Result:
         """Return a single experiment result from a given key.
 
         Args:
-            key (str or QuantumCircuit or Schedule or int or None): the index of the
+            key (str or QuantumCircuit or int or None): the index of the
                 experiment, as specified by ``data()``.
 
         Returns:

qiskit/synthesis/discrete_basis/commutator_decompose.py

@@ -53,16 +53,40 @@ def _compute_rotation_axis(matrix: np.ndarray) -> np.ndarray:
     """
     _check_is_so3(matrix)
 
+    # If theta represents the rotation angle, then trace = 1 + 2cos(theta).
     trace = _compute_trace_so3(matrix)
-    theta = math.acos(0.5 * (trace - 1))
-    if math.sin(theta) > 1e-10:
-        x = 1 / (2 * math.sin(theta)) * (matrix[2][1] - matrix[1][2])
-        y = 1 / (2 * math.sin(theta)) * (matrix[0][2] - matrix[2][0])
-        z = 1 / (2 * math.sin(theta)) * (matrix[1][0] - matrix[0][1])
-    else:
+
+    if trace >= 3 - 1e-10:
+        # The matrix is the identity (rotation by 0)
         x = 1.0
         y = 0.0
         z = 0.0
+
+    elif trace <= -1 + 1e-10:
+        # The matrix is the 180-degree rotation
+        squares = (1 + np.diagonal(matrix)) / 2
+        index_of_max = np.argmax(squares)
+
+        if index_of_max == 0:
+            x = math.sqrt(squares[0])
+            y = matrix[0][1] / (2 * x)
+            z = matrix[0][2] / (2 * x)
+        elif index_of_max == 1:
+            y = math.sqrt(squares[1])
+            x = matrix[0][1] / (2 * y)
+            z = matrix[1][2] / (2 * y)
+        else:
+            z = math.sqrt(squares[2])
+            x = matrix[0][2] / (2 * z)
+            y = matrix[1][2] / (2 * z)
+
+    else:
+        # The matrix is the rotation by theta with sin(theta)!=0
+        theta = math.acos(0.5 * (trace - 1))
+        x = 1 / (2 * math.sin(theta)) * (matrix[2][1] - matrix[1][2])
+        y = 1 / (2 * math.sin(theta)) * (matrix[0][2] - matrix[2][0])
+        z = 1 / (2 * math.sin(theta)) * (matrix[1][0] - matrix[0][1])
+
     return np.array([x, y, z])
 
 

qiskit/synthesis/discrete_basis/gate_sequence.py

@@ -55,7 +55,6 @@ class GateSequence:
         self.name = " ".join(self.labels)
         self.global_phase = global_phase
         self.product = so3_matrix
-        self.product_su2 = su2_matrix
 
     def remove_cancelling_pair(self, indices: Sequence[int]) -> None:
         """Remove a pair of indices that cancel each other and *do not* change the matrices."""
@@ -106,6 +105,16 @@ class GateSequence:
 
         return circuit
 
+    def _to_u2(self):
+        """Creates the U2 matrix corresponding to the stored sequence of gates
+        and the global phase.
+        """
+        u2 = np.eye(2, dtype=complex)
+        for mat in self.gates:
+            u2 = mat.to_matrix().dot(u2)
+        u2 = np.exp(1j * self.global_phase) * u2
+        return u2
+
     def to_dag(self):
         """Convert to a :class:`.DAGCircuit`.
 
@@ -149,7 +158,6 @@ class GateSequence:
         so3 = _convert_su2_to_so3(su2)
 
         self.product = so3.dot(self.product)
-        self.product_su2 = su2.dot(self.product_su2)
         self.global_phase = self.global_phase + phase
 
         self.gates.append(gate)
@@ -172,7 +180,6 @@ class GateSequence:
         adjoint.labels = [inv.name for inv in adjoint.gates]
         adjoint.name = " ".join(adjoint.labels)
         adjoint.product = np.conj(self.product).T
-        adjoint.product_su2 = np.conj(self.product_su2).T
         adjoint.global_phase = -self.global_phase
 
         return adjoint
@@ -190,7 +197,6 @@ class GateSequence:
         out.matrices = self.matrices.copy()
         out.global_phase = self.global_phase
         out.product = self.product.copy()
-        out.product_su2 = self.product_su2.copy()
         out.name = self.name
         out._eulers = self._eulers
         return out

qiskit/synthesis/discrete_basis/generate_basis_approximations.py

@@ -76,7 +76,7 @@ def _check_candidate_greedy(candidate, existing_sequences, tol=1e-10):
         return False
 
     for existing in existing_sequences:
-        if matrix_equal(existing.product_su2, candidate.product_su2, ignore_phase=True, atol=tol):
+        if matrix_equal(existing.product, candidate.product, ignore_phase=True, atol=tol):
             # is the new sequence less or more efficient?
             return len(candidate.gates) < len(existing.gates)
     return True

qiskit/synthesis/discrete_basis/solovay_kitaev.py

@@ -24,7 +24,7 @@ from .generate_basis_approximations import generate_basic_approximations, _1q_ga
 class SolovayKitaevDecomposition:
     """The Solovay Kitaev discrete decomposition algorithm.
 
-    This class is called recursively by the transpiler pass, which is why it is separeted.
+    This class is called recursively by the transpiler pass, which is why it is separated.
     See :class:`qiskit.transpiler.passes.SolovayKitaev` for more information.
     """
 
@@ -33,7 +33,7 @@ class SolovayKitaevDecomposition:
     ) -> None:
         """
         Args:
-            basic_approximations: A specification of the basic SU(2) approximations in terms
+            basic_approximations: A specification of the basic SO(3) approximations in terms
                 of discrete gates. At each iteration this algorithm, the remaining error is
                 approximated with the closest sequence of gates in this set.
                 If a ``str``, this specifies a ``.npy`` filename from which to load the
@@ -116,23 +116,33 @@ class SolovayKitaevDecomposition:
         """
         # make input matrix SU(2) and get the according global phase
         z = 1 / np.sqrt(np.linalg.det(gate_matrix))
-        gate_matrix_su2 = GateSequence.from_matrix(z * gate_matrix)
+
+        gate_matrix_su2 = z * gate_matrix
+        gate_matrix_as_sequence = GateSequence.from_matrix(gate_matrix_su2)
         global_phase = np.arctan2(np.imag(z), np.real(z))
 
         # get the decomposition as GateSequence type
-        decomposition = self._recurse(gate_matrix_su2, recursion_degree, check_input=check_input)
+        decomposition = self._recurse(
+            gate_matrix_as_sequence, recursion_degree, check_input=check_input
+        )
 
         # simplify
         _remove_identities(decomposition)
         _remove_inverse_follows_gate(decomposition)
 
+        # adjust to the correct SU(2) phase
+        adjust_phase = (
+            np.pi if _should_adjust_phase(decomposition._to_u2(), gate_matrix_su2) else 0.0
+        )
+
         # convert to a circuit and attach the right phases
         if return_dag:
             out = decomposition.to_dag()
         else:
             out = decomposition.to_circuit()
 
-        out.global_phase = decomposition.global_phase - global_phase
+        out.global_phase += adjust_phase
+        out.global_phase -= global_phase
 
         return out
 
@@ -155,17 +165,20 @@ class SolovayKitaevDecomposition:
             raise ValueError("Shape of U must be (3, 3) but is", sequence.shape)
 
         if n == 0:
-            return self.find_basic_approximation(sequence)
+            res = self.find_basic_approximation(sequence)
 
-        u_n1 = self._recurse(sequence, n - 1, check_input=check_input)
+        else:
+            u_n1 = self._recurse(sequence, n - 1, check_input=check_input)
 
-        v_n, w_n = commutator_decompose(
-            sequence.dot(u_n1.adjoint()).product, check_input=check_input
-        )
+            v_n, w_n = commutator_decompose(
+                sequence.dot(u_n1.adjoint()).product, check_input=check_input
+            )
+
+            v_n1 = self._recurse(v_n, n - 1, check_input=check_input)
+            w_n1 = self._recurse(w_n, n - 1, check_input=check_input)
+            res = v_n1.dot(w_n1).dot(v_n1.adjoint()).dot(w_n1.adjoint()).dot(u_n1)
 
-        v_n1 = self._recurse(v_n, n - 1, check_input=check_input)
-        w_n1 = self._recurse(w_n, n - 1, check_input=check_input)
-        return v_n1.dot(w_n1).dot(v_n1.adjoint()).dot(w_n1.adjoint()).dot(u_n1)
+        return res
 
     def find_basic_approximation(self, sequence: GateSequence) -> GateSequence:
         """Find ``GateSequence`` in ``self._basic_approximations`` that approximates ``sequence``.
@@ -215,3 +228,13 @@ def _remove_identities(sequence):
             sequence.gates.pop(index)
         else:
             index += 1
+
+
+def _should_adjust_phase(computed: np.ndarray, target: np.ndarray) -> bool:
+    """
+    The implemented SolovayKitaevDecomposition has a global phase uncertainty of +-1,
+    due to approximating not the original SU(2) matrix but its projection onto SO(3).
+    This function returns ``True`` if the global phase of the computed approximation
+    should be adjusted (by adding pi) to better much the target.
+    """
+    return np.linalg.norm(-computed - target) < np.linalg.norm(computed - target)

qiskit/transpiler/passes/__init__.py

@@ -91,6 +91,7 @@ Optimizations
    Split2QUnitaries
    RemoveIdentityEquivalent
    ContractIdleWiresInControlFlow
+   LightCone
 
 Scheduling
 =============
@@ -225,6 +226,7 @@ from .optimization import OptimizeAnnotated
 from .optimization import RemoveIdentityEquivalent
 from .optimization import Split2QUnitaries
 from .optimization import ContractIdleWiresInControlFlow
+from .optimization import LightCone
 
 # circuit analysis
 from .analysis import ResourceEstimation

qiskit/transpiler/passes/basis/basis_translator.py

@@ -18,7 +18,7 @@ import logging
 from collections import defaultdict
 
 from qiskit.transpiler.basepasses import TransformationPass
-from qiskit._accelerate.basis.basis_translator import base_run
+from qiskit._accelerate.basis_translator import base_run
 
 logger = logging.getLogger(__name__)
 

qiskit/transpiler/passes/layout/full_ancilla_allocation.py

@@ -92,9 +92,8 @@ class FullAncillaAllocation(AnalysisPass):
 
         if idle_physical_qubits:
             if self.ancilla_name in dag.qregs:
-                qreg = QuantumRegister(
-                    len(idle_physical_qubits),
-                    name=f"{self.ancilla_name}{QuantumRegister.instances_count + 1}",
+                qreg = QuantumRegister._new_with_prefix(
+                    len(idle_physical_qubits), self.ancilla_name
                 )
             else:
                 qreg = QuantumRegister(len(idle_physical_qubits), name=self.ancilla_name)

qiskit/transpiler/passes/layout/sabre_layout.py

@@ -305,6 +305,9 @@ class SabreLayout(TransformationPass):
         # the layout and routing together as part of resolving the Sabre result.
         physical_qubits = QuantumRegister(self.coupling_map.size(), "q")
         mapped_dag = DAGCircuit()
+        mapped_dag.name = dag.name
+        mapped_dag.metadata = dag.metadata
+        mapped_dag.global_phase = dag.global_phase
         mapped_dag.add_qreg(physical_qubits)
         mapped_dag.add_clbits(dag.clbits)
         for creg in dag.cregs.values():
@@ -319,7 +322,6 @@ class SabreLayout(TransformationPass):
             mapped_dag.add_captured_stretch(stretch)
         for stretch in dag.iter_declared_stretches():
             mapped_dag.add_declared_stretch(stretch)
-        mapped_dag.global_phase = dag.global_phase
         self.property_set["original_qubit_indices"] = {
             bit: index for index, bit in enumerate(dag.qubits)
         }

qiskit/transpiler/passes/layout/vf2_utils.py

@@ -179,11 +179,8 @@ def build_average_error_map(target, coupling_map):
         coupling_map = target.build_coupling_map()
     if not built and coupling_map is not None and num_qubits is not None:
         for qubit in range(num_qubits):
-            avg_map.add_error(
-                (qubit, qubit),
-                (coupling_map.graph.out_degree(qubit) + coupling_map.graph.in_degree(qubit))
-                / num_qubits,
-            )
+            degree = len(set(coupling_map.graph.neighbors_undirected(qubit)))
+            avg_map.add_error((qubit, qubit), degree / num_qubits)
         for edge in coupling_map.graph.edge_list():
             avg_map.add_error(edge, (avg_map[edge[0], edge[0]] + avg_map[edge[1], edge[1]]) / 2)
             built = True

qiskit/transpiler/passes/optimization/__init__.py

@@ -39,3 +39,4 @@ from .remove_identity_equiv import RemoveIdentityEquivalent
 from .split_2q_unitaries import Split2QUnitaries
 from .collect_and_collapse import CollectAndCollapse
 from .contract_idle_wires_in_control_flow import ContractIdleWiresInControlFlow
+from .light_cone import LightCone

qiskit/transpiler/passes/optimization/template_matching/template_substitution.py

@@ -496,7 +496,6 @@ class TemplateSubstitution:
                 parameter constraints, returns None.
         """
         import sympy as sym
-        from sympy.parsing.sympy_parser import parse_expr
 
         if _optionals.HAS_SYMENGINE:
             import symengine
@@ -572,7 +571,8 @@ class TemplateSubstitution:
                 if isinstance(circuit_param, ParameterExpression):
                     circ_param_sym = circuit_param.sympify()
                 else:
-                    circ_param_sym = parse_expr(str(circuit_param))
+                    # if it's not a ParameterExpression we're a float
+                    circ_param_sym = sym.Float(circuit_param)
                 equations.append(sym.Eq(template_param.sympify(), circ_param_sym))
 
                 for param in template_param.parameters:

qiskit/transpiler/passes/scheduling/alignments/check_durations.py

@@ -59,7 +59,7 @@ class InstructionDurationCheck(AnalysisPass):
         self.property_set["reschedule_required"] = False
 
         # Rescheduling is not necessary
-        if self.acquire_align == 1 and self.pulse_align == 1:
+        if (self.acquire_align == 1 and self.pulse_align == 1) or dag._num_stretches != 0:
             return
 
         # Check delay durations