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

qiskit/transpiler/passes/synthesis/high_level_synthesis.py

@@ -968,6 +968,10 @@ class QFTSynthesisFull(HighLevelSynthesisPlugin):
     This plugin name is :``qft.full`` which can be used as the key on
     an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
 
+    Note that the plugin mechanism is not applied if the gate is called ``qft`` but
+    is not an instance of ``QFTGate``. This allows users to create custom gates with
+    name ``qft``.
+
     The plugin supports the following additional options:
 
     * reverse_qubits (bool): Whether to synthesize the "QFT" operation (if ``False``,
@@ -995,10 +999,11 @@ class QFTSynthesisFull(HighLevelSynthesisPlugin):
 
     def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
         """Run synthesis for the given QFTGate."""
+
+        # Even though the gate is called "qft", it's not a QFTGate,
+        # and we should not synthesize it using the plugin.
         if not isinstance(high_level_object, QFTGate):
-            raise TranspilerError(
-                "The synthesis plugin 'qft.full` only applies to objects of type QFTGate."
-            )
+            return None
 
         reverse_qubits = options.get("reverse_qubits", False)
         approximation_degree = options.get("approximation_degree", 0)
@@ -1023,6 +1028,10 @@ class QFTSynthesisLine(HighLevelSynthesisPlugin):
     This plugin name is :``qft.line`` which can be used as the key on
     an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
 
+    Note that the plugin mechanism is not applied if the gate is called ``qft`` but
+    is not an instance of ``QFTGate``. This allows users to create custom gates with
+    name ``qft``.
+
     The plugin supports the following additional options:
 
     * reverse_qubits (bool): Whether to synthesize the "QFT" operation (if ``False``,
@@ -1047,10 +1056,11 @@ class QFTSynthesisLine(HighLevelSynthesisPlugin):
 
     def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
         """Run synthesis for the given QFTGate."""
+
+        # Even though the gate is called "qft", it's not a QFTGate,
+        # and we should not synthesize it using the plugin.
         if not isinstance(high_level_object, QFTGate):
-            raise TranspilerError(
-                "The synthesis plugin 'qft.line` only applies to objects of type QFTGate."
-            )
+            return None
 
         reverse_qubits = options.get("reverse_qubits", False)
         approximation_degree = options.get("approximation_degree", 0)

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
@@ -152,7 +150,8 @@ class DefaultInitPassManager(PassManagerStagePlugin):
                 pass_manager_config.unitary_synthesis_plugin_config,
                 pass_manager_config.hls_config,
             )
-            init.append(ElidePermutations())
+            if pass_manager_config.routing_method != "none":
+                init.append(ElidePermutations())
             init.append(RemoveDiagonalGatesBeforeMeasure())
             init.append(
                 InverseCancellation(
@@ -173,58 +172,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

qiskit/utils/optionals.py

@@ -25,172 +25,195 @@ Available Testers
 Qiskit Components
 -----------------
 
-.. list-table::
-    :widths: 25 75
+.. py:data:: HAS_AER
 
-    * - .. py:data:: HAS_AER
-      - `Qiskit Aer <https://qiskit.github.io/qiskit-aer/>` provides high-performance simulators for
-        the quantum circuits constructed within Qiskit.
+    `Qiskit Aer <https://qiskit.github.io/qiskit-aer/>` provides high-performance simulators for
+    the quantum circuits constructed within Qiskit.
 
-    * - .. py:data:: HAS_IBMQ
-      - The :mod:`Qiskit IBMQ Provider <qiskit.providers.ibmq>` is used for accessing IBM Quantum
-        hardware in the IBM cloud.
+.. py:data:: HAS_IBMQ
 
-    * - .. py:data:: HAS_IGNIS
-      - :mod:`Qiskit Ignis <qiskit.ignis>` provides tools for quantum hardware verification, noise
-        characterization, and error correction.
+    The :mod:`Qiskit IBMQ Provider <qiskit.providers.ibmq>` is used for accessing IBM Quantum
+    hardware in the IBM cloud.
 
-    * - .. py:data:: HAS_TOQM
-      - `Qiskit TOQM <https://github.com/qiskit-toqm/qiskit-toqm>`__ provides transpiler passes
-        for the `Time-optimal Qubit mapping algorithm <https://doi.org/10.1145/3445814.3446706>`__.
+.. py:data:: HAS_IGNIS
+
+    :mod:`Qiskit Ignis <qiskit.ignis>` provides tools for quantum hardware verification, noise
+    characterization, and error correction.
+
+.. py:data:: HAS_TOQM
+
+    `Qiskit TOQM <https://github.com/qiskit-toqm/qiskit-toqm>`__ provides transpiler passes
+    for the `Time-optimal Qubit mapping algorithm <https://doi.org/10.1145/3445814.3446706>`__.
 
 
 External Python Libraries
 -------------------------
 
-.. list-table::
-    :widths: 25 75
-
-    * - .. py:data:: HAS_CONSTRAINT
-      - `python-constraint <https://github.com/python-constraint/python-constraint>`__ is a
-        constraint satisfaction problem solver, used in the :class:`~.CSPLayout` transpiler pass.
-
-    * - .. py:data:: HAS_CPLEX
-      - The `IBM CPLEX Optimizer <https://www.ibm.com/analytics/cplex-optimizer>`__ is a
-        high-performance mathematical programming solver for linear, mixed-integer and quadratic
-        programming. This is no longer by Qiskit, but it weas historically and the optional
-        remains for backwards compatibility.
-
-    * - .. py:data:: HAS_CVXPY
-      - `CVXPY <https://www.cvxpy.org/>`__ is a Python package for solving convex optimization
-        problems.  It is required for calculating diamond norms with
-        :func:`.quantum_info.diamond_norm`.
-
-    * - .. py:data:: HAS_DOCPLEX
-      - `IBM Decision Optimization CPLEX Modelling
-        <http://ibmdecisionoptimization.github.io/docplex-doc/>`__ is a library for prescriptive
-        analysis.  Like CPLEX, this is no longer by Qiskit, but it weas historically and the
-        optional remains for backwards compatibility.
-
-    * - .. py:data:: HAS_FIXTURES
-      - The test suite has additional features that are available if the optional `fixtures
-        <https://launchpad.net/python-fixtures>`__ module is installed.  This generally also needs
-        :data:`HAS_TESTTOOLS` as well.  This is generally only needed for Qiskit developers.
-
-    * - .. py:data:: HAS_IPYTHON
-      - If `the IPython kernel <https://ipython.org/>`__ is available, certain additional
-        visualizations and line magics are made available.
-
-    * - .. py:data:: HAS_IPYWIDGETS
-      - Monitoring widgets for jobs running on external backends can be provided if `ipywidgets
-        <https://ipywidgets.readthedocs.io/en/latest/>`__ is available.
-
-    * - .. py:data:: HAS_JAX
-      - Some methods of gradient calculation within :mod:`.opflow.gradients` require `JAX
-        <https://github.com/google/jax>`__ for autodifferentiation.
-
-    * - .. py:data:: HAS_JUPYTER
-      - Some of the tests require a complete `Jupyter <https://jupyter.org/>`__ installation to test
-        interactivity features.
-
-    * - .. py:data:: HAS_MATPLOTLIB
-      - Qiskit provides several visualization tools in the :mod:`.visualization` module.
-        Almost all of these are built using `Matplotlib <https://matplotlib.org/>`__, which must
-        be installed in order to use them.
-
-    * - .. py:data:: HAS_NETWORKX
-      - No longer used by Qiskit.  Internally, Qiskit now uses the high-performance `rustworkx
-        <https://github.com/Qiskit/rustworkx>`__ library as a core dependency, and during the
-        change-over period, it was sometimes convenient to convert things into the Python-only
-        `NetworkX <https://networkx.org/>`__ format.  Some tests of application modules, such as
-        `Qiskit Nature <https://qiskit-community.github.io/qiskit-nature/>`__ still use NetworkX.
-
-    * - .. py:data:: HAS_NLOPT
-      - `NLopt <https://nlopt.readthedocs.io/en/latest/>`__ is a nonlinear optimization library,
-        used by the global optimizers in the :mod:`.algorithms.optimizers` module.
-
-    * - .. py:data:: HAS_PIL
-      - PIL is a Python image-manipulation library.  Qiskit actually uses the `pillow
-        <https://pillow.readthedocs.io/en/stable/>`__ fork of PIL if it is available when generating
-        certain visualizations, for example of both :class:`.QuantumCircuit` and
-        :class:`.DAGCircuit` in certain modes.
-
-    * - .. py:data:: HAS_PYDOT
-      - For some graph visualizations, Qiskit uses `pydot <https://github.com/pydot/pydot>`__ as an
-        interface to GraphViz (see :data:`HAS_GRAPHVIZ`).
-
-    * - .. py:data:: HAS_PYGMENTS
-      - Pygments is a code highlighter and formatter used by many environments that involve rich
-        display of code blocks, including Sphinx and Jupyter.  Qiskit uses this when producing rich
-        output for these environments.
-
-    * - .. py:data:: HAS_PYLATEX
-      - Various LaTeX-based visualizations, especially the circuit drawers, need access to the
-        `pylatexenc <https://github.com/phfaist/pylatexenc>`__ project to work correctly.
-
-    * - .. py:data:: HAS_QASM3_IMPORT
-      - The functions :func:`.qasm3.load` and :func:`.qasm3.loads` for importing OpenQASM 3 programs
-        into :class:`.QuantumCircuit` instances use `an external importer package
-        <https://qiskit.github.io/qiskit-qasm3-import>`__.
-
-    * - .. py:data:: HAS_SEABORN
-      - Qiskit provides several visualization tools in the :mod:`.visualization` module.  Some
-        of these are built using `Seaborn <https://seaborn.pydata.org/>`__, which must be installed
-        in order to use them.
-
-    * - .. py:data:: HAS_SKLEARN
-      - Some of the gradient functions in :mod:`.opflow.gradients` use regularisation methods from
-        `Scikit Learn <https://scikit-learn.org/stable/>`__.
-
-    * - .. py:data:: HAS_SKQUANT
-      - Some of the optimisers in :mod:`.algorithms.optimizers` are based on those found in `Scikit
-        Quant <https://github.com/scikit-quant/scikit-quant>`__, which must be installed to use
-        them.
-
-    * - .. py:data:: HAS_SQSNOBFIT
-      - `SQSnobFit <https://pypi.org/project/SQSnobFit/>`__ is a library for the "stable noisy
-        optimization by branch and fit" algorithm.  It is used by the :class:`.SNOBFIT` optimizer.
-
-    * - .. py:data:: HAS_SYMENGINE
-      - `Symengine <https://github.com/symengine/symengine>`__ is a fast C++ backend for the
-        symbolic-manipulation library `Sympy <https://www.sympy.org/en/index.html>`__.  Qiskit uses
-        special methods from Symengine to accelerate its handling of
-        :class:`~.circuit.Parameter`\\ s if available.
-
-    * - .. py:data:: HAS_TESTTOOLS
-      - Qiskit's test suite has more advanced functionality available if the optional
-        `testtools <https://pypi.org/project/testtools/>`__ library is installed.  This is generally
-        only needed for Qiskit developers.
-
-    * - .. py:data:: HAS_TWEEDLEDUM
-      - `Tweedledum <https://github.com/boschmitt/tweedledum>`__ is an extension library for
-        synthesis and optimization of circuits that may involve classical oracles.  Qiskit's
-        :class:`.PhaseOracle` uses this, which is used in turn by amplification algorithms via
-        the :class:`.AmplificationProblem`.
-
-    * - .. py:data:: HAS_Z3
-      - `Z3 <https://github.com/Z3Prover/z3>`__ is a theorem prover, used in the
-        :class:`.CrosstalkAdaptiveSchedule` and :class:`.HoareOptimizer` transpiler passes.
+.. py:data:: HAS_CONSTRAINT
+
+    `python-constraint <https://github.com/python-constraint/python-constraint>`__ is a
+    constraint satisfaction problem solver, used in the :class:`~.CSPLayout` transpiler pass.
+
+.. py:data:: HAS_CPLEX
+
+    The `IBM CPLEX Optimizer <https://www.ibm.com/analytics/cplex-optimizer>`__ is a
+    high-performance mathematical programming solver for linear, mixed-integer and quadratic
+    programming. This is no longer by Qiskit, but it weas historically and the optional
+    remains for backwards compatibility.
+
+.. py:data:: HAS_CVXPY
+
+    `CVXPY <https://www.cvxpy.org/>`__ is a Python package for solving convex optimization
+    problems.  It is required for calculating diamond norms with
+    :func:`.quantum_info.diamond_norm`.
+
+.. py:data:: HAS_DOCPLEX
+
+    `IBM Decision Optimization CPLEX Modelling
+    <http://ibmdecisionoptimization.github.io/docplex-doc/>`__ is a library for prescriptive
+    analysis.  Like CPLEX, this is no longer by Qiskit, but it weas historically and the
+    optional remains for backwards compatibility.
+
+.. py:data:: HAS_FIXTURES
+
+    The test suite has additional features that are available if the optional `fixtures
+    <https://launchpad.net/python-fixtures>`__ module is installed.  This generally also needs
+    :data:`HAS_TESTTOOLS` as well.  This is generally only needed for Qiskit developers.
+
+.. py:data:: HAS_IPYTHON
+
+    If `the IPython kernel <https://ipython.org/>`__ is available, certain additional
+    visualizations and line magics are made available.
+
+.. py:data:: HAS_IPYWIDGETS
+
+    Monitoring widgets for jobs running on external backends can be provided if `ipywidgets
+    <https://ipywidgets.readthedocs.io/en/latest/>`__ is available.
+
+.. py:data:: HAS_JAX
+
+    Some methods of gradient calculation within :mod:`.opflow.gradients` require `JAX
+    <https://github.com/google/jax>`__ for autodifferentiation.
+
+.. py:data:: HAS_JUPYTER
+
+    Some of the tests require a complete `Jupyter <https://jupyter.org/>`__ installation to test
+    interactivity features.
+
+.. py:data:: HAS_MATPLOTLIB
+
+    Qiskit provides several visualization tools in the :mod:`.visualization` module.
+    Almost all of these are built using `Matplotlib <https://matplotlib.org/>`__, which must
+    be installed in order to use them.
+
+.. py:data:: HAS_NETWORKX
+
+    No longer used by Qiskit.  Internally, Qiskit now uses the high-performance `rustworkx
+    <https://github.com/Qiskit/rustworkx>`__ library as a core dependency, and during the
+    change-over period, it was sometimes convenient to convert things into the Python-only
+    `NetworkX <https://networkx.org/>`__ format.  Some tests of application modules, such as
+    `Qiskit Nature <https://qiskit-community.github.io/qiskit-nature/>`__ still use NetworkX.
+
+.. py:data:: HAS_NLOPT
+
+    `NLopt <https://nlopt.readthedocs.io/en/latest/>`__ is a nonlinear optimization library,
+    used by the global optimizers in the :mod:`.algorithms.optimizers` module.
+
+.. py:data:: HAS_PIL
+
+    PIL is a Python image-manipulation library.  Qiskit actually uses the `pillow
+    <https://pillow.readthedocs.io/en/stable/>`__ fork of PIL if it is available when generating
+    certain visualizations, for example of both :class:`.QuantumCircuit` and
+    :class:`.DAGCircuit` in certain modes.
+
+.. py:data:: HAS_PYDOT
+
+    For some graph visualizations, Qiskit uses `pydot <https://github.com/pydot/pydot>`__ as an
+    interface to GraphViz (see :data:`HAS_GRAPHVIZ`).
+
+.. py:data:: HAS_PYGMENTS
+
+    Pygments is a code highlighter and formatter used by many environments that involve rich
+    display of code blocks, including Sphinx and Jupyter.  Qiskit uses this when producing rich
+    output for these environments.
+
+.. py:data:: HAS_PYLATEX
+
+    Various LaTeX-based visualizations, especially the circuit drawers, need access to the
+    `pylatexenc <https://github.com/phfaist/pylatexenc>`__ project to work correctly.
+
+.. py:data:: HAS_QASM3_IMPORT
+
+    The functions :func:`.qasm3.load` and :func:`.qasm3.loads` for importing OpenQASM 3 programs
+    into :class:`.QuantumCircuit` instances use `an external importer package
+    <https://qiskit.github.io/qiskit-qasm3-import>`__.
+
+.. py:data:: HAS_SEABORN
+
+    Qiskit provides several visualization tools in the :mod:`.visualization` module.  Some
+    of these are built using `Seaborn <https://seaborn.pydata.org/>`__, which must be installed
+    in order to use them.
+
+.. py:data:: HAS_SKLEARN
+
+    Some of the gradient functions in :mod:`.opflow.gradients` use regularisation methods from
+    `Scikit Learn <https://scikit-learn.org/stable/>`__.
+
+.. py:data:: HAS_SKQUANT
+
+    Some of the optimisers in :mod:`.algorithms.optimizers` are based on those found in `Scikit
+    Quant <https://github.com/scikit-quant/scikit-quant>`__, which must be installed to use
+    them.
+
+.. py:data:: HAS_SQSNOBFIT
+
+    `SQSnobFit <https://pypi.org/project/SQSnobFit/>`__ is a library for the "stable noisy
+    optimization by branch and fit" algorithm.  It is used by the :class:`.SNOBFIT` optimizer.
+
+.. py:data:: HAS_SYMENGINE
+
+    `Symengine <https://github.com/symengine/symengine>`__ is a fast C++ backend for the
+    symbolic-manipulation library `Sympy <https://www.sympy.org/en/index.html>`__.  Qiskit uses
+    special methods from Symengine to accelerate its handling of
+    :class:`~.circuit.Parameter`\\ s if available.
+
+.. py:data:: HAS_TESTTOOLS
+
+    Qiskit's test suite has more advanced functionality available if the optional
+    `testtools <https://pypi.org/project/testtools/>`__ library is installed.  This is generally
+    only needed for Qiskit developers.
+
+.. py:data:: HAS_TWEEDLEDUM
+
+    `Tweedledum <https://github.com/boschmitt/tweedledum>`__ is an extension library for
+    synthesis and optimization of circuits that may involve classical oracles.  Qiskit's
+    :class:`.PhaseOracle` uses this, which is used in turn by amplification algorithms via
+    the :class:`.AmplificationProblem`.
+
+.. py:data:: HAS_Z3
+
+    `Z3 <https://github.com/Z3Prover/z3>`__ is a theorem prover, used in the
+    :class:`.CrosstalkAdaptiveSchedule` and :class:`.HoareOptimizer` transpiler passes.
 
 External Command-Line Tools
 ---------------------------
 
-.. list-table::
-    :widths: 25 75
+.. py:data:: HAS_GRAPHVIZ
+
+    For some graph visualizations, Qiskit uses the `GraphViz <https://graphviz.org/>`__
+    visualization tool via its ``pydot`` interface (see :data:`HAS_PYDOT`).
+
+.. py:data:: HAS_PDFLATEX
 
-    * - .. py:data:: HAS_GRAPHVIZ
-      - For some graph visualizations, Qiskit uses the `GraphViz <https://graphviz.org/>`__
-        visualization tool via its ``pydot`` interface (see :data:`HAS_PYDOT`).
+    Visualization tools that use LaTeX in their output, such as the circuit drawers, require
+    ``pdflatex`` to be available.  You will generally need to ensure that you have a working
+    LaTeX installation available, and the ``qcircuit.tex`` package.
 
-    * - .. py:data:: HAS_PDFLATEX
-      - Visualization tools that use LaTeX in their output, such as the circuit drawers, require
-        ``pdflatex`` to be available.  You will generally need to ensure that you have a working
-        LaTeX installation available, and the ``qcircuit.tex`` package.
+.. py:data:: HAS_PDFTOCAIRO
 
-    * - .. py:data:: HAS_PDFTOCAIRO
-      - Visualization tools that convert LaTeX-generated files into rasterized images use the
-        ``pdftocairo`` tool.  This is part of the `Poppler suite of PDF tools
-        <https://poppler.freedesktop.org/>`__.
+    Visualization tools that convert LaTeX-generated files into rasterized images use the
+    ``pdftocairo`` tool.  This is part of the `Poppler suite of PDF tools
+    <https://poppler.freedesktop.org/>`__.
 
 
 Lazy Checker Classes

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