qiskit 1.1.0rc1__cp38-abi3-win_amd64.whl → 1.1.2__cp38-abi3-win_amd64.whl

qiskit/synthesis/discrete_basis/generate_basis_approximations.py

@@ -156,7 +156,7 @@ def generate_basic_approximations(
         data = {}
         for sequence in sequences:
             gatestring = sequence.name
-            data[gatestring] = sequence.product
+            data[gatestring] = (sequence.product, sequence.global_phase)
 
         np.save(filename, data)
 

qiskit/synthesis/discrete_basis/solovay_kitaev.py

@@ -16,8 +16,6 @@ from __future__ import annotations
 
 import numpy as np
 
-from qiskit.circuit.gate import Gate
-
 from .gate_sequence import GateSequence
 from .commutator_decompose import commutator_decompose
 from .generate_basis_approximations import generate_basic_approximations, _1q_gates, _1q_inverses
@@ -53,14 +51,19 @@ class SolovayKitaevDecomposition:
 
         self.basic_approximations = self.load_basic_approximations(basic_approximations)
 
-    def load_basic_approximations(self, data: list | str | dict) -> list[GateSequence]:
+    @staticmethod
+    def load_basic_approximations(data: list | str | dict) -> list[GateSequence]:
         """Load basic approximations.
 
         Args:
             data: If a string, specifies the path to the file from where to load the data.
-                If a dictionary, directly specifies the decompositions as ``{gates: matrix}``.
-                There ``gates`` are the names of the gates producing the SO(3) matrix ``matrix``,
-                e.g. ``{"h t": np.array([[0, 0.7071, -0.7071], [0, -0.7071, -0.7071], [-1, 0, 0]]}``.
+                If a dictionary, directly specifies the decompositions as ``{gates: matrix}``
+                or ``{gates: (matrix, global_phase)}``. There, ``gates`` are the names of the gates
+                producing the SO(3) matrix ``matrix``, e.g.
+                ``{"h t": np.array([[0, 0.7071, -0.7071], [0, -0.7071, -0.7071], [-1, 0, 0]]}``
+                and the ``global_phase`` can be given to account for a global phase difference
+                between the U(2) matrix of the quantum gates and the stored SO(3) matrix.
+                If not given, the ``global_phase`` will be assumed to be 0.
 
         Returns:
             A list of basic approximations as type ``GateSequence``.
@@ -74,13 +77,20 @@ class SolovayKitaevDecomposition:
 
         # if a file, load the dictionary
         if isinstance(data, str):
-            data = np.load(data, allow_pickle=True)
+            data = np.load(data, allow_pickle=True).item()
 
         sequences = []
-        for gatestring, matrix in data.items():
+        for gatestring, matrix_and_phase in data.items():
+            if isinstance(matrix_and_phase, tuple):
+                matrix, global_phase = matrix_and_phase
+            else:
+                matrix, global_phase = matrix_and_phase, 0
+
             sequence = GateSequence()
             sequence.gates = [_1q_gates[element] for element in gatestring.split()]
+            sequence.labels = [gate.name for gate in sequence.gates]
             sequence.product = np.asarray(matrix)
+            sequence.global_phase = global_phase
             sequences.append(sequence)
 
         return sequences
@@ -157,14 +167,14 @@ class SolovayKitaevDecomposition:
         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)
 
-    def find_basic_approximation(self, sequence: GateSequence) -> Gate:
-        """Finds gate in ``self._basic_approximations`` that best represents ``sequence``.
+    def find_basic_approximation(self, sequence: GateSequence) -> GateSequence:
+        """Find ``GateSequence`` in ``self._basic_approximations`` that approximates ``sequence``.
 
         Args:
-            sequence: The gate to find the approximation to.
+            sequence: ``GateSequence`` to find the approximation to.
 
         Returns:
-            Gate in basic approximations that is closest to ``sequence``.
+            ``GateSequence`` in ``self._basic_approximations`` that approximates ``sequence``.
         """
         # TODO explore using a k-d tree here
 

qiskit/transpiler/__init__.py

@@ -650,8 +650,6 @@ manner to the "physical" qubits in an actual quantum device.
 .. image:: /source_images/mapping.png
 
 
-
-
 By default, qiskit will do this mapping for you.  The choice of mapping depends on the
 properties of the circuit, the particular device you are targeting, and the optimization
 level that is chosen. The choice of initial layout is extremely important for minimizing the
@@ -684,10 +682,12 @@ Next, for the heuristic stage, 2 passes are used by default:
   :class:`~.SabreLayout` is used to select a layout if a perfect layout isn't found for
   optimization levels 1, 2, and 3.
 - :class:`~.TrivialLayout`: Always used for the layout at optimization level 0.
+
+There are other passes than can be used for the heuristic stage, but are not included in the default
+pipeline, such as:
+
 - :class:`~.DenseLayout`: Finds the sub-graph of the device with greatest connectivity
-  that has the same number of qubits as the circuit. Used for
-  optimization level 1 if there are control flow operations (such as
-  :class:`~.IfElseOp`) present in the circuit.
+  that has the same number of qubits as the circuit.
 
 Let's see what layouts are automatically picked at various optimization levels.  The circuits
 returned by :func:`qiskit.compiler.transpile` are annotated with this initial layout information,

qiskit/transpiler/layout.py

@@ -454,7 +454,7 @@ class TranspileLayout:
     qubits in the circuit as it fits the circuit to the target backend. For example,
     let the input circuit be:
 
-    .. plot:
+    .. plot::
        :include-source:
 
        from qiskit.circuit import QuantumCircuit, QuantumRegister
@@ -469,7 +469,7 @@ class TranspileLayout:
 
     Suppose that during the layout stage the transpiler reorders the qubits to be:
 
-    .. plot:
+    .. plot::
        :include-source:
 
        from qiskit import QuantumCircuit
@@ -497,7 +497,7 @@ class TranspileLayout:
     the transpiler needs to insert swap gates, and the output circuit
     becomes:
 
-    .. plot:
+    .. plot::
        :include-source:
 
        from qiskit import QuantumCircuit

qiskit/transpiler/passes/__init__.py

@@ -154,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/

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.
     """
 

qiskit/transpiler/passes/layout/vf2_layout.py

@@ -104,15 +104,21 @@ class VF2Layout(AnalysisPass):
                 limit on the number of trials will be set.
             target (Target): A target representing the backend device to run ``VF2Layout`` on.
                 If specified it will supersede a set value for ``properties`` and
-                ``coupling_map``.
+                ``coupling_map`` if the :class:`.Target` contains connectivity constraints. If the value
+                of ``target`` models an ideal backend without any constraints then the value of
+                ``coupling_map``
+                will be used.
 
         Raises:
             TypeError: At runtime, if neither ``coupling_map`` or ``target`` are provided.
         """
         super().__init__()
         self.target = target
-        if target is not None:
-            self.coupling_map = self.target.build_coupling_map()
+        if (
+            target is not None
+            and (target_coupling_map := self.target.build_coupling_map()) is not None
+        ):
+            self.coupling_map = target_coupling_map
         else:
             self.coupling_map = coupling_map
         self.properties = properties
@@ -145,7 +151,7 @@ class VF2Layout(AnalysisPass):
         )
         # Filter qubits without any supported operations. If they don't support any operations
         # They're not valid for layout selection
