{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "c8e557e7-e1f9-4429-80ad-2907871c704d",
      "metadata": {},
      "source": [
        "---\n",
        "title: \"Ver detalles del backend\"\n",
        "description: \"Enumera y filtra los backends disponibles, y encuentra detalles de la QPU, como datos de configuración y calibración.\"\n",
        "---\n",
        "\n",
        "<span id=\"view-backend-details\" />\n",
        "\n",
        "# Ver detalles del backend\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=\"Versiones del paquete\">\n",
        "    El código de esta página se ha desarrollado siguiendo los siguientes requisitos.\n",
        "    Recomendamos utilizar estas versiones o posteriores.\n",
        "\n",
        "    ```\n",
        "    qiskit-ibm-runtime~=0.47.0\n",
        "    ```\n",
        "  </AccordionItem>\n",
        "</Accordion>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "d76db591-d53c-4753-ab4f-8d6e80bbc39e",
      "metadata": {},
      "source": [
        "Esta página explica cómo encontrar información sobre los backends disponibles.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "1215b9ee-c32f-42db-a1e0-24d62175ab88",
      "metadata": {},
      "source": [
        "<span id=\"list-or-filter-backends\" />\n",
        "\n",
        "## Lista o filtro de backends\n",
        "\n",
        "<span id=\"available\" />\n",
        "\n",
        "<span id=\"list-backends-available-to-you\" />\n",
        "\n",
        "### Lista de backends disponibles para usted\n",
        "\n",
        "Puede utilizar Qiskit o IBM Quantum Platform para ver una lista de los backends disponibles o para buscar un backend concreto.\n",
        "\n",
        "<Admonition type=\"note\" title=\"Nombres de QPU\">\n",
        "  Las QPU alojadas en IBM Cloud® tienen nombres que comienzan por `ibm_*`. A todas las QPU se les asigna un nombre de ciudad, por ejemplo, `ibm_kingston`. Este nombre no indica dónde se aloja realmente la QPU.\n",
        "</Admonition>\n",
        "\n",
        "<Tabs>\n",
        "  <TabItem value=\"Qiskit-available\" label=\"View backends with Qiskit\">\n",
        "    Utilice el [`QiskitRuntimeService.backends()`](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service#backends) método, tal y como se muestra en el siguiente bloque de código. Este método devuelve una lista de [`IBMBackend`](/docs/api/qiskit-ibm-runtime/ibm-backend) instancias.\n",
        "\n",
        "    Para ejecutar el siguiente código, asegúrese de que ya se ha autenticado en el servicio. Consulte [Configurar su cuenta de IBM Cloud](/docs/guides/cloud-setup) para obtener más detalles.\n",
        "\n",
        "    <CodeCellPlaceholder tag=\"id-initialize\" />\n",
        "\n",
        "    Para buscar un backend específico, utilice el [`QiskitRuntimeService.backend()`](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service#backend) método (tenga en cuenta que es singular: *backend* ), que toma el nombre del backend como parámetro de entrada y devuelve una [`IBMBackend`](/docs/api/qiskit-ibm-runtime/ibm-backend) instancia que representa ese backend en particular:\n",
        "\n",
        "    <CodeCellPlaceholder tag=\"id-search\" />\n",
        "  </TabItem>\n",
        "\n",
        "  <TabItem value=\"IQP-available\" label=\"View backends on IBM Quantum Platform\">\n",
        "    Para ver los backends a los que tiene acceso, vaya a la lista de backends en la [página Recursos informáticos](/computers) (tenga en cuenta que la región seleccionada puede afectar a las QPU que aparecen en la lista). Haga clic en el icono del filtro y seleccione «Todas mis instancias» o el nombre de una instancia específica para ver las QPU disponibles.\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_pittsburgh')>,\n",
              " <IBMBackend('ibm_boston')>,\n",
              " <IBMBackend('ibm_fez')>,\n",
              " <IBMBackend('ibm_miami')>,\n",
              " <IBMBackend('ibm_marrakesh')>,\n",
              " <IBMBackend('ibm_kingston')>]"
            ]
          },
          "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_pittsburgh')>,\n",
              " <IBMBackend('ibm_boston')>,\n",
              " <IBMBackend('ibm_fez')>,\n",
              " <IBMBackend('ibm_miami')>,\n",
              " <IBMBackend('ibm_marrakesh')>,\n",
              " <IBMBackend('ibm_kingston')>]"
            ]
          },
          "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",
        "  Si ha iniciado sesión en una instancia o región específica, o si ha inicializado el servicio con una instancia o región específica mediante `QiskitRuntimeService()`, solo se devolverán los backends disponibles para usted en esa instancia o región.\n",
        "</Admonition>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "e6d4dafc-33f1-4010-a8fa-33bf37e7f98f",
      "metadata": {},
      "source": [
        "<span id=\"filter-backends\" />\n",
        "\n",
        "### Backends de filtro\n",
        "\n",
        "<Tabs>\n",
        "  <TabItem value=\"Qiskit-filter\" label=\"Filter by properties with Qiskit\">\n",
        "    Puede filtrar los backends disponibles por su [configuración](/docs/api/qiskit-ibm-runtime/models-backend-configuration) o [estado](/docs/api/qiskit-ibm-runtime/models-backend-status). Para filtros más generales, establezca el `filters` argumento en una función que acepte un objeto backend y devuelva `True` si cumple con sus criterios. Consulte la [documentación](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service#backends) de la API para obtener más detalles.\n",
        "\n",
        "    El siguiente código devuelve solo los backends que cumplen estos criterios y que están disponibles para usted *en la instancia seleccionada actualmente* :\n",
        "\n",
        "    * ¿Son dispositivos cuánticos reales (`simulator=False`)\n",
        "    * Actualmente en funcionamiento (`operational=True`)\n",
        "    * Tener al menos cien qubits (`min_num_qubits=100`)\n",
        "\n",
        "    <CodeCellPlaceholder tag=\"id-filter\" />\n",
        "\n",
        "    Un método similar es [`QiskitRuntimeService.least_busy()`](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service#least_busy), que toma los mismos filtros que `backends()` pero devuelve el backend que coincide con los filtros y tiene el menor número de trabajos pendientes en la cola:\n",
        "\n",
        "    <CodeCellPlaceholder tag=\"id-least-jobs\" />\n",
        "  </TabItem>\n",
        "\n",
        "  <TabItem value=\"IQP-filter\" label=\"Filter by properties on IBM Quantum Platform\">\n",
        "    Para ver los backends a los que tiene acceso, consulte la tabla de la [página Recursos informáticos](/computers). Haga clic en el icono del filtro para ver las opciones de filtrado. Puede filtrar por tipo de procesador y estado. Ten en cuenta también que puedes ordenar la tabla por cualquier columna pasando el cursor por encima del título de una columna y haciendo clic en las flechas que aparecen.\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_marrakesh')>"
            ]
          },
          "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": [
        "<span id=\"static-backend-information\" />\n",
        "\n",
        "## Información estática del backend\n",
        "\n",
        "Algunos datos sobre un backend no cambian con regularidad, como su nombre, [versión](#qpu-versioning), número de qubits, tipo de procesador (el nombre de la familia de aves, que indica la [topología](#coupling-map) y el número aproximado de qubits) y los tipos de funciones que admite. Esta información está disponible como atributos del `backend` objeto. Para obtener una lista completa de atributos, consulte la [`IBMBackend` documentación de la API](/docs/api/qiskit-ibm-runtime/ibm-backend).  Encuentre más información sobre el control de versiones en la sección [de control de versiones de QPU](#qpu-versioning) más abajo.\n",
        "\n",
        "La región de un backend (la ubicación del centro de datos donde se alojarán y procesarán sus datos y experimentos) aparece en su tarjeta de información detallada en la página [Recursos informáticos](/computers) de 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",
        "    Vaya a la página [Recursos informáticos](/computers) para ver una tabla con todas las QPU y, a continuación, haga clic en el nombre de cualquier QPU para abrir su tarjeta de información detallada. Encuentre la información del backend en la sección Detalles de la tarjeta.\n",
        "  </TabItem>\n",
        "</Tabs>\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "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 programmable 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 programmable 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": [
        "<span id=\"qpu-versioning\" />\n",
        "\n",
        "### Versiones de QPU\n",
        "\n",
        "Cada QPU tiene un número de versión con el formato X.Y.Z ( major.minor.revision ). Se garantiza que un circuito compilado para un número de versión determinado se ejecutará en esa QPU. Si cambia el número de revisión, el circuito seguirá funcionando. Si cambia el número mayor o menor, no se garantiza que el circuito funcione, aunque es posible que lo haga.\n",
        "\n",
        "El número de versión de revisión aumentará para las correcciones que no afecten al circuito compilado existente.\n",
        "\n",
        "El ejemplo de código anterior en [esta sección](#static-backend-information) muestra cómo encontrar la versión de un backend. En IBM Quantum Platform, puede ver la versión en la tarjeta de información detallada de una QPU (haga clic en el nombre de la QPU en la tabla [de recursos informáticos](/computers) para abrir la tarjeta).\n",
        "\n",
        "Las condiciones en las que puede cambiar un número de versión o revisión se enumeran en la siguiente tabla.\n",
        "\n",
        "| Versión principal                                                                                  | Versión secundaria                                                                                                                          | Versión revisada                                               |\n",
        "| -------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------- |\n",
        "| Cambios en las muestras                                                                            | Ciclos de calentamiento/enfriamiento                                                                                                        | Actualizaciones de software de QPU                             |\n",
        "| Cambios importantes en la electrónica de control                                                   | Si al cambiar algunos componentes electrónicos, el reemplazo afecta notablemente al funcionamiento                                          | Calibraciones manuales para mejorar la fidelidad               |\n",
        "| Trasladar la QPU a una nueva ubicación, si se producen cambios significativos en el comportamiento | Bajar una compuerta durante un tiempo debido a problemas de calibración, y las correcciones no se pueden realizar fácilmente en el software | Pequeños cambios electrónicos que no afectan al funcionamiento |\n",
        "|                                                                                                    | Cambiar la dirección de una puerta CNOT                                                                                                     |                                                                |\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "42d83190-198e-4696-acb6-9cc5e57c49ab",
      "metadata": {},
      "source": [
        "<span id=\"native-gates-ops\" />\n",
        "\n",
        "<span id=\"supported-instructions\" />\n",
        "\n",
        "### Instrucciones compatibles\n",
        "\n",
        "Cada [familia de procesadores](/docs/guides/processor-types) admite de forma nativa un conjunto limitado de instrucciones. Este conjunto incluye puertas de uno y dos qubits, así como operaciones no unitarias como medición y reinicio. Cada puerta del circuito debe ser traducida (por el transpilador) a los elementos del conjunto de instrucciones compatibles con la QPU antes de que pueda ejecutarse en la QPU.\n",
        "\n",
        "Puede ver los conjuntos de instrucciones compatibles con una QPU con Qiskit. La página de recursos informáticos de IBM Quantum Platform solo incluye las puertas unitarias compatibles (puertas básicas) para una 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",
        "    Vaya a la página [Recursos informáticos](/computers) para ver una tabla con todas las QPU y, a continuación, haga clic en el nombre de cualquier QPU para abrir su tarjeta de información detallada. Las puertas básicas para esa QPU se enumeran en la sección Detalles.\n",
        "  </TabItem>\n",
        "</Tabs>\n",
        "\n",
        "<span id=\"native-gates\" />\n",
        "\n",
        "<span id=\"table-of-supported-instructions\" />\n",
        "\n",
        "### Tabla de instrucciones compatibles\n",
        "\n",
        "| Categoría de operación     | Nombre                                                                                                                                                                                                                                                                                |\n",
        "| :------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |\n",
        "| Puertas de un solo qubit   | [`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",
        "| Puertas de dos qubits      | [`CZ`](/docs/api/qiskit/qiskit.circuit.library.CZGate), [`ECR`](/docs/api/qiskit/qiskit.circuit.library.ECRGate)                                                                                                                                                                      |\n",
        "| Puertas fraccionarias      | [`RX`](/docs/api/qiskit/qiskit.circuit.library.RXGate) (un solo qubit), [`RZZ`](/docs/api/qiskit/qiskit.circuit.library.RZZGate) (dos qubits)                                                                                                                                         |\n",
        "| Instrucciones no unitarias | [`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",
        "| Controlar flujo            | [`if_else`](/docs/api/qiskit/qiskit.circuit.IfElseOp) (alimentación directa clásica)                                                                                                                                                                                                  |\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', 'store']\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": [
        "<span id=\"dynamic-backend-information\" />\n",
        "\n",
        "## Información dinámica del backend\n",
        "\n",
        "Los backends también tienen propiedades que cambian cada vez que se calibra el backend, como la vida útil de los qubits y las tasas de error de funcionamiento. Las propiedades del backend se actualizan una vez completada la secuencia de calibración. Estas propiedades pueden utilizarse para optimizar circuitos cuánticos o para construir modelos de ruido para un simulador clásico. Consulte la guía [de trabajos de calibración](/docs/guides/calibration-jobs) para obtener más información.\n",
        "\n",
        "En IBM Quantum Platform, puede descargar los datos de calibración como un archivo CSV. Haga clic en una QPU en la página [Recursos informáticos](/computers) para ver su tarjeta de información detallada y, a continuación, haga clic en el icono de descarga situado en la esquina superior derecha de la sección Datos de calibración.\n",
        "\n",
        "<Admonition type=\"note\" title=\"Recuperar datos históricos\">\n",
        "  Puede recuperar datos históricos de propiedades del backend en Qiskit con el siguiente código:\n",
        "\n",
        "  ```python\n",
        "  backend.properties(datetime=<datetime>)\n",
        "  ```\n",
        "</Admonition>\n",
        "\n",
        "<span id=\"qubit-properties\" />\n",
        "\n",
        "### Propiedades del qubit\n",
        "\n",
        "[Ir a la lista de propiedades de los qubits](#view-qubit-properties)\n",
        "\n",
        "`backend.properties().qubit_property()` devuelve información sobre los atributos físicos de los qubits. Contiene un diccionario con diversas propiedades del qubit, cada una de ellas emparejada con su valor y la marca de tiempo de la última calibración.\n",
        "\n",
        "Los siguientes ejemplos de código muestran cómo enumerar todas las propiedades o recuperar propiedades específicas de un qubit concreto.\n",
        "\n",
        "<CodeCellPlaceholder tag=\"id-properties\" />\n",
        "\n",
        "<CodeCellPlaceholder tag=\"id-properties2\" />\n",
        "\n",
        "<span id=\"view-qubit-properties\" />\n",
        "\n",
        "#### Ver propiedades del qubit\n",
        "\n",
        "<span id=\"t1\" />\n",
        "\n",
        "<Accordion>\n",
        "  <AccordionItem title=\"`T1` (Tiempo de relajación)\">\n",
        "    El tiempo de vida de la excitación ( $T_1$ ) representa la duración media que un qubit permanece en su estado excitado $|1\\rangle$ antes de decaer a su estado fundamental $|0\\rangle$ debido a la relajación de la energía. Este parámetro se utiliza para caracterizar el comportamiento de relajación energética del qubit y se expresa en segundos (s).\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver con Qiskit</Th>\n",
        "          <Td>`backend.properties().t1(<qubit>)`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver en IBM Quantum Platform</Th>\n",
        "          <Td>Sección de datos de calibración, menú desplegable Qubit; busque el valor *mediano* de $T_1$ en la sección Detalles</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "\n",
        "  <span id=\"t2\" />\n",
        "\n",
        "  <AccordionItem title=\"`T2` (Tiempo de desfase)\">\n",
        "    El tiempo de superposición ( $T_2$ ) denota la escala de tiempo durante la cual un qubit mantiene la coherencia de fase de una superposición entre los estados $|0\\rangle$ y $|1\\rangle$. Tiene en cuenta tanto los procesos de relajación energética como los de desfasamiento puro, lo que proporciona información sobre las propiedades de coherencia del qubit. Se informa de la aparición de « $T_2$ » a partir de una secuencia de eco de Hahn.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver con Qiskit</Th>\n",
        "          <Td>`backend.properties().t2(<qubit>)`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver en IBM Quantum Platform</Th>\n",
        "          <Td>Sección de datos de calibración, menú desplegable Qubit; busque el valor *mediano* de $T_2$ en la sección Detalles</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.00023525336833619243, t2=0.0002320821005698974, 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: 9.634806748588717e-05 seconds\n",
            "  T2: 8.579257084098977e-05 seconds\n",
            "  Readout Error: 0.050048828125\n",
            "  P(0 | 1): 0.0751953125\n",
            "  P(1 | 0): 0.02490234375\n",
            "  Readout Length: 1.7e-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": [
        "<span id=\"instruction-properties\" />\n",
        "\n",
        "### Propiedades de instrucción\n",
        "\n",
        "[Ir a la lista de propiedades de instrucción](#view-instruction-properties)\n",
        "\n",
        "El `backend.target` atributo es un [`qiskit.transpiler.Target`](/docs/api/qiskit/qiskit.transpiler.Target) objeto: un objeto que contiene toda la información necesaria para transpilear un circuito para ese backend. Esto incluye errores de instrucción y duraciones. Por ejemplo, la siguiente celda obtiene las propiedades de un [`cz` puerta](/docs/api/qiskit/qiskit.circuit.library.CZGate) que actúa entre los qubits 1 y 0.\n",
        "\n",
        "<CodeCellPlaceholder tag=\"id-instructions\" />\n",
        "\n",
        "La siguiente celda muestra las propiedades de una operación de medición (incluido el error de lectura) en el qubit 0.\n",
        "\n",
        "<CodeCellPlaceholder tag=\"id-instructions1\" />\n",
        "\n",
        "<span id=\"view-instruction-properties\" />\n",
        "\n",
        "#### Ver propiedades de la instrucción\n",
        "\n",
        "<Accordion>\n",
        "  <span id=\"prob-meas0-prep1\" />\n",
        "\n",
        "  <AccordionItem title=\"prob-meas0-prep1\">\n",
        "    Este parámetro indica la probabilidad de medir un qubit en el estado 0 cuando se pretendía prepararlo en el estado 0 ( $|1\\rangle$ ), denotado como $P(0 | 1)$. Refleja los errores en la preparación y medición del estado (SPAM), en particular los errores de medición en los qubits superconductores.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver con Qiskit</Th>\n",
        "          <Td>`backend.properties().qubit_property(<qubit>, 'prob_meas0_prep1')`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver en IBM Quantum Platform</Th>\n",
        "          <Td>Sección de datos de calibración, menú desplegable Qubit</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "\n",
        "  <span id=\"prob-meas1-prep0\" />\n",
        "\n",
        "  <AccordionItem title=\"prob-meas1-prep0\">\n",
        "    De manera similar, este parámetro representa la probabilidad de medir un qubit en el estado 1 cuando se pretendía prepararlo en el estado $|0\\rangle$, denotado como $P(1 | 0)$. Al igual que `prob_meas0_prep1`, refleja los errores SPAM, siendo los errores de medición el factor predominante en los qubits superconductores.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver con Qiskit</Th>\n",
        "          <Td>`backend.properties().qubit_property(<qubit>, 'prob_meas0_prep0')`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver en IBM Quantum Platform</Th>\n",
        "          <Td>Sección de datos de calibración, menú desplegable Qubit</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "\n",
        "  <span id=\"2q-error\" />\n",
        "\n",
        "  <AccordionItem title=\"2Q error (Heron y Nighthawk: CZ, Eagle: ECR)\">\n",
        "    El error de dos qubits por borde del mismo lote de mediciones utilizado para calcular el error [mediano e 2Q](#2q-error-median). **2Q El error (óptimo)** se refiere al error de dos qubits más bajo en cualquier borde del dispositivo, también a partir de este lote de mediciones.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver con Qiskit</Th>\n",
        "          <Td>`backend.target['<instruction>'][<qubit 1>, <qubit 2>]`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver en IBM Quantum Platform</Th>\n",
        "          <Td>Sección de calibración: coloque el cursor sobre la conexión del qubit en la vista Mapa, o busque el valor en la vista Tabla en la columna Error CZ (Heron y Nighthawk) o Error ECR (Eagle); busque el valor del *error de la conexión de la fuente de calor ( 2Q ) (óptimo)* en la sección Detalles</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "\n",
        "  <span id=\"2q-error-median\" />\n",
        "\n",
        "  <AccordionItem title=\"Error mediano de 2Q e (Heron: CZ, Eagle: ECR)\">\n",
        "    [Fidelidad media](/docs/api/qiskit/quantum_info#average_gate_fidelity) de la puerta de la operación de dos qubits a partir de pruebas comparativas aleatorias. Medido en «aislamiento»: lotes con una separación mínima de dos qubits entre los bordes. Esta comparativa aleatoria utiliza capas alternas de puertas Clifford de un solo qubit y puertas de dos qubits, por lo que el valor final del error de la puerta ( 2Q ) incluye el error de la capa de puertas Clifford de un solo qubit.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Calcular con Qiskit</Th>\n",
        "          <Td>Siga el ejemplo de este [cuaderno de la comunidad Qiskit GitHub.](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\">Ver en IBM Quantum Platform</Th>\n",
        "          <Td>Sección Detalles; también encontrará datos por borde en la sección Datos de calibración</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "\n",
        "  <span id=\"2q-error-layered\" />\n",
        "\n",
        "  <AccordionItem title=\"2Q error (por capas)\">\n",
        "    Error medio por puerta en capas (EPLG) en una cadena de 100 qubits. El EPLG promedio mide el error promedio de puerta en una cadena en capas de qubits e $N$ es ( $N$ =100 aquí). Se deriva de una cantidad similar conocida como fidelidad de capa (LF), donde EPLG $_{100}$ = 4/5(1-LF $^{\\frac{1}{99}}$ ) y la fidelidad de capa es la fidelidad del proceso de la cadena en capas de qubits $N$. Para más detalles, consulte el artículo [Benchmarking quantum processor performance at scale](https://arxiv.org/abs/2311.05933) (Evaluación comparativa del rendimiento de los procesadores cuánticos a gran escala). Tenga en cuenta que en el artículo EPLG se define para el error de proceso, pero para mantener la coherencia con los errores de puerta notificados individualmente, aquí se cita para el error de puerta medio, de ahí el factor de 4/5.\n",
        "\n",
        "    En IBM Quantum Platform, la ficha informativa detallada de cada QPU tiene una sección llamada «Error de puerta de dos qubits (por capas)», que ofrece una vista ampliada del valor más bajo `two-qubit gate error (layered)` medido en función del número de qubits de la cadena. El valor final, con una longitud de cadena de 100, es el valor que se muestra en la sección Detalles. En la práctica, se miden seis cadenas de 100 qubits (preseleccionadas en función del rendimiento óptimo esperado) y el valor indicado para el número de qubits `N` es el error más bajo encontrado en una cadena de `N` longitud subconjunto que busca en las seis cadenas de 100 qubits.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Calcular con Qiskit</Th>\n",
        "          <Td>Siga el ejemplo de este [cuaderno de la comunidad Qiskit GitHub.](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\">Ver en IBM Quantum Platform</Th>\n",
        "          <Td>Sección Detalles y vista ampliada en la sección Error de puerta de dos qubits (en capas)</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "\n",
        "  <span id=\"rzz-error\" />\n",
        "\n",
        "  <AccordionItem title=\"Error RZZ (Heron)\">\n",
        "    Error en la puerta RZZ promediado sobre los ángulos RZZ utilizando una variante de benchmarking aleatorio para unitarios arbitrarios.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver con Qiskit</Th>\n",
        "          <Td>Importante: Asegúrate de haber configurado `use_fractional_gates=True` cuando cargues el backend, entonces podrás usar `backend.target['rzz'][<qubit 1>, <qubit 2>]`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver en IBM Quantum Platform</Th>\n",
        "          <Td>Sección de calibración: Seleccione RZZ en el menú desplegable Conexión y coloque el cursor sobre la conexión del qubit en la vista Mapa. También puede seleccionar el error RZZ en el menú desplegable Salida gráfica de la vista Gráfico, o buscar el valor en la vista Tabla, en la columna Error RZZ</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "\n",
        "  <span id=\"finite-duration-discrete\" />\n",
        "\n",
        "  <AccordionItem title=\"Error de identificación / Error √x (sx) / Error de Pauli-X / Error RX\">\n",
        "    Error en las puertas discretas de un qubit de duración finita, medido a partir de pruebas comparativas aleatorias. La secuencia de benchmarking aleatoria incluye puertas SX, ID y X, y se supone que sus errores son los mismos. La puerta ID es un retardo cuya duración es igual a la duración de las puertas √X y X. La puerta RX también tiene la misma duración que las puertas √X y X con amplitud variable, por lo que se informa que tiene el mismo error que estas puertas.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver con Qiskit</Th>\n",
        "          <Td>`backend.target['<instruction>'][<qubit 1>,]`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver en IBM Quantum Platform</Th>\n",
        "          <Td>Sección de calibración: menú desplegable Qubit</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "\n",
        "  <span id=\"median-sx-error\" />\n",
        "\n",
        "  <AccordionItem title=\"Error SX (mediana)\">\n",
        "    [Fidelidad media](/docs/api/qiskit/quantum_info#average_gate_fidelity) de la puerta √X (SX) a partir de pruebas comparativas aleatorias, medida simultáneamente en todos los qubits. La secuencia de benchmarking aleatoria incluye puertas SX, ID y X, y se supone que sus errores son los mismos.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver en IBM Quantum Platform</Th>\n",
        "          <Td>Sección de detalles</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "\n",
        "  <span id=\"rz-error\" />\n",
        "\n",
        "  <AccordionItem title=\"Error de rotación del eje Z (RZ)\">\n",
        "    Error en la puerta virtual RZ. Se reportan como todos 0, ya que se realizan en el software.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver con Qiskit</Th>\n",
        "          <Td> `backend.target['<instruction>'][<qubit 1>,]`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver en IBM Quantum Platform</Th>\n",
        "          <Td>Sección de calibración: menú desplegable Conexión</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "\n",
        "  <span id=\"readout-error\" />\n",
        "\n",
        "  <AccordionItem title=\"Error de lectura\">\n",
        "    El error de lectura cuantifica la probabilidad media de medir incorrectamente el estado de un qubit. Se calcula comúnmente como la media de `prob_meas0_prep1` y `prob_meas1_prep0`, lo que proporciona una única métrica para medir la fidelidad.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver con Qiskit</Th>\n",
        "          <Td>`backend.properties().readout_error(<qubit>)`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver en IBM Quantum Platform</Th>\n",
        "          <Td>Sección de datos de calibración, menú desplegable Qubit</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "\n",
        "  <span id=\"median-readout-error\" />\n",
        "\n",
        "  <AccordionItem title=\"Error de lectura (mediana)\">\n",
        "    Fidelidad de la operación de lectura. El error de lectura se mide preparando el qubit en el estado 0 (1) y midiendo la probabilidad de una salida en el estado 1 (0). El valor reportado es el promedio de estos dos errores. La mediana se calcula sobre todos los qubits.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver en IBM Quantum Platform</Th>\n",
        "          <Td>Sección de datos de calibración, sección Detalles</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "\n",
        "  <span id=\"single-qubit-gate-length\" />\n",
        "\n",
        "  <AccordionItem title=\"Longitud de la puerta de un solo qubit\">\n",
        "    Duración de una operación de puerta de un solo qubit. Tenga en cuenta que los valores que aparecen en IBM Quantum Platform están expresados en nanosegundos. Los valores devueltos en Qiskit se expresan en segundos.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver con Qiskit</Th>\n",
        "          <Td>`backend.target['<instruction>'][<qubit 1>,].duration`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver en IBM Quantum Platform</Th>\n",
        "          <Td>Sección de calibración: menú desplegable Qubit</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "\n",
        "  <span id=\"gate-length\" />\n",
        "\n",
        "  <AccordionItem title=\"Longitud de la puerta (puertas 2Q )\">\n",
        "    Duración de la operación de la puerta de dos qubits. Tenga en cuenta que los valores que aparecen en IBM Quantum Platform están expresados en nanosegundos. Los valores devueltos en Qiskit se expresan en segundos.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver con Qiskit</Th>\n",
        "          <Td>`backend.target['<instruction>'][<qubit 1>, <qubit 2>].duration`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver en IBM Quantum Platform</Th>\n",
        "          <Td>Sección de calibración: menú desplegable Qubit</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "\n",
        "  <span id=\"readout-length\" />\n",
        "\n",
        "  <AccordionItem title=\"Longitud de lectura\">\n",
        "    La longitud de lectura especifica la duración de la operación de lectura para un qubit. Mide el tiempo transcurrido desde el inicio del pulso de medición hasta la finalización de la digitalización de la señal, tras lo cual el sistema está listo para la siguiente operación. Comprender este parámetro es fundamental para optimizar la ejecución del circuito, especialmente cuando se incorporan mediciones a mitad del circuito.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver con Qiskit</Th>\n",
        "          <Td><ul><li>Para `measure`: `backend.properties().readout_length(<qubit>)`</li><li> Para `measure_2`: `backend.target['measure_2'][<qubit 1>,].duration` </li></ul></Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver en IBM Quantum Platform</Th>\n",
        "          <Td>Sección de datos de calibración, menú desplegable Qubit</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.008303008840692683)"
            ]
          },
          "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.7e-06, error=0.0302734375)"
            ]
          },
          "execution_count": 10,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "backend.target[\"measure\"][(0,)]"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "251f8748-7a6d-4e87-b0f5-8acb91048b36",
      "metadata": {},
      "source": [
        "<span id=\"additional-properties\" />\n",
        "\n",
        "### Propiedades adicionales\n",
        "\n",
        "<span id=\"mcps\" />\n",
        "\n",
        "<Accordion>\n",
        "  <AccordionItem title=\"Número máximo de circuitos por segundo (MCPS)\">\n",
        "    El número máximo de circuitos por segundo (MCPS) incluye la medición, el reinicio y la reinicialización de un circuito mediante una puerta de Hadamard y una única medición.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver con Qiskit</Th>\n",
        "          <Td>`mcps = backend.configuration().mcps`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver en IBM Quantum Platform</Th>\n",
        "          <Td>Sección de detalles</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "\n",
        "  <span id=\"clops\" />\n",
        "\n",
        "  <AccordionItem title=\"CLOPS (o CLOPS_h)\">\n",
        "    Las operaciones por segundo de la capa de circuito (CLOPS) son una medida de cuántas capas de un circuito e 100x100 e (circuito sensible al hardware) puede ejecutar una QPU por unidad de tiempo.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Calcular con Qiskit</Th>\n",
        "          <Td>Encuentre el [código CLOPS](https://github.com/qiskit-community/qiskit-device-benchmarking/tree/main/qiskit_device_benchmarking/clops#readme) en la comunidad Qiskit GitHub</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver en IBM Quantum Platform</Th>\n",
        "          <Td>Sección de detalles</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "\n",
        "  <span id=\"status\" />\n",
        "\n",
        "  <AccordionItem title=\"Estado\">\n",
        "    Con [`BackendStatus`](/docs/api/qiskit-ibm-runtime/models-backend-status), puede encontrar el estado de la QPU (por ejemplo, `Active`, `Paused`, `Offline`) así como el número de trabajos pendientes.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver con Qiskit</Th>\n",
        "          <Td>`print(backend.status().status_msg)`, `print(backend.status().pending_jobs)`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver en IBM Quantum Platform</Th>\n",
        "          <Td>Sección de detalles</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "\n",
        "  <span id=\"coupling-map\" />\n",
        "\n",
        "  <AccordionItem title=\"Diagrama topológico o mapa de acoplamiento\">\n",
        "    Diagrama que indica los pares de qubits que admiten operaciones de puerta de dos qubits entre ellos. Esto también se denomina mapa de acoplamiento o conectividad. Los qubits se representan como círculos y las operaciones de puerta de dos qubits compatibles se muestran como líneas que conectan los qubits.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver con Qiskit</Th>\n",
        "          <Td>`from qiskit.visualization import plot_gate_map` entonces `plot_gate_map(backend)`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver en IBM Quantum Platform</Th>\n",
        "          <Td>Sección de datos de calibración; haga clic en «Expandir» para ampliar la vista </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=\"¿Qué significa `error = 1` ?\">\n",
        "  Si la evaluación comparativa de un qubit o borde no se completa con éxito en el transcurso de varios días, ya sea debido a la mala calidad de los datos u otros factores internos, el valor de error notificado se considera obsoleto y se notificará como 1. Esto no indica necesariamente que el qubit o el borde no funcionen o que el error sea 1; más bien, el error se considera indefinido y se debe proceder con precaución al operar ese qubit o puerta.\n",
        "</Admonition>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ddeb876a-5260-4b32-83d6-b954c1bd2b9f",
      "metadata": {},
      "source": [
        "<span id=\"next-steps\" />\n",
        "\n",
        "## Próximos pasos\n",
        "\n",
        "<Admonition type=\"tip\" title=\"Recomendaciones\">\n",
        "  * Aprenda a [crear modelos de ruido](/docs/guides/build-noise-models) para realizar simulaciones clásicas ruidosas.\n",
        "  * Revise el tema [Etapas del transpilador](/docs/guides/transpiler-stages) para obtener información sobre cómo el transpilador utiliza las propiedades del backend para la optimización de circuitos.\n",
        "  * Consulte la referencia [de la API backend](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service#backend) de QiskitRuntime.\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
}