qiskit 1.2.0rc1__cp38-abi3-macosx_10_9_universal2.whl → 1.2.1__cp38-abi3-macosx_10_9_universal2.whl

qiskit/synthesis/one_qubit/one_qubit_decompose.py

@@ -224,7 +224,8 @@ class OneQubitEulerDecomposer:
         return QuantumCircuit._from_circuit_data(
             euler_one_qubit_decomposer.unitary_to_circuit(
                 unitary, [self.basis], 0, None, simplify, atol
-            )
+            ),
+            add_regs=True,
         )
 
     @property

qiskit/synthesis/permutation/permutation_full.py

@@ -42,7 +42,7 @@ def synth_permutation_basic(pattern: list[int] | np.ndarray[int]) -> QuantumCirc
     Returns:
         The synthesized quantum circuit.
     """
-    return QuantumCircuit._from_circuit_data(_synth_permutation_basic(pattern))
+    return QuantumCircuit._from_circuit_data(_synth_permutation_basic(pattern), add_regs=True)
 
 
 def synth_permutation_acg(pattern: list[int] | np.ndarray[int]) -> QuantumCircuit:
@@ -75,4 +75,4 @@ def synth_permutation_acg(pattern: list[int] | np.ndarray[int]) -> QuantumCircui
            *Routing Permutations on Graphs Via Matchings.*,
            `(Full paper) <https://www.cs.tau.ac.il/~nogaa/PDFS/r.pdf>`_
     """
-    return QuantumCircuit._from_circuit_data(_synth_permutation_acg(pattern))
+    return QuantumCircuit._from_circuit_data(_synth_permutation_acg(pattern), add_regs=True)

qiskit/synthesis/permutation/permutation_lnn.py

@@ -49,4 +49,6 @@ def synth_permutation_depth_lnn_kms(pattern: list[int] | np.ndarray[int]) -> Qua
     # In the permutation synthesis code below the notation is opposite:
     # [2, 4, 3, 0, 1] means that 0 maps to 2, 1 to 3, 2 to 3, 3 to 0, and 4 to 1.
     # This is why we invert the pattern.
-    return QuantumCircuit._from_circuit_data(_synth_permutation_depth_lnn_kms(pattern))
+    return QuantumCircuit._from_circuit_data(
+        _synth_permutation_depth_lnn_kms(pattern), add_regs=True
+    )

qiskit/synthesis/two_qubit/two_qubit_decompose.py

@@ -233,7 +233,7 @@ class TwoQubitWeylDecomposition:
         circuit_data = self._inner_decomposition.circuit(
             euler_basis=euler_basis, simplify=simplify, atol=atol
         )
-        return QuantumCircuit._from_circuit_data(circuit_data)
+        return QuantumCircuit._from_circuit_data(circuit_data, add_regs=True)
 
     def actual_fidelity(self, **kwargs) -> float:
         """Calculates the actual fidelity of the decomposed circuit to the input unitary."""
@@ -671,7 +671,7 @@ class TwoQubitBasisDecomposer:
                     approximate,
                     _num_basis_uses=_num_basis_uses,
                 )