-        if self.target is not None:
+        if self.target is not None and self.target.qargs is not None:
             has_operations = set(itertools.chain.from_iterable(self.target.qargs))
             to_remove = set(range(len(cm_nodes))).difference(has_operations)
             if to_remove:

qiskit/transpiler/passes/layout/vf2_utils.py

@@ -145,7 +145,7 @@ def score_layout(
 def build_average_error_map(target, properties, coupling_map):
     """Build an average error map used for scoring layouts pre-basis translation."""
     num_qubits = 0
-    if target is not None:
+    if target is not None and target.qargs is not None:
         num_qubits = target.num_qubits
         avg_map = ErrorMap(len(target.qargs))
     elif coupling_map is not None:
@@ -157,7 +157,7 @@ def build_average_error_map(target, properties, coupling_map):
         # object
         avg_map = ErrorMap(0)
     built = False
-    if target is not None:
+    if target is not None and target.qargs is not None:
         for qargs in target.qargs:
             if qargs is None:
                 continue

qiskit/transpiler/passes/optimization/collect_cliffords.py

@@ -22,6 +22,7 @@ from qiskit.transpiler.passes.optimization.collect_and_collapse import (
 )
 
 from qiskit.quantum_info.operators import Clifford
+from qiskit.quantum_info.operators.symplectic.clifford_circuits import _BASIS_1Q, _BASIS_2Q
 
 
 class CollectCliffords(CollectAndCollapse):
@@ -69,21 +70,11 @@ class CollectCliffords(CollectAndCollapse):
         )
 
 
