qiskit 2.0.0rc2__cp39-abi3-win_amd64.whl → 2.0.2__cp39-abi3-win_amd64.whl

qiskit/transpiler/passes/synthesis/solovay_kitaev_synthesis.py

@@ -207,7 +207,7 @@ class SolovayKitaevSynthesis(UnitarySynthesisPlugin):
 
     Supported parameters in the dictionary:
 
-    basis_approximations (str | dict):
+    basic_approximations (str | dict):
         The basic approximations for the finding the best discrete decomposition at the root of the
         recursion. If a string, it specifies the ``.npy`` file to load the approximations from.
         If a dictionary, it contains ``{label: SO(3)-matrix}`` pairs. If None, a default based on
@@ -215,19 +215,31 @@ class SolovayKitaevSynthesis(UnitarySynthesisPlugin):
 
     basis_gates (list):
         A list of strings specifying the discrete basis gates to decompose to. If None,
-        defaults to ``["h", "t", "tdg"]``.
+        it defaults to ``["h", "t", "tdg"]``. If ``basic_approximations`` is not None,
+        ``basis_set`` is required to correspond to the basis set that was used to
+        generate it.
 
     depth (int):
         The gate-depth of the basic approximations. All possible, unique combinations of the
         basis gates up to length ``depth`` are considered. If None, defaults to 10.
