{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "c8e557e7-e1f9-4429-80ad-2907871c704d",
      "metadata": {},
      "source": [
        "---\n",
        "title: View backend details\n",
        "description: List and filter available backends, and find QPU details such as configuration and calibration data.\n",
        "---\n",
        "\n",
        "# View backend details\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "bb84ab8e-6db9-45d6-bb59-2f06f38d9965",
      "metadata": {
        "tags": [
          "version-info"
        ]
      },
      "source": [
        "{/*\n",
        "  DO NOT EDIT THIS CELL!!!\n",
        "  This cell's content is generated automatically by a script. Anything you add\n",
        "  here will be removed next time the notebook is run. To add new content, create\n",
        "  a new cell before or after this one.\n",
        "  */}\n",
        "\n",
        "<Accordion>\n",
        "  <AccordionItem title=\"Package versions\">\n",
        "    The code on this page was developed using the following requirements.\n",
        "    We recommend using these versions or newer.\n",
        "\n",
        "    ```\n",
        "    qiskit-ibm-runtime~=0.45.1\n",
        "    ```\n",
        "  </AccordionItem>\n",
        "</Accordion>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "d76db591-d53c-4753-ab4f-8d6e80bbc39e",
      "metadata": {},
      "source": [
        "This page explains how to find information about your available backends.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "1215b9ee-c32f-42db-a1e0-24d62175ab88",
      "metadata": {},
      "source": [
        "## List or filter backends\n",
        "\n",
        "<span id=\"available\" />\n",
        "\n",
        "### List backends available to you\n",
        "\n",
        "You can use either Qiskit or IBM Quantum Platform to view a list of backends available to you, or to search for a particular backend.\n",
        "\n",
        "<Admonition type=\"note\" title=\"QPU names\">\n",
        "  QPUs hosted on IBM Cloud® have names that begin with `ibm_*`. All QPUs are given a city name - for example, `ibm_kingston`. This name does not indicate where the actual QPU is hosted.\n",
        "</Admonition>\n",
        "\n",
        "<Tabs>\n",
        "  <TabItem value=\"Qiskit-available\" label=\"View backends with Qiskit\">\n",
        "    Use the [`QiskitRuntimeService.backends()`](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service#backends) method, as shown in the next code block. This method returns a list of [`IBMBackend`](/docs/api/qiskit-ibm-runtime/ibm-backend) instances.\n",
        "\n",
        "    To run the following code, be sure you have already authenticated to the service. See [Set up your IBM Cloud account](/docs/guides/cloud-setup) for more details.\n",
        "\n",
        "    <CodeCellPlaceholder tag=\"id-initialize\" />\n",
        "\n",
        "    To search for a specific backend, use the [`QiskitRuntimeService.backend()`](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service#backend) method (note that this is singular: *backend*), which takes the name of the backend as the input parameter and returns an [`IBMBackend`](/docs/api/qiskit-ibm-runtime/ibm-backend) instance representing that particular backend:\n",
        "\n",
        "    <CodeCellPlaceholder tag=\"id-search\" />\n",
        "  </TabItem>\n",
        "\n",
        "  <TabItem value=\"IQP-available\" label=\"View backends on IBM Quantum Platform\">\n",
        "    To view the backends you have access to, navigate to the list of backends on the [Compute resources page](/computers) (note that your selected region might impact the QPUs listed). Click the filter icon and choose either \"All my instances\" or a specific instance name to see the available QPUs.\n",
        "  </TabItem>\n",
        "</Tabs>\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "id": "068f58ca-bff4-4138-8b75-b6a67e1e9e37",
      "metadata": {
        "tags": [
          "id-initialize"
        ]
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[<IBMBackend('ibm_boston')>,\n",
              " <IBMBackend('ibm_pittsburgh')>,\n",
              " <IBMBackend('ibm_fez')>,\n",
              " <IBMBackend('ibm_kingston')>,\n",
              " <IBMBackend('ibm_miami')>,\n",
              " <IBMBackend('ibm_marrakesh')>,\n",
              " <IBMBackend('ibm_torino')>]"
            ]
          },
          "execution_count": 1,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Initialize your account\n",
        "from qiskit_ibm_runtime import QiskitRuntimeService\n",
        "\n",
        "service = QiskitRuntimeService()\n",
        "\n",
        "service.backends()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "id": "0fc28230-3036-44ea-b933-8a9dda548b38",
      "metadata": {
        "tags": [
          "id-search"
        ]
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<IBMBackend('ibm_fez')>"
            ]
          },
          "execution_count": 2,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "service.backend(\"ibm_fez\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "id": "3a28c031-e306-4cd2-aacb-f007b564ce96",
      "metadata": {
        "tags": [
          "id-filter"
        ]
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[<IBMBackend('ibm_boston')>,\n",
              " <IBMBackend('ibm_pittsburgh')>,\n",
              " <IBMBackend('ibm_fez')>,\n",
              " <IBMBackend('ibm_kingston')>,\n",
              " <IBMBackend('ibm_miami')>,\n",
              " <IBMBackend('ibm_marrakesh')>,\n",
              " <IBMBackend('ibm_torino')>]"
            ]
          },
          "execution_count": 3,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Optionally pass in an instance, region, or both, to\n",
        "# further filter the backends.\n",
        "service = QiskitRuntimeService()\n",
        "\n",
        "service.backends(simulator=False, operational=True, min_num_qubits=100)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "aefe61eb-27fd-4689-b16e-458a9681c066",
      "metadata": {},
      "source": [
        "<Admonition type=\"note\">\n",
        "  If you are logged in to a specific instance or region, or if you initialized the service with a specific instance or region by using `QiskitRuntimeService()`, only the backends available to you on that instance or region are returned.\n",
        "</Admonition>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "e6d4dafc-33f1-4010-a8fa-33bf37e7f98f",
      "metadata": {},
      "source": [
        "### Filter backends\n",
        "\n",
        "<Tabs>\n",
        "  <TabItem value=\"Qiskit-filter\" label=\"Filter by properties with Qiskit\">\n",
        "    You can filter the available backends by their [configuration](/docs/api/qiskit-ibm-runtime/models-backend-configuration) or [status](/docs/api/qiskit-ibm-runtime/models-backend-status). For more general filters, set the `filters` argument to a function that accepts a backend object and returns `True` if it meets your criteria. Refer to the [API documentation](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service#backends) for more details.\n",
        "\n",
        "    The following code returns only backends that fit these criteria and are available to you *on your currently selected instance*:\n",
        "\n",
        "    * Are real quantum devices (`simulator=False`)\n",
        "    * Are currently operational (`operational=True`)\n",
        "    * Have at least a hundred qubits (`min_num_qubits=100`)\n",
        "\n",
        "    <CodeCellPlaceholder tag=\"id-filter\" />\n",
        "\n",
        "    A similar method is [`QiskitRuntimeService.least_busy()`](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service#least_busy), which takes the same filters as `backends()` but returns the backend that matches the filters and has the least number of jobs pending in the queue:\n",
        "\n",
        "    <CodeCellPlaceholder tag=\"id-least-jobs\" />\n",
        "  </TabItem>\n",
        "\n",
        "  <TabItem value=\"IQP-filter\" label=\"Filter by properties on IBM Quantum Platform\">\n",
        "    To view the backends you have access to, view the table on the [Compute resources page](/computers). Click the filter icon to see filter options. You can filter by processor type and status. Note also that you can sort the table by any column by hovering over a column title, and then clicking the arrows that appear.\n",
        "  </TabItem>\n",
        "</Tabs>\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "id": "7493d247-ade9-4dd2-8bdf-11e332bd6939",
      "metadata": {
        "tags": [
          "id-least-jobs"
        ]
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<IBMBackend('ibm_fez')>"
            ]
          },
          "execution_count": 4,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "service.least_busy(operational=True, min_num_qubits=100)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "1a0c9cbe-48e6-499e-bfb2-ed8bbdbeb38e",
      "metadata": {},
      "source": [
        "## Static backend information\n",
        "\n",
        "Some information about a backend does not change regularly, such as its name, [version](#qpu-versioning), the number of qubits it has, its processor type (the bird family name, which indicates the [topology](#coupling-map) and approximate qubit count), and the types of features it supports. This information is available as attributes of the `backend` object. For a full list of attributes, see the [`IBMBackend` API documentation](/docs/api/qiskit-ibm-runtime/ibm-backend).  Find more information on versioning in the [QPU versioning](#qpu-versioning) section below.\n",
        "\n",
        "A backend's region (the location of the data center where your data and experiments will be hosted and processed) is listed in its detailed information card on the [Compute resources](/computers) page on IBM Quantum Platform.\n",
        "\n",
        "<Tabs>\n",
        "  <TabItem value=\"Qiskit-backend\" label=\"View backend information with Qiskit\">\n",
        "    <CodeCellPlaceholder tag=\"id-version\" />\n",
        "  </TabItem>\n",
        "\n",
        "  <TabItem value=\"IQP-backend\" label=\"View backend information on IBM Quantum Platform\">\n",
        "    Navigate to the [Compute resources](/computers) page to view a table of all QPUs, then click the name of any QPU to open its detailed information card. Find backend information under the Details section of the card.\n",
        "  </TabItem>\n",
        "</Tabs>\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "id": "c15c53ef-301e-47b6-9931-bb5ae1f200dd",
      "metadata": {
        "tags": [
          "id-version"
        ]
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Name: ibm_fez\n",
            "Version: 1.3.37\n",
            "No. of qubits: 156\n",
            "Processor type: {'family': 'Heron', 'revision': '2'}\n",
            "\n"
          ]
        }
      ],
      "source": [
        "backend = service.backend(\"ibm_fez\")\n",
        "\n",
        "print(\n",
        "    f\"Name: {backend.name}\\n\"\n",
        "    f\"Version: {backend.backend_version}\\n\"\n",
        "    f\"No. of qubits: {backend.num_qubits}\\n\"\n",
        "    f\"Processor type: {backend.processor_type}\\n\"\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "99f2db6d-9d77-4330-9e3c-293153cd2f80",
      "metadata": {},
      "source": [
        "### QPU versioning\n",
        "\n",
        "Each QPU has a version number in the form X.Y.Z (major.minor.revision). A circuit compiled for a given version number is guaranteed to run on that QPU. If the revision number changes, the circuit will continue to run. If the major or minor number changes, the circuit is not guaranteed to run, although it may do so.\n",
        "\n",
        "The revision version number will increment for fixes that do not break the existing compiled circuit.\n",
        "\n",
        "The code example earlier in [this section](#static-backend-information) demonstrates how to find a backend's version. On IBM Quantum Platform, you can view the version on a QPU's detailed information card (click the QPU's name on the [Compute resources](/computers) table to open the card).\n",
        "\n",
        "The conditions under which a version or revision number can change are listed in the following table.\n",
        "\n",
        "| Major version                                                            | Minor version                                                                                                           | Revision version                                      |\n",
        "| ------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------- |\n",
        "| Sample changes                                                           | Warmup / cool-down cycles                                                                                               | QPU software updates                                  |\n",
        "| Major changes to the control electronics                                 | Swapping out some electronics, if the replacement appreciably affects operation                                         | Manual calibrations to improve fidelities             |\n",
        "| Moving the QPU to a new location, if significant behavior changes result | Dropping a gate for some duration of time due to calibration issues, and corrections cannot readily be done in software | Small electronics changes that don’t affect operation |\n",
        "|                                                                          | Changing the direction of a CNOT gate                                                                                   |                                                       |\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "42d83190-198e-4696-acb6-9cc5e57c49ab",
      "metadata": {},
      "source": [
        "<span id=\"native-gates-ops\" />\n",
        "\n",
        "### Supported instructions\n",
        "\n",
        "Each [processor family](/docs/guides/processor-types) natively supports a limited set of instructions. This set includes single- and two-qubit gates, as well as non-unitary operations such as measure and reset. Every gate in the circuit must be translated (by the transpiler) to the elements of a QPU's supported instruction set before it can run on the QPU.\n",
        "\n",
        "You can view the supported instruction sets for a QPU with Qiskit. The IBM Quantum Platform Compute resources page lists only the supported unitary gates (basis gates) for a QPU.\n",
        "\n",
        "<Tabs>\n",
        "  <TabItem value=\"Qiskit-native\" label=\"Find supported instructions with Qiskit\">\n",
        "    <CodeCellPlaceholder tag=\"id-gates\" />\n",
        "  </TabItem>\n",
        "\n",
        "  <TabItem value=\"IQP-basis\" label=\"Find basis gates on IBM Quantum Platform\">\n",
        "    Navigate to the [Compute resources](/computers) page to view a table of all QPUs, then click the name of any QPU to open its detailed information card. The basis gates for that QPU are listed in the Details section.\n",
        "  </TabItem>\n",
        "</Tabs>\n",
        "\n",
        "<span id=\"native-gates\" />\n",
        "\n",
        "### Table of supported instructions\n",
        "\n",
        "| Operation category       | Name                                                                                                                                                                                                                                                                                  |\n",
        "| :----------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |\n",
        "| Single-qubit gates       | [`RZ`](/docs/api/qiskit/qiskit.circuit.library.RZGate), [`SX`](/docs/api/qiskit/qiskit.circuit.library.SXGate), [`X`](/docs/api/qiskit/qiskit.circuit.library.XGate), [`ID`](/docs/api/qiskit/qiskit.circuit.library.IGate), [`delay`](/docs/api/qiskit/circuit#qiskit.circuit.Delay) |\n",
        "| Two-qubit gates          | [`CZ`](/docs/api/qiskit/qiskit.circuit.library.CZGate), [`ECR`](/docs/api/qiskit/qiskit.circuit.library.ECRGate)                                                                                                                                                                      |\n",
        "| Fractional gates         | [`RX`](/docs/api/qiskit/qiskit.circuit.library.RXGate) (single-qubit), [`RZZ`](/docs/api/qiskit/qiskit.circuit.library.RZZGate) (two-qubit)                                                                                                                                           |\n",
        "| Non-unitary instructions | [`measure`](/docs/api/qiskit/circuit#qiskit.circuit.Measure), [`reset`](/docs/api/qiskit/circuit#qiskit.circuit.Reset), [`measure_*`](/docs/guides/execute-dynamic-circuits#midcircuit), [`delay`](/docs/api/qiskit/circuit#delay)                                                    |\n",
        "| Control flow             | [`if_else`](/docs/api/qiskit/qiskit.circuit.IfElseOp) (classical feedforward)                                                                                                                                                                                                         |\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "id": "1471a0cb-faf5-419d-9437-b9ecc9a87541",
      "metadata": {
        "tags": [
          "id-gates"
        ]
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Backend: ibm_kingston\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    Processor type: {'family': 'Heron', 'revision': '2'}\n",
            "    Supported instructions: ['cz', 'id', 'delay', 'measure', 'measure_2', 'reset', 'rz', 'sx', 'x', 'if_else']\n"
          ]
        }
      ],
      "source": [
        "from qiskit_ibm_runtime import QiskitRuntimeService\n",
        "\n",
        "service = QiskitRuntimeService()\n",
        "backend = service.backend(\"ibm_kingston\")\n",
        "\n",
        "print(f\"Backend: {backend.name}\")\n",
        "print(f\"    Processor type: {backend.processor_type}\")\n",
        "print(f\"    Supported instructions: {backend.supported_instructions}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "693a91b6-5bd0-411f-ba83-be72d3732402",
      "metadata": {},
      "source": [
        "## Dynamic backend information\n",
        "\n",
        "Backends also have properties that change whenever the backend is calibrated, such as qubit lifetime and operation error rates. Backend properties update after the calibration sequence completes. These properties can be used when optimizing quantum circuits or to construct noise models for a classical simulator. See the [Calibration jobs](/docs/guides/calibration-jobs) guide for more information.\n",
        "\n",
        "On IBM Quantum Platform, you can download calibration data as a CSV file. Click a QPU on the [Compute resources](/computers) page to view its detailed information card, then click the download icon in the upper right corner of the Calibration data section.\n",
        "\n",
        "<Admonition type=\"note\" title=\"Retrieve historical data\">\n",
        "  You can retrieve historical backend properties data in Qiskit with the following code:\n",
        "\n",
        "  ```python\n",
        "  backend.properties(datetime=<datetime>)\n",
        "  ```\n",
        "</Admonition>\n",
        "\n",
        "### Qubit properties\n",
        "\n",
        "[Jump to the list of qubit properties](#view-qubit-properties)\n",
        "\n",
        "`backend.properties().qubit_property()` returns information about the qubits' physical attributes. It contains a dictionary of various properties of the qubit, each paired with its value and the timestamp of the last calibration.\n",
        "\n",
        "The following code examples demonstrate how to list all properties, or retrieve specific properties, of a particular qubit.\n",
        "\n",
        "<CodeCellPlaceholder tag=\"id-properties\" />\n",
        "\n",
        "<CodeCellPlaceholder tag=\"id-properties2\" />\n",
        "\n",
        "#### View qubit properties\n",
        "\n",
        "<span id=\"t1\" />\n",
        "\n",
        "<Accordion>\n",
        "  <AccordionItem title=\"`T1` (Relaxation time)\">\n",
        "    The $T_1$ time represents the average duration a qubit remains in its excited state $|1\\rangle$ before decaying to its ground state $|0\\rangle$ due to energy relaxation. This parameter is used to characterize the qubit's energy relaxation behavior, and is expressed in units of seconds (s).\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">View with Qiskit</Th>\n",
        "          <Td>`backend.properties().t1(<qubit>)`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">View on IBM Quantum Platform</Th>\n",
        "          <Td>Calibration data section, Qubit dropdown menu; find the *$T_1$ median* value in the Details section</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "</Accordion>\n",
        "\n",
        "<span id=\"t2\" />\n",
        "\n",
        "<Accordion>\n",
        "  <AccordionItem title=\"`T2` (Dephasing time)\">\n",
        "    The $T_2$ time denotes the timescale over which a qubit maintains phase coherence of a superposition between the $|0\\rangle$ and $|1\\rangle$ states. It accounts for both energy relaxation and pure dephasing processes, providing insight into the qubit's coherence properties. $T_2$ is reported from a Hahn echo sequence.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">View with Qiskit</Th>\n",
        "          <Td>`backend.properties().t2(<qubit>)`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">View on IBM Quantum Platform</Th>\n",
        "          <Td>Calibration data section, Qubit dropdown menu; find the *$T_2$ median* value in the Details section</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "</Accordion>\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "id": "852d47b7-50c6-4fde-9d59-603825b3ec97",
      "metadata": {
        "tags": [
          "id-properties"
        ]
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "QubitProperties(t1=0.00021773926819388414, t2=0.00026425070120544354, frequency=None)"
            ]
          },
          "execution_count": 7,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# fundamental physical properties of qubit 1\n",
        "\n",
        "backend = service.backend(\"ibm_fez\")\n",
        "\n",
        "backend.qubit_properties(1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "id": "6ec8f609-9542-4f9e-8a68-0829627211b7",
      "metadata": {
        "tags": [
          "id-properties2"
        ]
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Qubit 126 Properties:\n",
            "  T1: 7.277917134771197e-05 seconds\n",
            "  T2: 5.480973335299794e-05 seconds\n",
            "  Readout Error: 0.0079345703125\n",
            "  P(0 | 1): 0.010986328125\n",
            "  P(1 | 0): 0.0048828125\n",
            "  Readout Length: 1.56e-06 seconds\n"
          ]
        }
      ],
      "source": [
        "# Retrieve qubit properties\n",
        "qubit_index = 126  # Replace with your qubit index\n",
        "qubit_props = backend.properties().qubit_property(qubit_index)\n",
        "\n",
        "# Access specific properties\n",
        "t1 = qubit_props.get(\"T1\", (None,))[0]\n",
        "t2 = qubit_props.get(\"T2\", (None,))[0]\n",
        "readout_error = qubit_props.get(\"readout_error\", (None,))[0]\n",
        "prob_meas0_prep1 = qubit_props.get(\"prob_meas0_prep1\", (None,))[0]\n",
        "prob_meas1_prep0 = qubit_props.get(\"prob_meas1_prep0\", (None,))[0]\n",
        "readout_length = qubit_props.get(\"readout_length\", (None,))[0]\n",
        "\n",
        "print(f\"Qubit {qubit_index} Properties:\")\n",
        "print(f\"  T1: {t1} seconds\")\n",
        "print(f\"  T2: {t2} seconds\")\n",
        "print(f\"  Readout Error: {readout_error}\")\n",
        "print(f\"  P(0 | 1): {prob_meas0_prep1}\")\n",
        "print(f\"  P(1 | 0): {prob_meas1_prep0}\")\n",
        "print(f\"  Readout Length: {readout_length} seconds\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2d045537-c8f4-4297-852f-b26311d4640d",
      "metadata": {},
      "source": [
        "### Instruction properties\n",
        "\n",
        "[Jump to the list of instruction properties](#view-instruction-properties)\n",
        "\n",
        "The `backend.target` attribute is a [`qiskit.transpiler.Target`](/docs/api/qiskit/qiskit.transpiler.Target) object: an object that contains all the information needed to transpile a circuit for that backend. This includes instruction errors and durations. For example, the following cell gets the properties for a [`cz` gate](/docs/api/qiskit/qiskit.circuit.library.CZGate) acting between qubits 1 and 0.\n",
        "\n",
        "<CodeCellPlaceholder tag=\"id-instructions\" />\n",
        "\n",
        "The following cell shows the properties for a measurement operation (including the readout error) on qubit 0.\n",
        "\n",
        "<CodeCellPlaceholder tag=\"id-instructions1\" />\n",
        "\n",
        "#### View instruction properties\n",
        "\n",
        "<span id=\"prob-meas0-prep1\" />\n",
        "\n",
        "<Accordion>\n",
        "  <AccordionItem title=\"prob-meas0-prep1\">\n",
        "    This parameter indicates the probability of measuring a qubit in the 0 state when it was intended to be prepared in the $|1\\rangle$ state, denoted as $P(0 | 1)$. It reflects errors in state preparation and measurement (SPAM), particularly measurement errors in superconducting qubits.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">View with Qiskit</Th>\n",
        "          <Td>`backend.properties().qubit_property(<qubit>, 'prob_meas0_prep1')`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">View on IBM Quantum Platform</Th>\n",
        "          <Td>Calibration data section, Qubit dropdown menu</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "</Accordion>\n",
        "\n",
        "<span id=\"prob-meas1-prep0\" />\n",
        "\n",
        "<Accordion>\n",
        "  <AccordionItem title=\"prob-meas1-prep0\">\n",
        "    Similarly, this parameter represents the probability of measuring a qubit in the 1 state when it was intended to be prepared in the $|0\\rangle$ state, denoted as $P(1 | 0)$. Like `prob_meas0_prep1`, it reflects SPAM errors, with measurement errors being the predominant contributor in superconducting qubits.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">View with Qiskit</Th>\n",
        "          <Td>`backend.properties().qubit_property(<qubit>, 'prob_meas0_prep0')`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">View on IBM Quantum Platform</Th>\n",
        "          <Td>Calibration data section, Qubit dropdown menu</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "</Accordion>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f601cb5c-ae7d-4d7b-9666-24b029711b38",
      "metadata": {},
      "source": [
        "<span id=\"2q-error\" />\n",
        "\n",
        "<Accordion>\n",
        "  <AccordionItem title=\"2Q error (Heron and Nighthawk: CZ, Eagle: ECR)\">\n",
        "    The two-qubit error per edge from the same batch of measurements used to calculate the [2Q median](#2q-error-median) error. **2Q error (best)** refers to the lowest two-qubit error on any edge of the device, also from this batch of measurements.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">View with Qiskit</Th>\n",
        "          <Td>`backend.target['<instruction>'][<qubit 1>, <qubit 2>]`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">View on IBM Quantum Platform</Th>\n",
        "          <Td>Calibration section: hover over the qubit connection in Map view, or find the value in Table view under the CZ error (Heron and Nighthawk) or ECR error (Eagle) column; find the value for *2Q error (best)* in the Details section</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "</Accordion>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "430e075e-063f-4f66-bd74-cd820c54ffbc",
      "metadata": {},
      "source": [
        "<span id=\"2q-error-median\" />\n",
        "\n",
        "<Accordion>\n",
        "  <AccordionItem title=\"Median 2Q error (Heron: CZ, Eagle: ECR)\">\n",
        "    [Average gate fidelity](/docs/api/qiskit/quantum_info#average_gate_fidelity) of the two-qubit operation from randomized benchmarking. Measured in \"isolation\": batches with a minimum separation of two qubits between edges. This randomized benchmarking uses alternating layers of single-qubit Cliffords and two-qubit gates, and thus the final 2Q error value includes the error of the layer of single-qubit Cliffords.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Calculate with Qiskit</Th>\n",
        "          <Td>Follow the example in this [Qiskit Community GitHub notebook](https://github.com/qiskit-community/qiskit-device-benchmarking/blob/main/notebooks/device_rb_w_lf.ipynb)</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">View on IBM Quantum Platform</Th>\n",
        "          <Td>Details section; also find per-edge data in the Calibration data section</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "</Accordion>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "236de191-d823-493f-b0c3-981843794e35",
      "metadata": {},
      "source": [
        "<span id=\"2q-error-layered\" />\n",
        "\n",
        "<Accordion>\n",
        "  <AccordionItem title=\"2Q error (layered)\">\n",
        "    Average error per layered gate (EPLG) in a chain of 100 qubits. Average EPLG measures the average gate error in a layered chain of $N$ qubits ($N$=100 here). It is derived from a similar quantity known as the layer fidelity (LF) where EPLG$_{100}$ = 4/5(1-LF$^{\\frac{1}{99}}$) and layer fidelity is the process fidelity of the layered chain of $N$ qubits. For details, see the paper [Benchmarking quantum processor performance at scale](https://arxiv.org/abs/2311.05933). Note that in the paper EPLG is defined for process error, but for consistency with the individually reported gate errors here it is quoted for average gate error, thus the factor of 4/5.\n",
        "\n",
        "    On IBM Quantum Platform, the detailed information card for each QPU has a section called Two-qubit gate error (layered), which provides the expanded view of the lowest `two-qubit gate error (layered)` measured as a function of the number of qubits in the chain. The final value, at chain length 100, is the value presented in the Details section. In practice, six 100-qubit chains (pre-selected based on expected optimal performance) are measured, and the value reported for number of qubits `N` is the lowest error found in a subset length `N` chain searching over the six 100-qubit chains.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Calculate with Qiskit</Th>\n",
        "          <Td>Follow the example in this [Qiskit Community GitHub notebook](https://github.com/qiskit-community/qiskit-device-benchmarking/blob/main/notebooks/layer_fidelity_single_chain.ipynb)</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">View on IBM Quantum Platform</Th>\n",
        "          <Td>Details section, and an expanded view in the Two-qubit gate error (layered) section</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "</Accordion>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "d17ebdaf-5bab-4079-bda3-96731a73ce75",
      "metadata": {},
      "source": [
        "<span id=\"rzz-error\" />\n",
        "\n",
        "<Accordion>\n",
        "  <AccordionItem title=\"RZZ error (Heron)\">\n",
        "    Error in the RZZ gate averaged over the RZZ angles using a variant of randomized benchmarking for arbitrary unitaries.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">View with Qiskit</Th>\n",
        "          <Td>Important: Be sure you have set `use_fractional_gates=True` when you load the backend, then you can use `backend.target['rzz'][<qubit 1>, <qubit 2>]`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">View on IBM Quantum Platform</Th>\n",
        "          <Td>Calibration section: Select RZZ in the Connection dropdown menu and hover over the qubit connection in Map view. You can also select RZZ error in the Graph output dropdown menu in Graph view, or find the value in Table view under the RZZ error column</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "</Accordion>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "75a130f0-59f7-4fe3-9947-8feff4c65281",
      "metadata": {},
      "source": [
        "<span id=\"finite-duration-discrete\" />\n",
        "\n",
        "<Accordion>\n",
        "  <AccordionItem title=\"ID error / √x (sx) error / Pauli-X error / RX error\">\n",
        "    Error in the finite-duration discrete one-qubit gates, measured from randomized benchmarking. The randomized benchmarking sequence includes SX, ID, and X gates, and it is assumed their errors are the same. The ID gate is a delay of duration equal to the duration of the √X and X gates. The RX gate is also the same duration as the √X and X gates with variable amplitude, and so it is reported as having the same error as these gates.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">View with Qiskit</Th>\n",
        "          <Td>`backend.target['<instruction>'][<qubit 1>, ]`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">View on IBM Quantum Platform</Th>\n",
        "          <Td>Calibration section: Qubit dropdown menu</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "</Accordion>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "242a0ef0-dd7f-4361-b3a0-9b6c8df49f80",
      "metadata": {},
      "source": [
        "<span id=\"median-sx-error\" />\n",
        "\n",
        "<Accordion>\n",
        "  <AccordionItem title=\"SX error (median)\">\n",
        "    [Average gate fidelity](/docs/api/qiskit/quantum_info#average_gate_fidelity) of the √X (SX) gate from randomized benchmarking, measured simultaneously on all qubits. The randomized benchmarking sequence includes SX, ID, and X gates, and it is assumed their errors are the same.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">View on IBM Quantum Platform</Th>\n",
        "          <Td>Details section</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "</Accordion>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "b4b702f9-e694-4942-aab4-cbdc46f6b7f7",
      "metadata": {},
      "source": [
        "<span id=\"rz-error\" />\n",
        "\n",
        "<Accordion>\n",
        "  <AccordionItem title=\"Z-axis rotation (RZ) error\">\n",
        "    Error in the virtual RZ gate. Reported as all 0 since these are performed in software.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">View with Qiskit</Th>\n",
        "          <Td> `backend.target['<instruction>'][<qubit 1>, ]`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">View on IBM Quantum Platform</Th>\n",
        "          <Td>Calibration section: Connection dropdown menu</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "</Accordion>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "5e1e4053-0c2f-4b8d-9cc0-3f25c7fdb981",
      "metadata": {},
      "source": [
        "<span id=\"readout-error\" />\n",
        "\n",
        "<Accordion>\n",
        "  <AccordionItem title=\"Readout error\">\n",
        "    The readout error quantifies the average probability of incorrectly measuring a qubit's state. It is commonly calculated as the mean of `prob_meas0_prep1` and `prob_meas1_prep0`, providing a single metric for measurement fidelity.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">View with Qiskit</Th>\n",
        "          <Td>`backend.properties().readout_error(<qubit>)`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">View on IBM Quantum Platform</Th>\n",
        "          <Td>Calibration data section, Qubit dropdown menu</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "</Accordion>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "d8660efa-fc48-467e-acd8-d0fe6041f309",
      "metadata": {},
      "source": [
        "<span id=\"median-readout-error\" />\n",
        "\n",
        "<Accordion>\n",
        "  <AccordionItem title=\"Readout error (median)\">\n",
        "    Fidelity of the readout operation. Readout error is measured by preparing the qubit in the 0 (1) state and measuring the probability of an output in the 1 (0) state. The reported value is the average of these two errors. The median is taken over all qubits.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">View on IBM Quantum Platform</Th>\n",
        "          <Td>Calibration data section, Details section</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "</Accordion>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9e566d6a-cef8-40ee-b80e-182e834bcde3",
      "metadata": {},
      "source": [
        "<span id=\"single-qubit-gate-length\" />\n",
        "\n",
        "<Accordion>\n",
        "  <AccordionItem title=\"Single-qubit gate length\">\n",
        "    Duration of a single-qubit gate operation. Note that values shown on IBM Quantum Platform are in nanoseconds. Values returned in Qiskit are in seconds.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">View with Qiskit</Th>\n",
        "          <Td>`backend.target['<instruction>'][<qubit 1>, ].duration`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">View on IBM Quantum Platform</Th>\n",
        "          <Td>Calibration section: Qubit dropdown menu</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "</Accordion>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "08d4f1f1-52d6-43fc-82a1-05e627da5159",
      "metadata": {},
      "source": [
        "<span id=\"gate-length\" />\n",
        "\n",
        "<Accordion>\n",
        "  <AccordionItem title=\"Gate length (2Q gates)\">\n",
        "    Duration of the two-qubit gate operation. Note that values shown on IBM Quantum Platform are in nanoseconds. Values returned in Qiskit are in seconds.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">View with Qiskit</Th>\n",
        "          <Td>`backend.target['<instruction>'][<qubit 1>, <qubit 2> ].duration`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">View on IBM Quantum Platform</Th>\n",
        "          <Td>Calibration section: Qubit dropdown menu</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "</Accordion>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "397d1189-484e-4f13-9146-7b8dc24c0f21",
      "metadata": {},
      "source": [
        "<span id=\"readout-length\" />\n",
        "\n",
        "<Accordion>\n",
        "  <AccordionItem title=\"Readout length\">\n",
        "    The readout length specifies the duration of the readout operation for a qubit. It measures the time from the initiation of the measurement pulse to the completion of signal digitization, after which the system is ready for the next operation. Understanding this parameter is crucial for optimizing circuit execution, especially when incorporating mid-circuit measurements.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">View with Qiskit</Th>\n",
        "          <Td><ul><li>For `measure`: `backend.properties().readout_length(<qubit>)`</li><li> For `measure_2`: `backend.target['measure_2'][<qubit 1>, ].duration` </li></ul></Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">View on IBM Quantum Platform</Th>\n",
        "          <Td>Calibration data section, Qubit dropdown menu</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "</Accordion>\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "id": "af5e4fc7-8c6c-4f8a-acc9-2a40802d2fa9",
      "metadata": {
        "tags": [
          "id-instructions"
        ]
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "InstructionProperties(duration=6.8e-08, error=0.007200454251140492)"
            ]
          },
          "execution_count": 9,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "backend.target[\"cz\"][(1, 0)]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "id": "9837a240-b649-4117-b795-22c47c2a9b6a",
      "metadata": {
        "tags": [
          "id-instructions1"
        ]
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "InstructionProperties(duration=1.56e-06, error=0.015869140625)"
            ]
          },
          "execution_count": 10,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "backend.target[\"measure\"][(0,)]"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "251f8748-7a6d-4e87-b0f5-8acb91048b36",
      "metadata": {},
      "source": [
        "### Additional properties\n",
        "\n",
        "<span id=\"clops\" />\n",
        "\n",
        "<Accordion>\n",
        "  <AccordionItem title=\"CLOPS (or CLOPS_h)\">\n",
        "    Circuit layer operations per second (CLOPS) is a measure of how many layers of a 100x100 circuit (hardware-aware circuit) a QPU can execute per unit of time.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Calculate with Qiskit</Th>\n",
        "          <Td>Find the [CLOPS code](https://github.com/qiskit-community/qiskit-device-benchmarking/tree/main/qiskit_device_benchmarking/clops#readme) in the Qiskit Community GitHub</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">View on IBM Quantum Platform</Th>\n",
        "          <Td>Details section</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "</Accordion>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f350f7db-4797-46e1-a10c-d0b6af8f68ac",
      "metadata": {},
      "source": [
        "<span id=\"status\" />\n",
        "\n",
        "<Accordion>\n",
        "  <AccordionItem title=\"Status\">\n",
        "    With [`BackendStatus`](/docs/api/qiskit-ibm-runtime/models-backend-status), you can find the QPU status (for example, `Active`, `Paused`, `Offline`) as well as the number of pending jobs.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">View with Qiskit</Th>\n",
        "          <Td>`print(backend.status().status_msg)`, `print(backend.status().pending_jobs)`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">View on IBM Quantum Platform</Th>\n",
        "          <Td>Details section</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "</Accordion>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "0a2bf11b-16a5-48cf-a146-88539b3fd552",
      "metadata": {},
      "source": [
        "<span id=\"coupling-map\" />\n",
        "\n",
        "<Accordion>\n",
        "  <AccordionItem title=\"Topology diagram or coupling map\">\n",
        "    A diagram that indicates the pairs of qubits that support two-qubit gate operations between them. This is also called the coupling map or connectivity. Qubits are represented as circles and the supported two-qubit gate operations are displayed as lines connecting the qubits.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">View with Qiskit</Th>\n",
        "          <Td>`from qiskit.visualization import plot_gate_map` then `plot_gate_map(backend)`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">View on IBM Quantum Platform</Th>\n",
        "          <Td>Calibration data section; Click on Expand for a larger view </Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "</Accordion>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "b054f39f-d3fc-4060-81c6-6ceba4bf8045",
      "metadata": {},
      "source": [
        "<Admonition type=\"note\" title=\"What does `error = 1` mean?\">\n",
        "  If the benchmarking of a qubit or edge does not succeed over the course of several days, whether due to poor data quality or other internal factors, the reported error value is considered stale and will be reported as 1. This is not an indication that the qubit or edge is necessarily non-working or that the error is 1; rather, the error is considered undefined and you should proceed with caution when operating that qubit or gate.\n",
        "</Admonition>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ddeb876a-5260-4b32-83d6-b954c1bd2b9f",
      "metadata": {},
      "source": [
        "## Next steps\n",
        "\n",
        "<Admonition type=\"tip\" title=\"Recommendations\">\n",
        "  * Learn how to [build noise models](/docs/guides/build-noise-models) to do noisy classical simulation.\n",
        "  * Review the [Transpiler stages](/docs/guides/transpiler-stages) topic to learn about how the transpiler uses backend properties for circuit optimization.\n",
        "  * Review the [QiskitRuntime backend API](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service#backend) reference.\n",
        "</Admonition>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "id": "a1b8767d",
      "source": "© IBM Corp., 2017-2026"
    }
  ],
  "metadata": {
    "in_page_toc_max_heading_level": 2,
    "in_page_toc_min_heading_level": 2,
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 4
}