-clifford_gate_names = [
-    "x",
-    "y",
-    "z",
-    "h",
-    "s",
-    "sdg",
-    "cx",
-    "cy",
-    "cz",
-    "swap",
-    "clifford",
-    "linear_function",
-    "pauli",
-]
+clifford_gate_names = (
+    list(_BASIS_1Q.keys())
+    + list(_BASIS_2Q.keys())
+    + ["clifford", "linear_function", "pauli", "permutation"]
+)
 
 
 def _is_clifford_gate(node):

qiskit/transpiler/passes/routing/commuting_2q_gate_routing/commuting_2q_gate_router.py

@@ -160,8 +160,13 @@ class Commuting2qGateRouter(TransformationPass):
         if len(dag.qubits) != next(iter(dag.qregs.values())).size:
             raise TranspilerError("Circuit has qubits not contained in the qubit register.")
 
-        new_dag = dag.copy_empty_like()
+        # Fix output permutation -- copied from ElidePermutations
+        input_qubit_mapping = {qubit: index for index, qubit in enumerate(dag.qubits)}
+        self.property_set["original_layout"] = Layout(input_qubit_mapping)
+        if self.property_set["original_qubit_indices"] is None:
+            self.property_set["original_qubit_indices"] = input_qubit_mapping
 
+        new_dag = dag.copy_empty_like()
         current_layout = Layout.generate_trivial_layout(*dag.qregs.values())
 
         # Used to keep track of nodes that do not decompose using swap strategies.
@@ -183,6 +188,8 @@ class Commuting2qGateRouter(TransformationPass):
 
         self._compose_non_swap_nodes(accumulator, current_layout, new_dag)
 