+        If ``basic_approximations`` is not None, ``depth`` is required to correspond to the
+        depth that was used to generate it.
 
     recursion_degree (int):
         The number of times the decomposition is recursively improved. If None, defaults to 3.
     """
 
-    # we cache an instance of the Solovay-Kitaev class to generate the
-    # computationally expensive basis approximation of single qubit gates only once
+    # Generating basic approximations of single-qubit gates is computationally expensive.
+    # We cache the instance of the Solovay-Kitaev class (which contains the approximations),
+    # as well as the basis gates and the depth (used to generate it).
+    # When the plugin is called again, we check if the specified basis gates and depth are
+    # the same as before. If so, the stored basic approximations are reused, and if not, the
+    # approximations are re-generated. In practice (when the plugin is run as a part of the
+    # UnitarySynthesis transpiler pass), the basis gates and the depth do not change, and
+    # basic approximations are not re-generated.
     _sk = None
+    _basis_gates = None
+    _depth = None
 
     @property
     def max_qubits(self):
@@ -277,27 +289,25 @@ class SolovayKitaevSynthesis(UnitarySynthesisPlugin):
         return False
 
     def run(self, unitary, **options):
+        """Run the SolovayKitaevSynthesis synthesis plugin on the given unitary."""
 
-        # Runtime imports to avoid the overhead of these imports for
-        # plugin discovery and only use them if the plugin is run/used
         config = options.get("config") or {}
-
+        basis_gates = options.get("basis_gates", ["h", "t", "tdg"])
+        depth = config.get("depth", 10)
+        basic_approximations = config.get("basic_approximations", None)
         recursion_degree = config.get("recursion_degree", 3)
 
-        # if we didn't yet construct the Solovay-Kitaev instance, which contains
-        # the basic approximations, do it now
-        if SolovayKitaevSynthesis._sk is None:
-            basic_approximations = config.get("basic_approximations", None)
-            basis_gates = options.get("basis_gates", ["h", "t", "tdg"])
-
-            # if the basic approximations are not generated and not given,
-            # try to generate them if the basis set is specified
+        # Check if we didn't yet construct the Solovay-Kitaev instance (which contains the basic
+        # approximations) or if the basic approximations need need to be recomputed.
+        if (SolovayKitaevSynthesis._sk is None) or (
+            (basis_gates != SolovayKitaevSynthesis._basis_gates)
+            or (depth != SolovayKitaevSynthesis._depth)
+        ):
             if basic_approximations is None:
-                depth = config.get("depth", 10)
                 basic_approximations = generate_basic_approximations(basis_gates, depth)
 
+            SolovayKitaevSynthesis._basis_gates = basis_gates
+            SolovayKitaevSynthesis._depth = depth
             SolovayKitaevSynthesis._sk = SolovayKitaevDecomposition(basic_approximations)
-
         approximate_circuit = SolovayKitaevSynthesis._sk.run(unitary, recursion_degree)
-        dag_circuit = circuit_to_dag(approximate_circuit)
-        return dag_circuit
+        return circuit_to_dag(approximate_circuit)

qiskit/transpiler/passes/synthesis/unitary_synthesis.py

@@ -223,6 +223,7 @@ class UnitarySynthesis(TransformationPass):
                 self._min_qubits,
                 self._target,
                 self._basis_gates,
+                self._synth_gates,
                 _coupling_edges,
                 self._approximation_degree,
                 self._natural_direction,
@@ -294,7 +295,7 @@ class UnitarySynthesis(TransformationPass):
 
         out_dag = dag.copy_empty_like()
         for node in dag.topological_op_nodes():
-            if node.name == "unitary" and len(node.qargs) >= self._min_qubits:
+            if node.name in self._synth_gates and len(node.qargs) >= self._min_qubits:
                 synth_dag = None
                 unitary = node.matrix
                 n_qubits = len(node.qargs)

qiskit/transpiler/preset_passmanagers/generate_preset_pass_manager.py

@@ -13,7 +13,7 @@
 """
 Preset pass manager generation function
 """
-
+import copy
 import warnings
 
 from qiskit.circuit.controlflow import CONTROL_FLOW_OP_NAMES, get_control_flow_name_mapping
@@ -129,9 +129,9 @@ def generate_preset_pass_manager(
             :class:`~.StagedPassManager`. You can see a list of installed plugins by using
             :func:`~.list_stage_plugins` with ``"layout"`` for the ``stage_name`` argument.
         routing_method (str): The pass to use for routing qubits on the
-            architecture. Valid choices are ``'basic'``, ``'lookahead'``, ``'stochastic'``,
+            architecture. Valid choices are ``'basic'``, ``'lookahead'``,
             ``'sabre'``, and ``'none'`` representing :class:`~.BasicSwap`,
-            :class:`~.LookaheadSwap`, :class:`~.StochasticSwap`, :class:`~.SabreSwap`, and
+            :class:`~.LookaheadSwap`, :class:`~.SabreSwap`, and
             erroring if routing is required respectively. This can also be the external plugin
             name to use for the ``routing`` stage of the output :class:`~.StagedPassManager`.
             You can see a list of installed plugins by using :func:`~.list_stage_plugins` with
@@ -200,12 +200,14 @@ def generate_preset_pass_manager(
     # If there are no loose constraints => use backend target if available
     _no_loose_constraints = basis_gates is None and coupling_map is None and dt is None
 
+    # If the only loose constraint is dt => use backend target and modify dt
+    _adjust_dt = backend is not None and dt is not None
+
     # Warn about inconsistencies in backend + loose constraints path (dt shouldn't be a problem)
     if backend is not None and (coupling_map is not None or basis_gates is not None):
         warnings.warn(
             "Providing `coupling_map` and/or `basis_gates` along with `backend` is not "
-            "recommended. This may introduce inconsistencies in the transpilation target, "
-            "leading to potential errors.",
+            "recommended, as this will invalidate the backend's gate durations and error rates.",
             category=UserWarning,
             stacklevel=2,
         )
@@ -226,13 +228,17 @@ def generate_preset_pass_manager(
                 raise ValueError(
                     f"Gates with 3 or more qubits ({gate}) in `basis_gates` or `backend` are "
                     "incompatible with a custom `coupling_map`. To include 3-qubit or larger "
-                    " gates in the transpilation basis, use a custom `target` instance instead."
+                    " gates in the transpilation basis, provide a custom `target` instead."
                 )
 
     if target is None:
         if backend is not None and _no_loose_constraints:
             # If a backend is specified without loose constraints, use its target directly.
             target = backend.target
+        elif _adjust_dt:
+            # If a backend is specified with loose dt, use its target and adjust the dt value.
+            target = copy.deepcopy(backend.target)
+            target.dt = dt
         else:
             if basis_gates is not None:
                 # Build target from constraints.
@@ -255,7 +261,7 @@ def generate_preset_pass_manager(
                     dt=dt,
                 )
 
-    # update loose constraints to populate pm options
+    # Update loose constraints to populate pm options
     if coupling_map is None:
         coupling_map = target.build_coupling_map()
     if basis_gates is None and len(target.operation_names) > 0:

qiskit/transpiler/target.py

@@ -270,6 +270,17 @@ class Target(BaseTarget):
         self._instruction_durations = None
         self._instruction_schedule_map = None
 
+    @property
+    def dt(self):
+        """Return dt."""
+        return self._dt
+
+    @dt.setter
+    def dt(self, dt):
+        """Set dt and invalidate instruction duration cache"""
+        self._dt = dt
+        self._instruction_durations = None
+
     def add_instruction(self, instruction, properties=None, name=None):
         """Add a new instruction to the :class:`~qiskit.transpiler.Target`
 

qiskit/visualization/circuit/text.py

@@ -1396,7 +1396,7 @@ class TextDrawing:
                 layers.append(flow_layer2.full_layer)
 
         # Draw the right box for End
-        flow_layer = self.draw_flow_box(node, flow_wire_map, CF_RIGHT, conditional=False)
+        flow_layer = self.draw_flow_box(node, wire_map, CF_RIGHT, conditional=False)
         layers.append(flow_layer.full_layer)
 
     def draw_flow_box(self, node, flow_wire_map, section, circ_num=0, conditional=False):

qiskit/visualization/counts_visualization.py