-                return QuantumCircuit._from_circuit_data(circ_data)
+                return QuantumCircuit._from_circuit_data(circ_data, add_regs=True)
             else:
                 sequence = self._inner_decomposer(
                     np.asarray(unitary, dtype=complex),

qiskit/transpiler/instruction_durations.py

@@ -18,6 +18,7 @@ import qiskit.circuit
 from qiskit.circuit import Barrier, Delay, Instruction, ParameterExpression
 from qiskit.circuit.duration import duration_in_dt
 from qiskit.providers import Backend
+from qiskit.providers.backend import BackendV2
 from qiskit.transpiler.exceptions import TranspilerError
 from qiskit.utils.units import apply_prefix
 
@@ -75,6 +76,9 @@ class InstructionDurations:
             TranspilerError: If dt and dtm is different in the backend.
         """
         # All durations in seconds in gate_length
+        if isinstance(backend, BackendV2):
+            return backend.target.durations()
+
         instruction_durations = []
         backend_properties = backend.properties()
         if hasattr(backend_properties, "_gates"):

qiskit/transpiler/passes/__init__.py

@@ -71,6 +71,7 @@ Optimizations
    Collect1qRuns
    Collect2qBlocks
    CollectMultiQBlocks
+   CollectAndCollapse
    CollectLinearFunctions
    CollectCliffords
    ConsolidateBlocks
@@ -238,6 +239,7 @@ from .optimization import HoareOptimizer
 from .optimization import TemplateOptimization
 from .optimization import InverseCancellation
 from .optimization import EchoRZXWeylDecomposition
+from .optimization import CollectAndCollapse
 from .optimization import CollectLinearFunctions
 from .optimization import CollectCliffords
 from .optimization import ResetAfterMeasureSimplification

qiskit/transpiler/passes/basis/basis_translator.py

@@ -162,7 +162,8 @@ class BasisTranslator(TransformationPass):
         # If the source basis is a subset of the target basis and we have no circuit
         # instructions on qargs that have non-global operations there is nothing to
         # translate and we can exit early.
-        if source_basis.issubset(target_basis) and not qargs_local_source_basis:
+        source_basis_names = {x[0] for x in source_basis}
+        if source_basis_names.issubset(target_basis) and not qargs_local_source_basis:
             return dag
 
         logger.info(

qiskit/transpiler/passes/optimization/__init__.py

@@ -39,3 +39,4 @@ from .elide_permutations import ElidePermutations
 from .normalize_rx_angle import NormalizeRXAngle
 from .optimize_annotated import OptimizeAnnotated
 from .split_2q_unitaries import Split2QUnitaries
+from .collect_and_collapse import CollectAndCollapse

qiskit/transpiler/passes/optimization/consolidate_blocks.py

@@ -28,6 +28,7 @@ from qiskit.transpiler.passmanager import PassManager
 from qiskit.transpiler.passes.synthesis import unitary_synthesis
 from qiskit.circuit.controlflow import CONTROL_FLOW_OP_NAMES
 from qiskit._accelerate.convert_2q_block_matrix import blocks_to_matrix
+from qiskit.exceptions import QiskitError
 
 from .collect_1q_runs import Collect1qRuns
 from .collect_2q_blocks import Collect2qBlocks
@@ -125,7 +126,12 @@ class ConsolidateBlocks(TransformationPass):
                         qc.append(nd.op, [q[block_index_map[i]] for i in nd.qargs])
                     unitary = UnitaryGate(Operator(qc), check_input=False)
                 else:
-                    matrix = blocks_to_matrix(block, block_index_map)
+                    try:
+                        matrix = blocks_to_matrix(block, block_index_map)
+                    except QiskitError:
+                        # If building a matrix for the block fails we should not consolidate it
+                        # because there is nothing we can do with it.
+                        continue
                     unitary = UnitaryGate(matrix, check_input=False)
 
                 max_2q_depth = 20  # If depth > 20, there will be 1q gates to consolidate.

qiskit/transpiler/passes/optimization/hoare_opt.py

@@ -203,20 +203,24 @@ class HoareOptimizer(TransformationPass):
         """
         import z3
 
-        for node in dag.topological_op_nodes():
+        # Pre-generate all DAG nodes, since we later iterate over them, while
+        # potentially modifying and removing some of them.
+        nodes = list(dag.topological_op_nodes())
+        for node in nodes:
             gate = node.op
-            ctrlqb, ctrlvar, trgtqb, trgtvar = self._seperate_ctrl_trgt(node)
+            _, ctrlvar, trgtqb, trgtvar = self._seperate_ctrl_trgt(node)
 
             ctrl_ones = z3.And(*ctrlvar)
 
-            remove_ctrl, new_dag, qb_idx = self._remove_control(gate, ctrlvar, trgtvar)
+            remove_ctrl, new_dag, _ = self._remove_control(gate, ctrlvar, trgtvar)
 
             if remove_ctrl:
-                dag.substitute_node_with_dag(node, new_dag)
-                gate = gate.base_gate
-                node.op = gate.to_mutable()
-                node.name = gate.name
-                node.qargs = tuple((ctrlqb + trgtqb)[qi] for qi in qb_idx)
+                # We are replacing a node by a new node over a smaller number of qubits.
+                # This can be done using substitute_node_with_dag, which furthermore returns
+                # a mapping from old node ids to new nodes.
+                mapped_nodes = dag.substitute_node_with_dag(node, new_dag)
+                node = next(iter(mapped_nodes.values()))
+                gate = node.op
                 _, ctrlvar, trgtqb, trgtvar = self._seperate_ctrl_trgt(node)
 
                 ctrl_ones = z3.And(*ctrlvar)

qiskit/transpiler/passes/optimization/split_2q_unitaries.py

@@ -9,8 +9,8 @@
 # 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.
+
 """Splits each two-qubit gate in the `dag` into two single-qubit gates, if possible without error."""
-from typing import Optional
 
 from qiskit.transpiler.basepasses import TransformationPass
 from qiskit.circuit.quantumcircuitdata import CircuitInstruction
@@ -20,37 +20,33 @@ from qiskit.synthesis.two_qubit.two_qubit_decompose import TwoQubitWeylDecomposi
 
 
 class Split2QUnitaries(TransformationPass):
-    """Attempt to splits two-qubit gates in a :class:`.DAGCircuit` into two single-qubit gates
+    """Attempt to splits two-qubit unitaries in a :class:`.DAGCircuit` into two single-qubit gates.
 
-    This pass will analyze all the two qubit gates in the circuit and analyze the gate's unitary
-    matrix to determine if the gate is actually a product of 2 single qubit gates. In these
-    cases the 2q gate can be simplified into two single qubit gates and this pass will
-    perform this optimization and will replace the two qubit gate with two single qubit
-    :class:`.UnitaryGate`.
+    This pass will analyze all :class:`.UnitaryGate` instances and determine whether the
+    matrix is actually a product of 2 single qubit gates. In these cases the 2q gate can be
+    simplified into two single qubit gates and this pass will perform this optimization and will
+    replace the two qubit gate with two single qubit :class:`.UnitaryGate`.
     """
 
-    def __init__(self, fidelity: Optional[float] = 1.0 - 1e-16):
-        """Split2QUnitaries initializer.
-
+    def __init__(self, fidelity: float = 1.0 - 1e-16):
+        """
         Args:
-            fidelity (float): Allowed tolerance for splitting two-qubit unitaries and gate decompositions
+            fidelity: Allowed tolerance for splitting two-qubit unitaries and gate decompositions.
         """
         super().__init__()
         self.requested_fidelity = fidelity
 
-    def run(self, dag: DAGCircuit):
+    def run(self, dag: DAGCircuit) -> DAGCircuit:
         """Run the Split2QUnitaries pass on `dag`."""
+
         for node in dag.topological_op_nodes():
-            # skip operations without two-qubits and for which we can not determine a potential 1q split
-            if (
-                len(node.cargs) > 0
-                or len(node.qargs) != 2
-                or node.matrix is None
-                or node.is_parameterized()
-            ):
+            # We only attempt to split UnitaryGate objects, but this could be extended in future
+            # -- however we need to ensure that we can compile the resulting single-qubit unitaries
+            # to the supported basis gate set.
+            if not (len(node.qargs) == 2 and node.op.name == "unitary"):
                 continue
 
-            decomp = TwoQubitWeylDecomposition(node.op, fidelity=self.requested_fidelity)
+            decomp = TwoQubitWeylDecomposition(node.matrix, fidelity=self.requested_fidelity)
             if (
                 decomp._inner_decomposition.specialization
                 == TwoQubitWeylDecomposition._specializations.IdEquiv

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

@@ -31,7 +31,7 @@ class ValidatePulseGates(AnalysisPass):
 
     In Qiskit SDK, we can define the pulse-level implementation of custom quantum gate
     instructions, as a `pulse gate
-    <https://docs.quantum.ibm.com/build/pulse>`__,
+    <https://docs.quantum.ibm.com/guides/pulse>`__,
     thus user gates should satisfy all waveform memory constraints imposed by the backend.
 
     This pass validates all attached calibration entries and raises ``TranspilerError`` to

qiskit/transpiler/passes/scheduling/padding/dynamical_decoupling.py

@@ -20,7 +20,7 @@ from qiskit.circuit import Gate, ParameterExpression, Qubit
 from qiskit.circuit.delay import Delay
 from qiskit.circuit.library.standard_gates import IGate, UGate, U3Gate
 from qiskit.circuit.reset import Reset
-from qiskit.dagcircuit import DAGCircuit, DAGNode, DAGInNode, DAGOpNode
+from qiskit.dagcircuit import DAGCircuit, DAGNode, DAGInNode, DAGOpNode, DAGOutNode
 from qiskit.quantum_info.operators.predicates import matrix_equal
 from qiskit.synthesis.one_qubit import OneQubitEulerDecomposer
 from qiskit.transpiler.exceptions import TranspilerError
@@ -331,8 +331,7 @@ class PadDynamicalDecoupling(BasePadding):
         if time_interval % self._alignment != 0:
             raise TranspilerError(
                 f"Time interval {time_interval} is not divisible by alignment {self._alignment} "
-                f"between DAGNode {prev_node.name} on qargs {prev_node.qargs} and {next_node.name} "
-                f"on qargs {next_node.qargs}."
+                f"between {_format_node(prev_node)} and {_format_node(next_node)}."
             )
 
         if not self.__is_dd_qubit(dag.qubits.index(qubit)):
@@ -430,3 +429,10 @@ class PadDynamicalDecoupling(BasePadding):
             else:
                 params.append(p)
         return tuple(params)
+
+
+def _format_node(node: DAGNode) -> str:
+    """Util to format the DAGNode, DAGInNode, and DAGOutNode."""
+    if isinstance(node, (DAGInNode, DAGOutNode)):
+        return f"{node.__class__.__name__} on qarg {node.wire}"
+    return f"DAGNode {node.name} on qargs {node.qargs}"

qiskit/transpiler/passes/synthesis/unitary_synthesis.py

@@ -54,7 +54,7 @@ from qiskit.circuit.library.standard_gates import (
 from qiskit.converters import circuit_to_dag, dag_to_circuit
 from qiskit.dagcircuit.dagcircuit import DAGCircuit, DAGOpNode
 from qiskit.exceptions import QiskitError
-from qiskit.providers.models import BackendProperties
+from qiskit.providers.models.backendproperties import BackendProperties
 from qiskit.quantum_info import Operator
 from qiskit.synthesis.one_qubit import one_qubit_decompose
 from qiskit.synthesis.two_qubit.xx_decompose import XXDecomposer, XXEmbodiments

qiskit/transpiler/preset_passmanagers/builtin_plugins.py

@@ -14,7 +14,6 @@
 
 import os
 
-from qiskit.circuit import Instruction
 from qiskit.transpiler.passes.optimization.split_2q_unitaries import Split2QUnitaries
 from qiskit.transpiler.passmanager import PassManager
 from qiskit.transpiler.exceptions import TranspilerError
@@ -66,7 +65,6 @@ from qiskit.circuit.library.standard_gates import (
     CYGate,
     SXGate,
     SXdgGate,
-    get_standard_gate_name_mapping,
 )
 from qiskit.utils.parallel import CPU_COUNT
 from qiskit import user_config
@@ -173,58 +171,16 @@ class DefaultInitPassManager(PassManagerStagePlugin):
                 )
             )
             init.append(CommutativeCancellation())
-            # skip peephole optimization before routing if target basis gate set is discrete,
-            # i.e. only consists of Cliffords that an user might want to keep
-            # use rz, sx, x, cx as basis, rely on physical optimziation to fix everything later one
-            stdgates = get_standard_gate_name_mapping()
-
-            def _is_one_op_non_discrete(ops):
-                """Checks if one operation in `ops` is not discrete, i.e. is parameterizable
-                Args:
-                    ops (List(Operation)): list of operations to check
-                Returns
-                    True if at least one operation in `ops` is not discrete, False otherwise
-                """
-                found_one_continuous_gate = False
-                for op in ops:
-                    if isinstance(op, str):
-                        if op in _discrete_skipped_ops:
-                            continue
-                        op = stdgates.get(op, None)
-
-                    if op is not None and op.name in _discrete_skipped_ops:
-                        continue
-
-                    if op is None or not isinstance(op, Instruction):
-                        return False
-
-                    if len(op.params) > 0:
-                        found_one_continuous_gate = True
-                return found_one_continuous_gate
-
-            target = pass_manager_config.target
-            basis = pass_manager_config.basis_gates
-            # consolidate gates before routing if the user did not specify a discrete basis gate, i.e.
-            # * no target or basis gate set has been specified
-            # * target has been specified, and we have one non-discrete gate in the target's spec
-            # * basis gates have been specified, and we have one non-discrete gate in that set
-            do_consolidate_blocks_init = target is None and basis is None
-            do_consolidate_blocks_init |= target is not None and _is_one_op_non_discrete(
-                target.operations
-            )
-            do_consolidate_blocks_init |= basis is not None and _is_one_op_non_discrete(basis)
-
-            if do_consolidate_blocks_init:
-                init.append(Collect2qBlocks())
-                init.append(ConsolidateBlocks())
-                # If approximation degree is None that indicates a request to approximate up to the
-                # error rates in the target. However, in the init stage we don't yet know the target
-                # qubits being used to figure out the fidelity so just use the default fidelity parameter
-                # in this case.
-                if pass_manager_config.approximation_degree is not None:
-                    init.append(Split2QUnitaries(pass_manager_config.approximation_degree))
-                else:
-                    init.append(Split2QUnitaries())
+            init.append(Collect2qBlocks())
+            init.append(ConsolidateBlocks())
+            # If approximation degree is None that indicates a request to approximate up to the
+            # error rates in the target. However, in the init stage we don't yet know the target
+            # qubits being used to figure out the fidelity so just use the default fidelity parameter
+            # in this case.
+            if pass_manager_config.approximation_degree is not None:
+                init.append(Split2QUnitaries(pass_manager_config.approximation_degree))
+            else:
+                init.append(Split2QUnitaries())
         else:
             raise TranspilerError(f"Invalid optimization level {optimization_level}")
         return init

qiskit/transpiler/preset_passmanagers/generate_preset_pass_manager.py

@@ -343,6 +343,7 @@ def generate_preset_pass_manager(
     # Parse non-target dependent pm options
     initial_layout = _parse_initial_layout(initial_layout)
     approximation_degree = _parse_approximation_degree(approximation_degree)
+    seed_transpiler = _parse_seed_transpiler(seed_transpiler)
 
     pm_options = {
         "target": target,
@@ -516,3 +517,11 @@ def _parse_approximation_degree(approximation_degree):
     if approximation_degree < 0.0 or approximation_degree > 1.0:
         raise TranspilerError("Approximation degree must be in [0.0, 1.0]")
     return approximation_degree
+
+
+def _parse_seed_transpiler(seed_transpiler):
+    if seed_transpiler is None:
+        return None
+    if not isinstance(seed_transpiler, int) or seed_transpiler < 0:
+        raise ValueError("Expected non-negative integer as seed for transpiler.")
+    return seed_transpiler