qiskit 2.0.3__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/visualization/transition_visualization.py

@@ -0,0 +1,369 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2018.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""
+Visualization function for animation of state transitions by applying gates to single qubit.
+"""
+import sys
+from math import sin, cos, acos, sqrt
+import numpy as np
+
+from qiskit.exceptions import MissingOptionalLibraryError
+from qiskit.utils.deprecation import deprecate_func
+
+
+def _normalize(v, tolerance=0.00001):
+    """Makes sure magnitude of the vector is 1 with given tolerance"""
+
+    mag2 = sum(n * n for n in v)
+    if abs(mag2 - 1.0) > tolerance:
+        mag = sqrt(mag2)
+        v = tuple(n / mag for n in v)
+    return np.array(v)
+
+
+class _Quaternion:
+    """For calculating vectors on unit sphere"""
+
+    def __init__(self):
+        self._val = None
+
+    @staticmethod
+    def from_axisangle(theta, v):
+        """Create quaternion from axis"""
+        v = _normalize(v)
+
+        new_quaternion = _Quaternion()
+        new_quaternion._axisangle_to_q(theta, v)
+        return new_quaternion
+
+    @staticmethod
+    def from_value(value):
+        """Create quaternion from vector"""
+        new_quaternion = _Quaternion()
+        new_quaternion._val = value
+        return new_quaternion
+
+    def _axisangle_to_q(self, theta, v):
+        """Convert axis and angle to quaternion"""
+        x = v[0]
+        y = v[1]
+        z = v[2]
+
+        w = cos(theta / 2.0)
+        x = x * sin(theta / 2.0)
+        y = y * sin(theta / 2.0)
+        z = z * sin(theta / 2.0)
+
+        self._val = np.array([w, x, y, z])
+
+    def __mul__(self, b):
+        """Multiplication of quaternion with quaternion or vector"""
+
+        if isinstance(b, _Quaternion):
+            return self._multiply_with_quaternion(b)
+        elif isinstance(b, (list, tuple, np.ndarray)):
+            if len(b) != 3:
+                raise ValueError(f"Input vector has invalid length {len(b)}")
+            return self._multiply_with_vector(b)
+        else:
+            return NotImplemented
+
+    def _multiply_with_quaternion(self, q_2):
+        """Multiplication of quaternion with quaternion"""
+        w_1, x_1, y_1, z_1 = self._val
+        w_2, x_2, y_2, z_2 = q_2._val
+        w = w_1 * w_2 - x_1 * x_2 - y_1 * y_2 - z_1 * z_2
+        x = w_1 * x_2 + x_1 * w_2 + y_1 * z_2 - z_1 * y_2
+        y = w_1 * y_2 + y_1 * w_2 + z_1 * x_2 - x_1 * z_2
+        z = w_1 * z_2 + z_1 * w_2 + x_1 * y_2 - y_1 * x_2
+
+        result = _Quaternion.from_value(np.array((w, x, y, z)))
+        return result
+
+    def _multiply_with_vector(self, v):
+        """Multiplication of quaternion with vector"""
+        q_2 = _Quaternion.from_value(np.append((0.0), v))
+        return (self * q_2 * self.get_conjugate())._val[1:]
+
+    def get_conjugate(self):
+        """Conjugation of quaternion"""
+        w, x, y, z = self._val
+        result = _Quaternion.from_value(np.array((w, -x, -y, -z)))
+        return result
+
+    def __repr__(self):
+        theta, v = self.get_axisangle()
+        return f"(({theta}; {v[0]}, {v[1]}, {v[2]}))"
+
+    def get_axisangle(self):
+        """Returns angle and vector of quaternion"""
+        w, v = self._val[0], self._val[1:]
+        theta = acos(w) * 2.0
+
+        return theta, _normalize(v)
+
+    def tolist(self):
+        """Converts quaternion to a list"""
+        return self._val.tolist()
+
+    def vector_norm(self):
+        """Calculates norm of quaternion"""
+        _, v = self.get_axisangle()
+        return np.linalg.norm(v)
+
+
+@deprecate_func(
+    since="1.2.0",
+    removal_timeline="in the 2.0 release",
+)
+def visualize_transition(circuit, trace=False, saveas=None, fpg=100, spg=2):
+    """
+    Creates animation showing transitions between states of a single
+    qubit by applying quantum gates.
+
+    Args:
+        circuit (QuantumCircuit): Qiskit single-qubit QuantumCircuit. Gates supported are
+            h,x, y, z, rx, ry, rz, s, sdg, t, tdg and u1.
+        trace (bool): Controls whether to display tracing vectors - history of 10 past vectors
+            at each step of the animation.
+        saveas (str): User can choose to save the animation as a video to their filesystem.
+            This argument is a string of path with filename and extension (e.g. "movie.mp4" to
+            save the video in current working directory).
+        fpg (int): Frames per gate. Finer control over animation smoothness and computational
+            needs to render the animation. Works well for tkinter GUI as it is, for jupyter GUI
+            it might be preferable to choose fpg between 5-30.
+        spg (int): Seconds per gate. How many seconds should animation of individual gate
+            transitions take.
+
+    Returns:
+        IPython.core.display.HTML:
+            If arg jupyter is set to True. Otherwise opens tkinter GUI and returns
+            after the GUI is closed.
+
+    Raises:
+        MissingOptionalLibraryError: Must have Matplotlib (and/or IPython) installed.
+        VisualizationError: Given gate(s) are not supported.
+
+    """
+    try:
+        from IPython.display import HTML
+
+        has_ipython = True
+    except ImportError:
+        has_ipython = False
+
+    try:
+        import matplotlib
+        from matplotlib import pyplot as plt
+        from matplotlib import animation
+        from mpl_toolkits.mplot3d import Axes3D
+        from .bloch import Bloch
+        from .exceptions import VisualizationError
+
+        has_matplotlib = True
+    except ImportError:
+        has_matplotlib = False
+
+    jupyter = False
+    if ("ipykernel" in sys.modules) and ("spyder" not in sys.modules):
+        jupyter = True
+
+    if not has_matplotlib:
+        raise MissingOptionalLibraryError(
+            libname="Matplotlib",
+            name="visualize_transition",
+            pip_install="pip install matplotlib",
+        )
+    if not has_ipython and jupyter is True:
+        raise MissingOptionalLibraryError(
+            libname="IPython",
+            name="visualize_transition",
+            pip_install="pip install ipython",
+        )
+    if len(circuit.qubits) != 1:
+        raise VisualizationError("Only one qubit circuits are supported")
+
+    frames_per_gate = fpg
+    time_between_frames = (spg * 1000) / fpg
+
+    # quaternions of gates which don't take parameters
+    simple_gates = {}
+    simple_gates["x"] = (
+        "x",
+        _Quaternion.from_axisangle(np.pi / frames_per_gate, [1, 0, 0]),
+        "#1abc9c",
+    )
+    simple_gates["y"] = (
+        "y",
+        _Quaternion.from_axisangle(np.pi / frames_per_gate, [0, 1, 0]),
+        "#2ecc71",
+    )
+    simple_gates["z"] = (
+        "z",
+        _Quaternion.from_axisangle(np.pi / frames_per_gate, [0, 0, 1]),
+        "#3498db",
+    )
+    simple_gates["s"] = (
+        "s",
+        _Quaternion.from_axisangle(np.pi / 2 / frames_per_gate, [0, 0, 1]),
+        "#9b59b6",
+    )
+    simple_gates["sdg"] = (
+        "sdg",
+        _Quaternion.from_axisangle(-np.pi / 2 / frames_per_gate, [0, 0, 1]),
+        "#8e44ad",
+    )
+    simple_gates["h"] = (
+        "h",
+        _Quaternion.from_axisangle(np.pi / frames_per_gate, _normalize([1, 0, 1])),
+        "#34495e",
+    )
+    simple_gates["t"] = (
+        "t",
+        _Quaternion.from_axisangle(np.pi / 4 / frames_per_gate, [0, 0, 1]),
+        "#e74c3c",
+    )
+    simple_gates["tdg"] = (
+        "tdg",
+        _Quaternion.from_axisangle(-np.pi / 4 / frames_per_gate, [0, 0, 1]),
+        "#c0392b",
+    )
+
+    list_of_circuit_gates = []
+
+    for gate, _, _ in circuit._data:
+        if gate.name == "barrier":
+            continue
+        if gate.name in simple_gates:
+            list_of_circuit_gates.append(simple_gates[gate.name])
+        elif gate.name == "rx":
+            theta = gate.params[0]
+            quaternion = _Quaternion.from_axisangle(theta / frames_per_gate, [1, 0, 0])
+            list_of_circuit_gates.append((f"{gate.name}: {theta:.2f}", quaternion, "#16a085"))
+        elif gate.name == "ry":
+            theta = gate.params[0]
+            quaternion = _Quaternion.from_axisangle(theta / frames_per_gate, [0, 1, 0])
+            list_of_circuit_gates.append((f"{gate.name}: {theta:.2f}", quaternion, "#27ae60"))
+        elif gate.name == "rz":
+            theta = gate.params[0]
+            quaternion = _Quaternion.from_axisangle(theta / frames_per_gate, [0, 0, 1])
+            list_of_circuit_gates.append((f"{gate.name}: {theta:.2f}", quaternion, "#2980b9"))
+        elif gate.name == "u1":
+            theta = gate.params[0]
+            quaternion = _Quaternion.from_axisangle(theta / frames_per_gate, [0, 0, 1])
+            list_of_circuit_gates.append((f"{gate.name}: {theta:.2f}", quaternion, "#f1c40f"))
+        else:
+            raise VisualizationError(f"Gate {gate.name} is not supported")
+
+    if len(list_of_circuit_gates) == 0:
+        raise VisualizationError("Nothing to visualize.")
+
+    starting_pos = _normalize(np.array([0, 0, 1]))
+
+    fig = plt.figure(figsize=(5, 5))
+    if tuple(int(x) for x in matplotlib.__version__.split(".")) >= (3, 4, 0):
+        _ax = Axes3D(fig, auto_add_to_figure=False)
+        fig.add_axes(_ax)
+    else:
+        _ax = Axes3D(fig)
+
+    _ax.set_xlim(-10, 10)
+    _ax.set_ylim(-10, 10)
+    sphere = Bloch(axes=_ax)
+
+    class Namespace:
+        """Helper class serving as scope container"""
+
+        def __init__(self):
+            self.new_vec = []
+            self.last_gate = -2
+            self.colors = []
+            self.pnts = []
+
+    namespace = Namespace()
+    namespace.new_vec = starting_pos
+
+    def animate(i):
+        sphere.clear()
+
+        # starting gate count from -1 which is the initial vector
+        gate_counter = (i - 1) // frames_per_gate
+        if gate_counter != namespace.last_gate:
+            namespace.pnts.append([[], [], []])
+            namespace.colors.append(list_of_circuit_gates[gate_counter][2])
+
+        # starts with default vector [0,0,1]
+        if i == 0:
+            sphere.add_vectors(namespace.new_vec)
+            namespace.pnts[0][0].append(namespace.new_vec[0])
+            namespace.pnts[0][1].append(namespace.new_vec[1])
+            namespace.pnts[0][2].append(namespace.new_vec[2])
+            namespace.colors[0] = "r"
+            sphere.make_sphere()
+            return _ax
+
+        namespace.new_vec = list_of_circuit_gates[gate_counter][1] * namespace.new_vec
+
+        namespace.pnts[gate_counter + 1][0].append(namespace.new_vec[0])
+        namespace.pnts[gate_counter + 1][1].append(namespace.new_vec[1])
+        namespace.pnts[gate_counter + 1][2].append(namespace.new_vec[2])
+
+        sphere.add_vectors(namespace.new_vec)
+        if trace:
+            # sphere.add_vectors(namespace.points)
+            for point_set in namespace.pnts:
+                sphere.add_points([point_set[0], point_set[1], point_set[2]])
+
+        sphere.vector_color = [list_of_circuit_gates[gate_counter][2]]
+        sphere.point_color = namespace.colors
+        sphere.point_marker = "o"
+
+        annotation_text = list_of_circuit_gates[gate_counter][0]
+        annotationvector = [1.40, -0.45, 1.65]
+        sphere.add_annotation(
+            annotationvector,
+            annotation_text,
+            color=list_of_circuit_gates[gate_counter][2],
+            fontsize=30,
+            horizontalalignment="left",
+        )
+
+        sphere.make_sphere()
+
+        namespace.last_gate = gate_counter
+        return _ax
+
+    def init():
+        sphere.vector_color = ["r"]
+        return _ax
+
+    ani = animation.FuncAnimation(
+        fig,
+        animate,
+        range(frames_per_gate * len(list_of_circuit_gates) + 1),
+        init_func=init,
+        blit=False,
+        repeat=False,
+        interval=time_between_frames,
+    )
+
+    if saveas:
+        ani.save(saveas, fps=30)
+    if jupyter:
+        # This is necessary to overcome matplotlib memory limit
+        matplotlib.rcParams["animation.embed_limit"] = 50
+        plt.close(fig)
+        return HTML(ani.to_jshtml())
+    plt.show()
+    plt.close(fig)
+    return None

qiskit/visualization/utils.py

@@ -0,0 +1,49 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2018.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Common visualization utilities."""
+
+from qiskit.utils import optionals as _optionals
+
+
+@_optionals.HAS_PIL.require_in_call("the latex circuit drawer")
+def _trim(image):
+    """Trim a PIL image and remove white space."""
+    import PIL
+
+    background = PIL.Image.new(image.mode, image.size, image.getpixel((0, 0)))
+    diff = PIL.ImageChops.difference(image, background)
+    diff = PIL.ImageChops.add(diff, diff, 2.0, -100)
+    bbox = diff.getbbox()
+    if bbox:
+        image = image.crop(bbox)
+    return image
+
+
+MATPLOTLIB_INLINE_BACKENDS = {
+    "module://ipykernel.pylab.backend_inline",
+    "module://matplotlib_inline.backend_inline",
+    "nbAgg",
+}
+
+
+def matplotlib_close_if_inline(figure):
+    """Close the given matplotlib figure if the backend in use draws figures inline.
+
+    If the backend does not draw figures inline, this does nothing.  This function is to prevent
+    duplicate images appearing; the inline backends will capture the figure in preparation and
+    display it as well, whereas the drawers want to return the figure to be displayed."""
+    # This can only called if figure has already been created, so matplotlib must exist.
+    import matplotlib.pyplot
+
+    if matplotlib.get_backend() in MATPLOTLIB_INLINE_BACKENDS:
+        matplotlib.pyplot.close(figure)