@@ -408,6 +408,10 @@ def _plotting_core(
     if fig:
         matplotlib_close_if_inline(fig)
     if filename is None:
+        try:
+            fig.tight_layout()
+        except AttributeError:
+            pass
         return fig
     else:
         return fig.savefig(filename)

qiskit/visualization/library.py

@@ -23,15 +23,18 @@ def _generate_circuit_library_visualization(circuit: QuantumCircuit):
     import matplotlib.pyplot as plt
 
     circuit = circuit.decompose()
+    global_phase, circuit.global_phase = circuit.global_phase, 0
     ops = circuit.count_ops()
     num_nl = circuit.num_nonlocal_gates()
-    _fig, (ax0, ax1) = plt.subplots(2, 1)
+    _fig, (ax0, ax1) = plt.subplots(2, 1, figsize=(6.4, 9.6))
     circuit.draw("mpl", ax=ax0)
+    circuit.global_phase = global_phase
     ax1.axis("off")
     ax1.grid(visible=None)
     ax1.table(
         [[circuit.name], [circuit.width()], [circuit.depth()], [sum(ops.values())], [num_nl]],
         rowLabels=["Circuit Name", "Width", "Depth", "Total Gates", "Non-local Gates"],
+        loc="top",
     )
     plt.tight_layout()
     plt.show()

qiskit/visualization/state_visualization.py

@@ -281,7 +281,8 @@ def plot_bloch_multivector(
         reverse_bits (bool): If True, plots qubits following Qiskit's convention [Default:False].
         font_size (float): Font size for the Bloch ball figures.
         title_font_size (float): Font size for the title.
-        title_pad (float): Padding for the title (suptitle `y` position is `y=1+title_pad/100`).
+        title_pad (float): Padding for the title (suptitle ``y`` position is ``0.98``
+        and the image height will be extended by ``1 + title_pad/100``).
 
     Returns:
         :class:`matplotlib:matplotlib.figure.Figure` :
@@ -345,6 +346,8 @@ def plot_bloch_multivector(
         width *= num
     else:
         width, height = plt.figaspect(1 / num)
+    if len(title) > 0:
+        height += 1 + title_pad / 100  # additional space for the title
     default_title_font_size = font_size if font_size is not None else 16
     title_font_size = title_font_size if title_font_size is not None else default_title_font_size
     fig = plt.figure(figsize=(width, height))
@@ -354,9 +357,13 @@ def plot_bloch_multivector(
         plot_bloch_vector(
             bloch_data[i], "qubit " + str(pos), ax=ax, figsize=figsize, font_size=font_size
         )
-    fig.suptitle(title, fontsize=title_font_size, y=1.0 + title_pad / 100)
+    fig.suptitle(title, fontsize=title_font_size, y=0.98)
     matplotlib_close_if_inline(fig)
     if filename is None:
+        try:
+            fig.tight_layout()
+        except AttributeError:
+            pass
         return fig
     else:
         return fig.savefig(filename)
@@ -726,6 +733,10 @@ def plot_state_paulivec(state, title="", figsize=None, color=None, ax=None, *, f
     if return_fig:
         matplotlib_close_if_inline(fig)
     if filename is None:
+        try:
+            fig.tight_layout()
+        except AttributeError:
+            pass
         return fig
     else:
         return fig.savefig(filename)

qiskit/visualization/timeline/core.py

@@ -260,7 +260,7 @@ class DrawerCanvas:
                     self.add_data(datum)
 
         # update time range
-        t_end = max(program.duration, self.formatter["margin.minimum_duration"])
+        t_end = max(program._duration, self.formatter["margin.minimum_duration"])
         self.set_time_range(t_start=0, t_end=t_end)
 
     def set_time_range(self, t_start: int, t_end: int):

qiskit/visualization/timeline/plotters/matplotlib.py

@@ -188,5 +188,8 @@ class MplPlotter(BasePlotter):
 
         if self.figure and interactive:
             self.figure.show()
-
+        try:
+            self.figure.tight_layout()
+        except AttributeError:
+            pass
         return self.figure

{qiskit-2.0.0rc2.dist-info → qiskit-2.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: qiskit
-Version: 2.0.0rc2
+Version: 2.0.2
 Summary: An open-source SDK for working with quantum computers at the level of extended quantum circuits, operators, and primitives.
 Author-email: Qiskit Development Team <qiskit@us.ibm.com>
 License: Apache 2.0
@@ -51,6 +51,7 @@ Provides-Extra: csp-layout-pass
 Requires-Dist: python-constraint>=1.4; extra == "csp-layout-pass"
 Provides-Extra: all
 Requires-Dist: qiskit[crosstalk-pass,csp-layout-pass,qasm3-import,visualization]; extra == "all"
+Dynamic: license-file
 
 # Qiskit
 
@@ -121,7 +122,7 @@ from qiskit.primitives import StatevectorSampler
 sampler = StatevectorSampler()
 job = sampler.run([qc_measured], shots=1000)
 result = job.result()
-print(f" > Counts: {result[0].data["meas"].get_counts()}")
+print(f" > Counts: {result[0].data['meas'].get_counts()}")
 ```
 Running this will give an outcome similar to `{'000': 497, '111': 503}` which is `000` 50% of the time and `111` 50% of the time up to statistical fluctuations.
 To illustrate the power of the Estimator, we now use the quantum information toolbox to create the operator $XXY+XYX+YXX-YYY$ and pass it to the `run()` function, along with our quantum circuit. Note that the Estimator requires a circuit _**without**_ measurements, so we use the `qc` circuit we created earlier.