qiskit 1.0.2__cp38-abi3-win32.whl → 1.1.0__cp38-abi3-win32.whl

qiskit/synthesis/two_qubit/xx_decompose/circuits.py

@@ -23,6 +23,7 @@ Output:
 """
 
 from __future__ import annotations
+import cmath
 from functools import reduce
 import math
 from operator import itemgetter
@@ -55,8 +56,8 @@ def decompose_xxyy_into_xxyy_xx(a_target, b_target, a_source, b_source, interact
     Returns the 6-tuple (r, s, u, v, x, y).
     """
 
-    cplus, cminus = np.cos(a_source + b_source), np.cos(a_source - b_source)
-    splus, sminus = np.sin(a_source + b_source), np.sin(a_source - b_source)
+    cplus, cminus = math.cos(a_source + b_source), math.cos(a_source - b_source)
+    splus, sminus = math.sin(a_source + b_source), math.sin(a_source - b_source)
     ca, sa = np.cos(interaction), np.sin(interaction)
 
     uplusv = (
@@ -117,10 +118,10 @@ def decompose_xxyy_into_xxyy_xx(a_target, b_target, a_source, b_source, interact
         ]
     )
     inner_phases = [
-        np.angle(middle_matrix[0, 0]),
-        np.angle(middle_matrix[1, 1]),
-        np.angle(middle_matrix[1, 2]) + np.pi / 2,
-        np.angle(middle_matrix[0, 3]) + np.pi / 2,
+        cmath.phase(middle_matrix[0, 0]),
+        cmath.phase(middle_matrix[1, 1]),
+        cmath.phase(middle_matrix[1, 2]) + np.pi / 2,
+        cmath.phase(middle_matrix[0, 3]) + np.pi / 2,
     ]
     r, s, x, y = np.dot(phase_solver, inner_phases)
 
@@ -133,8 +134,8 @@ def decompose_xxyy_into_xxyy_xx(a_target, b_target, a_source, b_source, interact
             np.kron(RZGate(2 * x).to_matrix(), RZGate(2 * y).to_matrix()),
         ],
     )