qiskit-2.0.3.dist-info/METADATA

@@ -0,0 +1,220 @@
+Metadata-Version: 2.4
+Name: qiskit
+Version: 2.0.3
+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
+Project-URL: Homepage, https://www.ibm.com/quantum/qiskit
+Project-URL: Documentation, https://quantum.cloud.ibm.com/docs
+Project-URL: API Reference, https://quantum.cloud.ibm.com/docs/api/qiskit
+Project-URL: Repository, https://github.com/Qiskit/qiskit
+Project-URL: Issues, https://github.com/Qiskit/qiskit/issues
+Project-URL: Changelog, https://quantum.cloud.ibm.com/docs/api/qiskit/release-notes
+Keywords: qiskit,quantum circuit,quantum computing,quantum programming language,quantum,sdk
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: rustworkx>=0.15.0
+Requires-Dist: numpy<3,>=1.17
+Requires-Dist: scipy>=1.5
+Requires-Dist: sympy>=1.3
+Requires-Dist: dill>=0.3
+Requires-Dist: python-dateutil>=2.8.0
+Requires-Dist: stevedore>=3.0.0
+Requires-Dist: typing-extensions
+Requires-Dist: symengine<0.14,>=0.11
+Provides-Extra: qasm3-import
+Requires-Dist: qiskit-qasm3-import>=0.1.0; extra == "qasm3-import"
+Provides-Extra: visualization
+Requires-Dist: matplotlib>=3.3; extra == "visualization"
+Requires-Dist: pydot; extra == "visualization"
+Requires-Dist: Pillow>=4.2.1; extra == "visualization"
+Requires-Dist: pylatexenc>=1.4; extra == "visualization"
+Requires-Dist: seaborn>=0.9.0; extra == "visualization"
+Provides-Extra: crosstalk-pass
+Requires-Dist: z3-solver>=4.7; extra == "crosstalk-pass"
+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
+
+[![License](https://img.shields.io/github/license/Qiskit/qiskit.svg?)](https://opensource.org/licenses/Apache-2.0) <!--- long-description-skip-begin -->
+[![Current Release](https://img.shields.io/github/release/Qiskit/qiskit.svg?logo=Qiskit)](https://github.com/Qiskit/qiskit/releases)
+<!-- [![Extended Support Release](https://img.shields.io/github/v/release/Qiskit/qiskit?sort=semver&filter=0.*&logo=Qiskit&label=extended%20support)](https://github.com/Qiskit/qiskit/releases?q=tag%3A0) -->
+[![Downloads](https://img.shields.io/pypi/dm/qiskit.svg)](https://pypi.org/project/qiskit/)
+[![Coverage Status](https://coveralls.io/repos/github/Qiskit/qiskit/badge.svg?branch=main)](https://coveralls.io/github/Qiskit/qiskit?branch=main)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/qiskit)
+[![Minimum rustc 1.79](https://img.shields.io/badge/rustc-1.79+-blue.svg)](https://rust-lang.github.io/rfcs/2495-min-rust-version.html)
+[![Downloads](https://static.pepy.tech/badge/qiskit)](https://pepy.tech/project/qiskit)<!--- long-description-skip-end -->
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.2583252.svg)](https://doi.org/10.5281/zenodo.2583252)
+
+**Qiskit**  is an open-source SDK for working with quantum computers at the level of extended quantum circuits, operators, and primitives.
+
+This library is the core component of Qiskit, which contains the building blocks for creating and working with quantum circuits, quantum operators, and primitive functions (Sampler and Estimator).
+It also contains a transpiler that supports optimizing quantum circuits, and a quantum information toolbox for creating advanced operators.
+
+For more details on how to use Qiskit, refer to the documentation located here:
+
+<https://quantum.cloud.ibm.com/docs/>
+
+
+## Installation
+
+We encourage installing Qiskit via ``pip``:
+
+```bash
+pip install qiskit
+```
+
+Pip will handle all dependencies automatically and you will always install the latest (and well-tested) version.
+
+To install from source, follow the instructions in the [documentation](https://quantum.cloud.ibm.com/docs/guides/install-qiskit-source).
+
+## Create your first quantum program in Qiskit
+
+Now that Qiskit is installed, it's time to begin working with Qiskit. The essential parts of a quantum program are:
+1. Define and build a quantum circuit that represents the quantum state
+2. Define the classical output by measurements or a set of observable operators
+3. Depending on the output, use the Sampler primitive to sample outcomes or the Estimator primitive to estimate expectation values.
+
+Create an example quantum circuit using the `QuantumCircuit` class:
+
+```python
+import numpy as np
+from qiskit import QuantumCircuit
+
+# 1. A quantum circuit for preparing the quantum state |000> + i |111> / √2
+qc = QuantumCircuit(3)
+qc.h(0)             # generate superposition
+qc.p(np.pi / 2, 0)  # add quantum phase
+qc.cx(0, 1)         # 0th-qubit-Controlled-NOT gate on 1st qubit
+qc.cx(0, 2)         # 0th-qubit-Controlled-NOT gate on 2nd qubit
+```
+
+This simple example creates an entangled state known as a [GHZ state](https://en.wikipedia.org/wiki/Greenberger%E2%80%93Horne%E2%80%93Zeilinger_state) $(|000\rangle + i|111\rangle)/\sqrt{2}$. It uses the standard quantum gates: Hadamard gate (`h`), Phase gate (`p`), and CNOT gate (`cx`). 
+
+Once you've made your first quantum circuit, choose which primitive you will use. Starting with the Sampler,
+we use `measure_all(inplace=False)` to get a copy of the circuit in which all the qubits are measured:
+
+```python
+# 2. Add the classical output in the form of measurement of all qubits
+qc_measured = qc.measure_all(inplace=False)
+
+# 3. Execute using the Sampler primitive
+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()}")
+```
+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.
+
+```python
+# 2. Define the observable to be measured 
+from qiskit.quantum_info import SparsePauliOp
+operator = SparsePauliOp.from_list([("XXY", 1), ("XYX", 1), ("YXX", 1), ("YYY", -1)])
+
+# 3. Execute using the Estimator primitive
+from qiskit.primitives import StatevectorEstimator
+estimator = StatevectorEstimator()
+job = estimator.run([(qc, operator)], precision=1e-3)
+result = job.result()
+print(f" > Expectation values: {result[0].data.evs}")
+```
+
+Running this will give the outcome `4`. For fun, try to assign a value of +/- 1 to each single-qubit operator X and Y 
+and see if you can achieve this outcome. (Spoiler alert: this is not possible!)
+
+Using the Qiskit-provided `qiskit.primitives.StatevectorSampler` and `qiskit.primitives.StatevectorEstimator` will not take you very far.
+The power of quantum computing cannot be simulated on classical computers and you need to use real quantum hardware to scale to larger quantum circuits.
+However, running a quantum circuit on hardware requires rewriting to the basis gates and connectivity of the quantum hardware.
+The tool that does this is the [transpiler](https://quantum.cloud.ibm.com/docs/api/qiskit/transpiler), and Qiskit includes transpiler passes for synthesis, optimization, mapping, and scheduling.
+However, it also includes a default compiler, which works very well in most examples.
+The following code will map the example circuit to the `basis_gates = ["cz", "sx", "rz"]` and a linear chain of qubits $0 \rightarrow 1 \rightarrow 2$ with the `coupling_map = [[0, 1], [1, 2]]`.
+
+```python
+from qiskit import transpile
+qc_transpiled = transpile(qc, basis_gates=["cz", "sx", "rz"], coupling_map=[[0, 1], [1, 2]], optimization_level=3)
+```
+
+### Executing your code on real quantum hardware
+
+Qiskit provides an abstraction layer that lets users run quantum circuits on hardware from any vendor that provides a compatible interface. 
+The best way to use Qiskit is with a runtime environment that provides optimized implementations of Sampler and Estimator for a given hardware platform. This runtime may involve using pre- and post-processing, such as optimized transpiler passes with error suppression, error mitigation, and, eventually, error correction built in. A runtime implements `qiskit.primitives.BaseSamplerV2` and `qiskit.primitives.BaseEstimatorV2` interfaces. For example,
+some packages that provide implementations of a runtime primitive implementation are:
+
+* https://github.com/Qiskit/qiskit-ibm-runtime
+
+Qiskit also provides a lower-level abstract interface for describing quantum backends. This interface, located in
+``qiskit.providers``, defines an abstract `BackendV2` class that providers can implement to represent their
+hardware or simulators to Qiskit. The backend class includes a common interface for executing circuits on the backends; however, in this interface each provider may perform different types of pre- and post-processing and return outcomes that are vendor-defined. Some examples of published provider packages that interface with real hardware are:
+
+* https://github.com/qiskit-community/qiskit-ionq
+* https://github.com/qiskit-community/qiskit-aqt-provider
+* https://github.com/qiskit-community/qiskit-braket-provider
+* https://github.com/qiskit-community/qiskit-quantinuum-provider
+* https://github.com/rigetti/qiskit-rigetti
+
+<!-- This is not an exhaustive list, and if you maintain a provider package please feel free to open a PR to add new providers -->
+
+You can refer to the documentation of these packages for further instructions
+on how to get access and use these systems.
+
+## Contribution Guidelines
+
+If you'd like to contribute to Qiskit, please take a look at our
+[contribution guidelines](CONTRIBUTING.md). By participating, you are expected to uphold our [code of conduct](CODE_OF_CONDUCT.md).
+
+We use [GitHub issues](https://github.com/Qiskit/qiskit/issues) for tracking requests and bugs. Please
+[join the Qiskit Slack community](https://qisk.it/join-slack) for discussion, comments, and questions.
+For questions related to running or using Qiskit, [Stack Overflow has a `qiskit`](https://stackoverflow.com/questions/tagged/qiskit).
+For questions on quantum computing with Qiskit, use the `qiskit` tag in the [Quantum Computing Stack Exchange](https://quantumcomputing.stackexchange.com/questions/tagged/qiskit) (please, read first the [guidelines on how to ask](https://quantumcomputing.stackexchange.com/help/how-to-ask) in that forum).
+
+
+## Authors and Citation
+
+Qiskit is the work of [many people](https://github.com/Qiskit/qiskit/graphs/contributors) who contribute
+to the project at different levels. If you use Qiskit, please cite as per the included [BibTeX file](CITATION.bib).
+
+## Changelog and Release Notes
+
+The changelog for a particular release is dynamically generated and gets
+written to the release page on Github for each release. For example, you can
+find the page for the `1.2.0` release here:
+
+<https://github.com/Qiskit/qiskit/releases/tag/1.2.0>
+
+The changelog for the current release can be found in the releases tab:
+[![Releases](https://img.shields.io/github/release/Qiskit/qiskit.svg?style=flat&label=)](https://github.com/Qiskit/qiskit/releases)
+The changelog provides a quick overview of notable changes for a given
+release.
+
+Additionally, as part of each release, detailed release notes are written to
+document in detail what has changed as part of a release. This includes any
+documentation on potential breaking changes on upgrade and new features. See [all release notes here](https://quantum.cloud.ibm.com/docs/api/qiskit/release-notes).
+
+## Acknowledgements
+
+We acknowledge partial support for Qiskit development from the DOE Office of Science National Quantum Information Science Research Centers, Co-design Center for Quantum Advantage (C2QA) under contract number DE-SC0012704.
+
+## License
+
+[Apache License 2.0](LICENSE.txt)