+        self.property_set["virtual_permutation_layout"] = current_layout
+
         return new_dag
 
     def _compose_non_swap_nodes(

qiskit/transpiler/passes/routing/commuting_2q_gate_routing/pauli_2q_evolution_commutation.py

@@ -51,7 +51,11 @@ class FindCommutingPauliEvolutions(TransformationPass):
                     sub_dag = self._decompose_to_2q(dag, node.op)
 
                     block_op = Commuting2qBlock(set(sub_dag.op_nodes()))
-                    wire_order = {wire: idx for idx, wire in enumerate(dag.qubits)}
+                    wire_order = {
+                        wire: idx
+                        for idx, wire in enumerate(sub_dag.qubits)
+                        if wire not in sub_dag.idle_wires()
+                    }
                     dag.replace_block_with_op([node], block_op, wire_order)
 
         return dag

qiskit/transpiler/passes/routing/star_prerouting.py

@@ -329,13 +329,13 @@ class StarPreRouting(TransformationPass):
             last_2q_gate = None
 
         int_digits = floor(log10(len(processing_order))) + 1
-        processing_order_s = set(processing_order)
+        processing_order_index_map = {
+            node: f"a{str(index).zfill(int(int_digits))}"
+            for index, node in enumerate(processing_order)
+        }
 
         def tie_breaker_key(node):
-            if node in processing_order_s:
-                return "a" + str(processing_order.index(node)).zfill(int(int_digits))
-            else:
-                return node.sort_key
+            return processing_order_index_map.get(node, node.sort_key)
 
         for node in dag.topological_op_nodes(key=tie_breaker_key):
             block_id = node_to_block_id.get(node, None)

qiskit/transpiler/passes/synthesis/unitary_synthesis.py

@@ -49,6 +49,7 @@ from qiskit.circuit.library.standard_gates import (
     CZGate,
     RXXGate,
     RZXGate,
+    RZZGate,
     ECRGate,
 )
 from qiskit.transpiler.passes.synthesis import plugin
@@ -744,6 +745,8 @@ class DefaultUnitarySynthesis(plugin.UnitarySynthesisPlugin):
                 op = RXXGate(pi / 2)
             elif isinstance(op, RZXGate) and isinstance(op.params[0], Parameter):
                 op = RZXGate(pi / 4)
+            elif isinstance(op, RZZGate) and isinstance(op.params[0], Parameter):
+                op = RZZGate(pi / 2)
             return op
 
         try:

qiskit/transpiler/preset_passmanagers/__init__.py

@@ -96,11 +96,37 @@ def generate_preset_pass_manager(
 ):
     """Generate a preset :class:`~.PassManager`
 
-    This function is used to quickly generate a preset pass manager. A preset pass
-    manager are the default pass managers used by the :func:`~.transpile`
+    This function is used to quickly generate a preset pass manager. Preset pass
+    managers are the default pass managers used by the :func:`~.transpile`
     function. This function provides a convenient and simple method to construct
-    a standalone :class:`~.PassManager` object that mirrors what the transpile
+    a standalone :class:`~.PassManager` object that mirrors what the :func:`~.transpile`
+    function internally builds and uses.
 
+    The target constraints for the pass manager construction can be specified through a :class:`.Target`
+    instance, a :class:`.BackendV1` or :class:`.BackendV2` instance, or via loose constraints
+    (``basis_gates``, ``inst_map``, ``coupling_map``, ``backend_properties``, ``instruction_durations``,
+    ``dt`` or ``timing_constraints``).
+    The order of priorities for target constraints works as follows: if a ``target``
+    input is provided, it will take priority over any ``backend`` input or loose constraints.
+    If a ``backend`` is provided together with any loose constraint
+    from the list above, the loose constraint will take priority over the corresponding backend
+    constraint. This behavior is independent of whether the ``backend`` instance is of type
+    :class:`.BackendV1` or :class:`.BackendV2`, as summarized in the table below. The first column
+    in the table summarizes the potential user-provided constraints, and each cell shows whether
+    the priority is assigned to that specific constraint input or another input
+    (`target`/`backend(V1)`/`backend(V2)`).
+
+    ============================ ========= ======================== =======================
+    User Provided                target    backend(V1)              backend(V2)
+    ============================ ========= ======================== =======================
+    **basis_gates**              target    basis_gates              basis_gates
+    **coupling_map**             target    coupling_map             coupling_map
+    **instruction_durations**    target    instruction_durations    instruction_durations
+    **inst_map**                 target    inst_map                 inst_map
+    **dt**                       target    dt                       dt
+    **timing_constraints**       target    timing_constraints       timing_constraints
+    **backend_properties**       target    backend_properties       backend_properties
+    ============================ ========= ======================== =======================
 
     Args:
         optimization_level (int): The optimization level to generate a

qiskit/transpiler/target.py

@@ -890,7 +890,7 @@ class Target(Mapping):
             return False
         if qargs not in self._gate_map[operation_name]:
             return False
-        return getattr(self._gate_map[operation_name][qargs], "_calibration") is not None
+        return getattr(self._gate_map[operation_name][qargs], "_calibration", None) is not None
 
     def get_calibration(
         self,

qiskit/utils/__init__.py

@@ -44,7 +44,7 @@ Multiprocessing
 .. autofunction:: local_hardware_info
 .. autofunction:: is_main_process
 
-A helper function for calling a custom function with python
+A helper function for calling a custom function with Python
 :class:`~concurrent.futures.ProcessPoolExecutor`. Tasks can be executed in parallel using this function.
 
 .. autofunction:: parallel_map
@@ -70,7 +70,7 @@ from .lazy_tester import LazyDependencyManager, LazyImportTester, LazySubprocess
 
 from . import optionals
 
-from .parallel import parallel_map
+from .parallel import parallel_map, should_run_in_parallel
 
 __all__ = [
     "LazyDependencyManager",
@@ -85,4 +85,5 @@ __all__ = [
     "is_main_process",
     "apply_prefix",
     "parallel_map",
+    "should_run_in_parallel",
 ]

qiskit/utils/parallel.py

@@ -48,6 +48,8 @@ Routines for running Python functions in parallel using process pools
 from the multiprocessing library.
 """
 
+from __future__ import annotations
+
 import os
 from concurrent.futures import ProcessPoolExecutor
 import sys
@@ -101,6 +103,21 @@ def _task_wrapper(param):
     return task(value, *task_args, **task_kwargs)
 
 
+def should_run_in_parallel(num_processes: int | None = None) -> bool:
+    """Return whether the current parallelisation configuration suggests that we should run things
+    like :func:`parallel_map` in parallel (``True``) or degrade to serial (``False``).
+
+    Args:
+        num_processes: the number of processes requested for use (if given).
+    """
+    num_processes = CPU_COUNT if num_processes is None else num_processes
+    return (
+        num_processes > 1
+        and os.getenv("QISKIT_IN_PARALLEL", "FALSE") == "FALSE"
+        and CONFIG.get("parallel_enabled", PARALLEL_DEFAULT)
+    )
+
+
 def parallel_map(  # pylint: disable=dangerous-default-value
     task, values, task_args=(), task_kwargs={}, num_processes=CPU_COUNT
 ):
@@ -110,21 +127,20 @@ def parallel_map(  # pylint: disable=dangerous-default-value
 
         result = [task(value, *task_args, **task_kwargs) for value in values]
 
-    On Windows this function defaults to a serial implementation to avoid the
-    overhead from spawning processes in Windows.
+    This will parallelise the results if the number of ``values`` is greater than one, and the
+    current system configuration permits parallelization.
 
     Args:
         task (func): Function that is to be called for each value in ``values``.
-        values (array_like): List or array of values for which the ``task``
-                            function is to be evaluated.
+        values (array_like): List or array of values for which the ``task`` function is to be
+            evaluated.
         task_args (list): Optional additional arguments to the ``task`` function.
         task_kwargs (dict): Optional additional keyword argument to the ``task`` function.
         num_processes (int): Number of processes to spawn.
 
     Returns:
-        result: The result list contains the value of
-                ``task(value, *task_args, **task_kwargs)`` for
-                    each value in ``values``.
+        result: The result list contains the value of ``task(value, *task_args, **task_kwargs)`` for
+        each value in ``values``.
 
     Raises:
         QiskitError: If user interrupts via keyboard.
@@ -147,12 +163,7 @@ def parallel_map(  # pylint: disable=dangerous-default-value
     if len(values) == 1:
         return [task(values[0], *task_args, **task_kwargs)]
 
-    # Run in parallel if not Win and not in parallel already
-    if (
-        num_processes > 1
-        and os.getenv("QISKIT_IN_PARALLEL") == "FALSE"
-        and CONFIG.get("parallel_enabled", PARALLEL_DEFAULT)
-    ):
+    if should_run_in_parallel(num_processes):
         os.environ["QISKIT_IN_PARALLEL"] = "TRUE"
         try:
             results = []
@@ -173,8 +184,6 @@ def parallel_map(  # pylint: disable=dangerous-default-value
         os.environ["QISKIT_IN_PARALLEL"] = "FALSE"
         return results
 
-    # Cannot do parallel on Windows , if another parallel_map is running in parallel,
-    # or len(values) == 1.
     results = []
     for _, value in enumerate(values):
         result = task(value, *task_args, **task_kwargs)

qiskit/visualization/bloch.py

@@ -50,6 +50,7 @@ __all__ = ["Bloch"]
 
 import math
 import os
+import re
 import numpy as np
 import matplotlib
 import matplotlib.pyplot as plt
@@ -60,6 +61,47 @@ from mpl_toolkits.mplot3d.art3d import Patch3D
 from .utils import matplotlib_close_if_inline
 
 
+# This version pattern is taken from the pypa packaging project:
+# https://github.com/pypa/packaging/blob/21.3/packaging/version.py#L223-L254
+# which is dual licensed Apache 2.0 and BSD see the source for the original
+# authors and other details
+VERSION_PATTERN = (
+    "^"
+    + r"""
+    v?
+    (?:
+        (?:(?P<epoch>[0-9]+)!)?                           # epoch
+        (?P<release>[0-9]+(?:\.[0-9]+)*)                  # release segment
+        (?P<pre>                                          # pre-release
+            [-_\.]?
+            (?P<pre_l>(a|b|c|rc|alpha|beta|pre|preview))
+            [-_\.]?
+            (?P<pre_n>[0-9]+)?
+        )?
+        (?P<post>                                         # post release
+            (?:-(?P<post_n1>[0-9]+))
+            |
+            (?:
+                [-_\.]?
+                (?P<post_l>post|rev|r)
+                [-_\.]?
+                (?P<post_n2>[0-9]+)?
+            )
+        )?
+        (?P<dev>                                          # dev release
+            [-_\.]?
+            (?P<dev_l>dev)
+            [-_\.]?
+            (?P<dev_n>[0-9]+)?
+        )?
+    )
+    (?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version
+"""
+    + "$"
+)
+VERSION_PATTERN_REGEX = re.compile(VERSION_PATTERN, re.VERBOSE | re.IGNORECASE)
+
+
 class Arrow3D(Patch3D, FancyArrowPatch):
     """Makes a fancy arrow"""
 
@@ -419,7 +461,8 @@ class Bloch:
             self.fig = plt.figure(figsize=self.figsize)
 
         if not self._ext_axes:
-            if tuple(int(x) for x in matplotlib.__version__.split(".")) >= (3, 4, 0):
+            version_match = VERSION_PATTERN_REGEX.search(matplotlib.__version__)
+            if tuple(int(x) for x in version_match.group("release").split(".")) >= (3, 4, 0):
                 self.axes = Axes3D(
                     self.fig, azim=self.view[0], elev=self.view[1], auto_add_to_figure=False
                 )

qiskit/visualization/dag_visualization.py

@@ -174,10 +174,13 @@ def dag_drawer(dag, scale=0.7, filename=None, style="color"):
                         label = register_bit_labels.get(
                             node.wire, f"q_{dag.find_bit(node.wire).index}"
                         )
-                    else:
+                    elif isinstance(node.wire, Clbit):
                         label = register_bit_labels.get(
                             node.wire, f"c_{dag.find_bit(node.wire).index}"
                         )
+                    else:
+                        label = str(node.wire.name)
+
                     n["label"] = label
                     n["color"] = "black"
                     n["style"] = "filled"
@@ -187,10 +190,12 @@ def dag_drawer(dag, scale=0.7, filename=None, style="color"):
                         label = register_bit_labels.get(
                             node.wire, f"q[{dag.find_bit(node.wire).index}]"
                         )
-                    else:
+                    elif isinstance(node.wire, Clbit):
                         label = register_bit_labels.get(
                             node.wire, f"c[{dag.find_bit(node.wire).index}]"
                         )
+                    else:
+                        label = str(node.wire.name)
                     n["label"] = label
                     n["color"] = "black"
                     n["style"] = "filled"
@@ -203,8 +208,10 @@ def dag_drawer(dag, scale=0.7, filename=None, style="color"):
             e = {}
             if isinstance(edge, Qubit):
                 label = register_bit_labels.get(edge, f"q_{dag.find_bit(edge).index}")
-            else:
+            elif isinstance(edge, Clbit):
                 label = register_bit_labels.get(edge, f"c_{dag.find_bit(edge).index}")
+            else:
+                label = str(edge.name)
             e["label"] = label
             return e
 

qiskit/visualization/gate_map.py

@@ -1039,7 +1039,9 @@ def plot_coupling_map(
         graph = CouplingMap(coupling_map).graph
 
     if not plot_directed:
+        line_color_map = dict(zip(graph.edge_list(), line_color))
         graph = graph.to_undirected(multigraph=False)
+        line_color = [line_color_map[edge] for edge in graph.edge_list()]
 
     for node in graph.node_indices():
         graph[node] = node
@@ -1122,7 +1124,13 @@ def plot_circuit_layout(circuit, backend, view="virtual", qubit_coordinates=None
     Args:
         circuit (QuantumCircuit): Input quantum circuit.
         backend (Backend): Target backend.
-        view (str): Layout view: either 'virtual' or 'physical'.
+        view (str): How to label qubits in the layout. Options:
+
+          - ``"virtual"``: Label each qubit with the index of the virtual qubit that
+            mapped to it.
+          - ``"physical"``: Label each qubit with the index of the physical qubit that it
+            corresponds to on the device.
+
         qubit_coordinates (Sequence): An optional sequence input (list or array being the
             most common) of 2d coordinates for each qubit. The length of the
             sequence must match the number of qubits on the backend. The sequence