-    if (abs(np.angle(generated_matrix[3, 0]) - np.pi / 2) < 0.01 and a_target > b_target) or (
-        abs(np.angle(generated_matrix[3, 0]) + np.pi / 2) < 0.01 and a_target < b_target
+    if (abs(cmath.phase(generated_matrix[3, 0]) - np.pi / 2) < 0.01 and a_target > b_target) or (
+        abs(cmath.phase(generated_matrix[3, 0]) + np.pi / 2) < 0.01 and a_target < b_target
     ):
         x += np.pi / 4
         y += np.pi / 4
@@ -231,8 +232,8 @@ def xx_circuit_step(source, strength, target, embodiment):
     # finally conjugated by p_s_f_o.
     prefix_circuit.compose(permute_source_for_overlap, inplace=True)
     prefix_circuit.compose(source_reflection, inplace=True)
-    prefix_circuit.global_phase += -np.log(reflection_phase_shift).imag
-    prefix_circuit.global_phase += -np.log(shift_phase_shift).imag
+    prefix_circuit.global_phase -= cmath.phase(reflection_phase_shift)
+    prefix_circuit.global_phase -= cmath.phase(shift_phase_shift)
 
     # the affix circuit is constructed in reverse.
     # first (i.e., innermost), we install the other half of the source transformations and p_s_f_o.
@@ -291,8 +292,8 @@ def canonical_xx_circuit(target, strength_sequence, basis_embodiments):
         circuit.compose(basis_embodiments[strength_sequence[0]], inplace=True)
         circuit.compose(source_reflection.inverse(), inplace=True)
         circuit.compose(source_shift, inplace=True)
-        circuit.global_phase += -np.log(shift_phase_shift).imag
-        circuit.global_phase += -np.log(reflection_phase_shift).imag
+        circuit.global_phase -= cmath.phase(shift_phase_shift)
+        circuit.global_phase -= cmath.phase(reflection_phase_shift)
 
     circuit.compose(affix_circuit, inplace=True)
 

qiskit/synthesis/two_qubit/xx_decompose/decomposer.py

@@ -230,6 +230,7 @@ class XXDecomposer:
         unitary: Operator | np.ndarray,
         basis_fidelity: dict | float | None = None,
         approximate: bool = True,
+        use_dag: bool = False,
     ) -> QuantumCircuit:
         r"""
         Fashions a circuit which (perhaps approximately) models the special unitary operation
@@ -246,6 +247,8 @@ class XXDecomposer:
                 interpreted as ``{pi: f, pi/2: f/2, pi/3: f/3}``.
                 If given, overrides the basis_fidelity given at init.
             approximate (bool): Approximates if basis fidelities are less than 1.0 .
+            use_dag (bool): If true a :class:`.DAGCircuit` is returned instead of a
+                :class:`QuantumCircuit` when this class is called.
 
         Returns:
             QuantumCircuit: Synthesized circuit.
@@ -279,7 +282,7 @@ class XXDecomposer:
             and self.backup_optimizer is not None
         ):
             pi2_fidelity = 1 - strength_to_infidelity[np.pi / 2]
-            return self.backup_optimizer(unitary, basis_fidelity=pi2_fidelity)
+            return self.backup_optimizer(unitary, basis_fidelity=pi2_fidelity, use_dag=use_dag)
 
         # change to positive canonical coordinates
         if weyl_decomposition.c >= -EPSILON:
@@ -314,5 +317,8 @@ class XXDecomposer:
         circ.append(UnitaryGate(weyl_decomposition.K1l), [1])
 
         circ = self._decomposer1q(circ)
+        if use_dag:
+            from qiskit.converters import circuit_to_dag
 
+            return circuit_to_dag(circ, copy_operations=False)
         return circ

qiskit/synthesis/unitary/aqc/__init__.py

@@ -108,7 +108,7 @@ A basic usage of the AQC algorithm should consist of the following steps::
     unitary = ...
 
     # Define a number of qubits for the algorithm, at least 3 qubits
-    num_qubits = int(round(np.log2(unitary.shape[0])))
+    num_qubits = round(math.log2(unitary.shape[0]))
 
     # Choose a layout of the CNOT structure for the approximate circuit, e.g. ``spin`` for
     # a linear layout.

qiskit/synthesis/unitary/aqc/cnot_structures.py

@@ -13,6 +13,7 @@
 These are the CNOT structure methods: anything that you need for creating CNOT structures.
 """
 import logging
+import math
 
 import numpy as np
 
@@ -34,7 +35,7 @@ def _lower_limit(num_qubits: int) -> int:
     Returns:
         lower limit on the number of CNOT units.
     """
-    num_cnots = round(np.ceil((4**num_qubits - 3 * num_qubits - 1) / 4.0))
+    num_cnots = math.ceil((4**num_qubits - 3 * num_qubits - 1) / 4.0)
     return num_cnots
 
 

qiskit/synthesis/unitary/aqc/fast_gradient/fast_gradient.py

@@ -14,6 +14,7 @@
 Implementation of the fast objective function class.
 """
 
+import math
 import warnings
 import numpy as np
 
@@ -110,7 +111,7 @@ class FastCNOTUnitObjective(CNOTUnitObjective):
         # If thetas are the same as used for objective value calculation
         # before calling this function, then we re-use the computations,
         # otherwise we have to re-compute the objective.
-        tol = float(np.sqrt(np.finfo(float).eps))
+        tol = math.sqrt(np.finfo(float).eps)
         if not np.allclose(param_values, self._circ_thetas, atol=tol, rtol=tol):
             self.objective(param_values)
             warnings.warn("gradient is computed before the objective")

qiskit/synthesis/unitary/qsd.py

@@ -15,6 +15,7 @@ Quantum Shannon Decomposition.
 Method is described in arXiv:quant-ph/0406176.
 """
 from __future__ import annotations
+import math
 from typing import Callable
 import scipy
 import numpy as np
@@ -93,7 +94,7 @@ def qs_decomposition(
     """
     #  _depth (int): Internal use parameter to track recursion depth.
     dim = mat.shape[0]
-    nqubits = int(np.log2(dim))
+    nqubits = int(math.log2(dim))
     if np.allclose(np.identity(dim), mat):
         return QuantumCircuit(nqubits)
     if dim == 2:
@@ -185,7 +186,7 @@ def _demultiplex(um0, um1, opt_a1=False, opt_a2=False, *, _depth=0):
         QuantumCircuit: decomposed circuit
     """
     dim = um0.shape[0] + um1.shape[0]  # these should be same dimension
-    nqubits = int(np.log2(dim))
+    nqubits = int(math.log2(dim))
     um0um1 = um0 @ um1.T.conjugate()
     if is_hermitian_matrix(um0um1):
         eigvals, vmat = scipy.linalg.eigh(um0um1)

qiskit/transpiler/__init__.py

@@ -799,7 +799,7 @@ circuit repeatedly will in general result in a distribution of circuit depths an
 at the output.
 
 In order to highlight this, we run a GHZ circuit 100 times, using a "bad" (disconnected)
-`initial_layout`:
+``initial_layout`` in a heavy hex coupling map:
 
 .. plot::
 
@@ -816,18 +816,22 @@ In order to highlight this, we run a GHZ circuit 100 times, using a "bad" (disco
    import matplotlib.pyplot as plt
    from qiskit import QuantumCircuit, transpile
    from qiskit.providers.fake_provider import GenericBackendV2
-   backend = GenericBackendV2(16)
+   from qiskit.transpiler import CouplingMap
+
+   coupling_map = CouplingMap.from_heavy_hex(3)
+   backend = GenericBackendV2(coupling_map.size(), coupling_map=coupling_map)
 
    ghz = QuantumCircuit(15)
    ghz.h(0)
    ghz.cx(0, range(1, 15))
 
    depths = []
-   for _ in range(100):
+   for i in range(100):
        depths.append(
            transpile(
                ghz,
                backend,
+               seed_transpiler=i,
                layout_method='trivial'  # Fixed layout mapped in circuit order
            ).depth()
        )

qiskit/transpiler/layout.py

@@ -368,22 +368,91 @@ class Layout:
             out.add_register(qreg)
         return out
 
+    def compose(self, other: Layout, qubits: List[Qubit]) -> Layout:
+        """Compose this layout with another layout.
+
+        If this layout represents a mapping from the P-qubits to the positions of the Q-qubits,
+        and the other layout represents a mapping from the Q-qubits to the positions of
+        the R-qubits, then the composed layout represents a mapping from the P-qubits to the
+        positions of the R-qubits.
+
+        Args:
+            other: The existing :class:`.Layout` to compose this :class:`.Layout` with.
+            qubits: A list of :class:`.Qubit` objects over which ``other`` is defined,
+                used to establish the correspondence between the positions of the ``other``
+                qubits and the actual qubits.
+
+        Returns:
+            A new layout object the represents this layout composed with the ``other`` layout.
+        """
+        other_v2p = other.get_virtual_bits()
+        return Layout({virt: other_v2p[qubits[phys]] for virt, phys in self._v2p.items()})
+
+    def inverse(self, source_qubits: List[Qubit], target_qubits: List[Qubit]):
+        """Finds the inverse of this layout.
+
+        This is possible when the layout is a bijective mapping, however the input
+        and the output qubits may be different (in particular, this layout may be
+        the mapping from the extended-with-ancillas virtual qubits to physical qubits).
+        Thus, if this layout represents a mapping from the P-qubits to the positions
+        of the Q-qubits, the inverse layout represents a mapping from the Q-qubits
+        to the positions of the P-qubits.
+
+        Args:
+            source_qubits: A list of :class:`.Qubit` objects representing the domain
+                of the layout.
+            target_qubits: A list of :class:`.Qubit` objects representing the image
+                of the layout.
+
+        Returns:
+            A new layout object the represents the inverse of this layout.
+        """
+        source_qubit_to_position = {q: p for p, q in enumerate(source_qubits)}
+        return Layout(
+            {
+                target_qubits[pos_phys]: source_qubit_to_position[virt]
+                for virt, pos_phys in self._v2p.items()
+            }
+        )
+
+    def to_permutation(self, qubits: List[Qubit]):
+        """Creates a permutation corresponding to this layout.
+
+        This is possible when the layout is a bijective mapping with the same
+        source and target qubits (for instance, a "final_layout" corresponds
+        to a permutation of the physical circuit qubits). If this layout is
+        a mapping from qubits to their new positions, the resulting permutation
+        describes which qubits occupy the positions 0, 1, 2, etc. after
+        applying the permutation.
+
+        For example, suppose that the list of qubits is ``[qr_0, qr_1, qr_2]``,
+        and the layout maps ``qr_0`` to ``2``, ``qr_1`` to ``0``, and
+        ``qr_2`` to ``1``. In terms of positions in ``qubits``, this maps ``0``
+        to ``2``, ``1`` to ``0`` and ``2`` to ``1``, with the corresponding
+        permutation being ``[1, 2, 0]``.
+        """
+
+        perm = [None] * len(qubits)
+        for i, q in enumerate(qubits):
+            pos = self._v2p[q]
+            perm[pos] = i
+        return perm
+
 
 @dataclass
 class TranspileLayout:
-    r"""Layout attributes from output circuit from transpiler.
+    r"""Layout attributes for the output circuit from transpiler.
 
-    The transpiler in general is unitary-perserving up to permutations caused
-    by setting and applying initial layout during the :ref:`layout_stage`
-    and :class:`~.SwapGate` insertion during the :ref:`routing_stage`. To
-    provide an interface to reason about these permutations caused by
-    the :mod:`~qiskit.transpiler`. In general the normal interface to access
-    and reason about the layout transformations made by the transpiler is to
-    use the helper methods defined on this class.
+    The :mod:`~qiskit.transpiler` is unitary-preserving up to the "initial layout"
+    and "final layout" permutations. The initial layout permutation is caused by
+    setting and applying the initial layout during the :ref:`layout_stage`.
+    The final layout permutation is caused by :class:`~.SwapGate` insertion during
+    the :ref:`routing_stage`. This class provides an interface to reason about these
+    permutations using a variety of helper methods.
 
-    For example, looking at the initial layout, the transpiler can potentially
-    remap the order of the qubits in your circuit as it fits the circuit to
-    the target backend. If the input circuit was:
+    During the layout stage, the transpiler can potentially remap the order of the
+    qubits in the circuit as it fits the circuit to the target backend. For example,
+    let the input circuit be:
 
     .. plot:
        :include-source:
@@ -397,7 +466,8 @@ class TranspileLayout:
        qc.cx(0, 2)
        qc.draw("mpl")
 
-    Then during the layout stage the transpiler reorders the qubits to be:
+
+    Suppose that during the layout stage the transpiler reorders the qubits to be:
 
     .. plot:
        :include-source:
@@ -410,7 +480,7 @@ class TranspileLayout:
        qc.cx(2, 0)
        qc.draw("mpl")
 
-    then the output of the :meth:`.initial_virtual_layout` would be
+    Then the output of the :meth:`.initial_virtual_layout` method is
     equivalent to::
 
         Layout({
@@ -421,10 +491,11 @@ class TranspileLayout:
 
     (it is also this attribute in the :meth:`.QuantumCircuit.draw` and
     :func:`.circuit_drawer` which is used to display the mapping of qubits to
-    positions in circuit visualizations post-transpilation)
+    positions in circuit visualizations post-transpilation).
 
-    Building on this above example for final layout, if the transpiler needed to
-    insert swap gates during routing so the output circuit became:
+    Building on the above example, suppose that during the routing stage
+    the transpiler needs to insert swap gates, and the output circuit
+    becomes:
 
     .. plot:
        :include-source:
@@ -438,19 +509,19 @@ class TranspileLayout:
        qc.cx(2, 1)
        qc.draw("mpl")
 
-    then the output of the :meth:`routing_permutation` method would be::
+    Then the output of the :meth:`routing_permutation` method is::
 
         [1, 0, 2]
 
-    which maps the qubits at each position to their final position after any swap
-    insertions caused by routing.
+    which maps positions of qubits before routing to their final positions
+    after routing.
 
     There are three public attributes associated with the class, however these
     are mostly provided for backwards compatibility and represent the internal
     state from the transpiler. They are defined as:
 
       * :attr:`initial_layout` - This attribute is used to model the
-        permutation caused by the :ref:`layout_stage` it contains a
+        permutation caused by the :ref:`layout_stage`. It is a
         :class:`~.Layout` object that maps the input :class:`~.QuantumCircuit`\s
         :class:`~.circuit.Qubit` objects to the position in the output
         :class:`.QuantumCircuit.qubits` list.
@@ -461,18 +532,19 @@ class TranspileLayout:
         :attr:`.QuantumCircuit.qubits` in the original circuit. This
         is needed when computing the permutation of the :class:`Operator` of
         the circuit (and used by :meth:`.Operator.from_circuit`).
-      * :attr:`final_layout` - This is a :class:`~.Layout` object used to
-        model the output permutation caused ny any :class:`~.SwapGate`\s
-        inserted into the :class:`~.QuantumCircuit` during the
-        :ref:`routing_stage`. It maps the output circuit's qubits from
-        :class:`.QuantumCircuit.qubits` in the output circuit to the final
-        position after routing. It is **not** a mapping from the original
-        input circuit's position to the final position at the end of the
-        transpiled circuit. If you need this you can use the
-        :meth:`.final_index_layout` to generate this. If this is set to ``None``
-        this indicates that routing was not run and it can be considered
-        equivalent to a trivial layout with the qubits from the output circuit's
-        :attr:`~.QuantumCircuit.qubits` list.
+      * :attr:`final_layout` - This attribute is used to model the
+        permutation caused by the :ref:`routing_stage`. It is a
+        :class:`~.Layout` object that maps the output circuit's qubits from
+        :class:`.QuantumCircuit.qubits` in the output circuit to their final
+        positions after routing. Importantly, this only represents the
+        permutation caused by inserting :class:`~.SwapGate`\s into
+        the :class:`~.QuantumCircuit` during the :ref:`routing_stage`.
+        It is **not** a mapping from the original input circuit's position
+        to the final position at the end of the transpiled circuit.
+        If you need this, you can use the :meth:`.final_index_layout` to generate this.
+        If :attr:`final_layout` is set to ``None``, this indicates that routing was not
+        run, and can be considered equivalent to a trivial layout with the qubits from
+        the output circuit's :attr:`~.QuantumCircuit.qubits` list.
     """
 
     initial_layout: Layout
@@ -485,8 +557,8 @@ class TranspileLayout:
         """Return a :class:`.Layout` object for the initial layout.
 
         This returns a mapping of virtual :class:`~.circuit.Qubit` objects in the input
-        circuit to the physical qubit selected during layout. This is analogous
-        to the :attr:`.initial_layout` attribute.
+        circuit to the positions of the physical qubits selected during layout.
+        This is analogous to the :attr:`.initial_layout` attribute.
 
         Args:
             filter_ancillas: If set to ``True`` only qubits in the input circuit
@@ -494,7 +566,7 @@ class TranspileLayout:
                 output circuit will be filtered from the returned object.
         Returns:
             A layout object mapping the input circuit's :class:`~.circuit.Qubit`
-            objects to the selected physical qubits.
+            objects to the positions of the selected physical qubits.
         """
         if not filter_ancillas:
             return self.initial_layout
@@ -507,7 +579,7 @@ class TranspileLayout:
         )
 
     def initial_index_layout(self, filter_ancillas: bool = False) -> List[int]:
-        """Generate an initial layout as an array of integers
+        """Generate an initial layout as an array of integers.
 
         Args:
             filter_ancillas: If set to ``True`` any ancilla qubits added
@@ -531,16 +603,15 @@ class TranspileLayout:
         return output
 
     def routing_permutation(self) -> List[int]:
-        """Generate a final layout as an array of integers
+        """Generate a final layout as an array of integers.
 
         If there is no :attr:`.final_layout` attribute present then that indicates
         there was no output permutation caused by routing or other transpiler
-        transforms. In this case the function will return a list of ``[0, 1, 2, .., n]``
-        to indicate this
+        transforms. In this case the function will return a list of ``[0, 1, 2, .., n]``.
 
         Returns:
             A layout array that maps a position in the array to its new position in the output
-            circuit
+            circuit.
         """
         if self.final_layout is None:
             return list(range(len(self._output_qubit_list)))
@@ -548,9 +619,9 @@ class TranspileLayout:
         return [virtual_map[virt] for virt in self._output_qubit_list]
 
     def final_index_layout(self, filter_ancillas: bool = True) -> List[int]:
-        """Generate the final layout as an array of integers
+        """Generate the final layout as an array of integers.
 
-        This method will generate an array of final positions for each qubit in the output circuit.
+        This method will generate an array of final positions for each qubit in the input circuit.
         For example, if you had an input circuit like::
 
             qc = QuantumCircuit(3)
@@ -561,18 +632,22 @@ class TranspileLayout:
         and the output from the transpiler was::
 
             tqc = QuantumCircuit(3)
-            qc.h(2)
-            qc.cx(2, 1)
-            qc.swap(0, 1)
-            qc.cx(2, 1)
+            tqc.h(2)
+            tqc.cx(2, 1)
+            tqc.swap(0, 1)
+            tqc.cx(2, 1)
 
-        then the return from this function would be a list of::
+        then the :meth:`.final_index_layout` method returns::
 
             [2, 0, 1]
 
-        because qubit 0 in the original circuit's final state is on qubit 3 in the output circuit,
-        qubit 1 in the original circuit's final state is on qubit 0, and qubit 2's final state is
-        on qubit. The output list length will be as wide as the input circuit's number of qubits,
+        This can be seen as follows. Qubit 0 in the original circuit is mapped to qubit 2
+        in the output circuit during the layout stage, which is mapped to qubit 2 during the
+        routing stage. Qubit 1 in the original circuit is mapped to qubit 1 in the output
+        circuit during the layout stage, which is mapped to qubit 0 during the routing
+        stage. Qubit 2 in the original circuit is mapped to qubit 0 in the output circuit
+        during the layout stage, which is mapped to qubit 1 during the routing stage.
+        The output list length will be as wide as the input circuit's number of qubits,
         as the output list from this method is for tracking the permutation of qubits in the
         original circuit caused by the transpiler.
 
@@ -581,7 +656,7 @@ class TranspileLayout:
                 included in the layout.
 
         Returns:
-            A list of final positions for each input circuit qubit
+            A list of final positions for each input circuit qubit.
         """
         if self._input_qubit_count is None:
             # TODO: After there is a way to differentiate the ancilla qubits added by the transpiler
@@ -614,9 +689,9 @@ class TranspileLayout:
         return qubit_indices
 
     def final_virtual_layout(self, filter_ancillas: bool = True) -> Layout:
-        """Generate the final layout as a :class:`.Layout` object
+        """Generate the final layout as a :class:`.Layout` object.
 
-        This method will generate an array of final positions for each qubit in the output circuit.
+        This method will generate an array of final positions for each qubit in the input circuit.
         For example, if you had an input circuit like::
 
             qc = QuantumCircuit(3)
@@ -627,10 +702,10 @@ class TranspileLayout:
         and the output from the transpiler was::
 
             tqc = QuantumCircuit(3)
-            qc.h(2)
-            qc.cx(2, 1)
-            qc.swap(0, 1)
-            qc.cx(2, 1)
+            tqc.h(2)
+            tqc.cx(2, 1)
+            tqc.swap(0, 1)
+            tqc.cx(2, 1)
 
         then the return from this function would be a layout object::
 
@@ -640,9 +715,13 @@ class TranspileLayout:
                 qc.qubits[2]: 1,
             })
 
-        because qubit 0 in the original circuit's final state is on qubit 3 in the output circuit,
-        qubit 1 in the original circuit's final state is on qubit 0, and qubit 2's final state is
-        on qubit. The output list length will be as wide as the input circuit's number of qubits,
+        This can be seen as follows. Qubit 0 in the original circuit is mapped to qubit 2
+        in the output circuit during the layout stage, which is mapped to qubit 2 during the
+        routing stage. Qubit 1 in the original circuit is mapped to qubit 1 in the output
+        circuit during the layout stage, which is mapped to qubit 0 during the routing
+        stage. Qubit 2 in the original circuit is mapped to qubit 0 in the output circuit
+        during the layout stage, which is mapped to qubit 1 during the routing stage.
+        The output list length will be as wide as the input circuit's number of qubits,
         as the output list from this method is for tracking the permutation of qubits in the
         original circuit caused by the transpiler.
 
@@ -651,7 +730,7 @@ class TranspileLayout:
                 included in the layout.
 
         Returns:
-            A layout object mapping to the final positions for each qubit
+            A layout object mapping to the final positions for each qubit.
         """
         res = self.final_index_layout(filter_ancillas=filter_ancillas)
         pos_to_virt = {v: k for k, v in self.input_qubit_mapping.items()}

qiskit/transpiler/passes/__init__.py

@@ -46,6 +46,7 @@ Routing
    StochasticSwap
    SabreSwap
    Commuting2qGateRouter
+   StarPreRouting
 
 Basis Change
 ============
@@ -81,11 +82,13 @@ Optimizations
    Optimize1qGatesSimpleCommutation
    RemoveDiagonalGatesBeforeMeasure
    RemoveResetInZeroState
+   RemoveFinalReset
    HoareOptimizer
    TemplateOptimization
    EchoRZXWeylDecomposition
    ResetAfterMeasureSimplification
    OptimizeCliffords
+   ElidePermutations
    NormalizeRXAngle
    OptimizeAnnotated
 
@@ -151,8 +154,10 @@ The synthesis transpiler plugin documentation can be found in the
    HLSConfig
    SolovayKitaev
 
-Post Layout (Post transpile qubit selection)
-============================================
+Post Layout
+===========
+
+These are post qubit selection.
 
 .. autosummary::
    :toctree: ../stubs/
@@ -203,6 +208,7 @@ from .routing import LookaheadSwap
 from .routing import StochasticSwap
 from .routing import SabreSwap
 from .routing import Commuting2qGateRouter
+from .routing import StarPreRouting
 
 # basis change
 from .basis import Decompose
@@ -225,6 +231,7 @@ from .optimization import CXCancellation
 from .optimization import Optimize1qGatesSimpleCommutation
 from .optimization import OptimizeSwapBeforeMeasure
 from .optimization import RemoveResetInZeroState
+from .optimization import RemoveFinalReset
 from .optimization import RemoveDiagonalGatesBeforeMeasure
 from .optimization import HoareOptimizer
 from .optimization import TemplateOptimization
@@ -234,6 +241,7 @@ from .optimization import CollectLinearFunctions
 from .optimization import CollectCliffords
 from .optimization import ResetAfterMeasureSimplification
 from .optimization import OptimizeCliffords
+from .optimization import ElidePermutations
 from .optimization import NormalizeRXAngle
 from .optimization import OptimizeAnnotated
 

qiskit/transpiler/passes/basis/basis_translator.py

@@ -97,8 +97,8 @@ class BasisTranslator(TransformationPass):
 
     When this error occurs it typically means that either the target basis
     is not universal or there are additional equivalence rules needed in the
-    :clas:~.EquivalenceLibrary` instance being used by the
-    :class:~.BasisTranslator` pass. You can refer to
+    :class:`~.EquivalenceLibrary` instance being used by the
+    :class:`~.BasisTranslator` pass. You can refer to
     :ref:`custom_basis_gates` for details on adding custom equivalence rules.
     """
 
@@ -148,16 +148,21 @@ class BasisTranslator(TransformationPass):
 
         # Names of instructions assumed to supported by any backend.
         if self._target is None:
-            basic_instrs = ["measure", "reset", "barrier", "snapshot", "delay"]
+            basic_instrs = ["measure", "reset", "barrier", "snapshot", "delay", "store"]
             target_basis = set(self._target_basis)
             source_basis = set(self._extract_basis(dag))
             qargs_local_source_basis = {}
         else:
-            basic_instrs = ["barrier", "snapshot"]
+            basic_instrs = ["barrier", "snapshot", "store"]
             target_basis = self._target.keys() - set(self._non_global_operations)
             source_basis, qargs_local_source_basis = self._extract_basis_target(dag, qarg_indices)
 
         target_basis = set(target_basis).union(basic_instrs)
+        # 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:
+            return dag
 
         logger.info(
             "Begin BasisTranslator from source basis %s to target basis %s.",

qiskit/transpiler/passes/basis/unroll_3q_or_more.py

@@ -63,7 +63,7 @@ class Unroll3qOrMore(TransformationPass):
 
             if self.target is not None:
                 # Treat target instructions as global since this pass can be run
-                # prior to layout and routing we don't have phsyical qubits from
+                # prior to layout and routing we don't have physical qubits from
                 # the circuit yet
                 if node.name in self.target:
                     continue