{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "c8e557e7-e1f9-4429-80ad-2907871c704d",
      "metadata": {},
      "source": [
        "---\n",
        "title: \"Ver detalhes do backend\"\n",
        "description: \"Liste e filtre os backends disponíveis e encontre detalhes da QPU, como dados de configuração e calibração.\"\n",
        "---\n",
        "\n",
        "<span id=\"view-backend-details\" />\n",
        "\n",
        "# Ver detalhes do 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=\"Versões do pacote\">\n",
        "    O código nesta página foi desenvolvido utilizando os seguintes requisitos.\n",
        "    Recomendamos usar essas versões ou mais recentes.\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 como encontrar informações sobre seus back-ends disponíveis.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "1215b9ee-c32f-42db-a1e0-24d62175ab88",
      "metadata": {},
      "source": [
        "<span id=\"list-or-filter-backends\" />\n",
        "\n",
        "## Listar ou filtrar backends\n",
        "\n",
        "<span id=\"available\" />\n",
        "\n",
        "<span id=\"list-backends-available-to-you\" />\n",
        "\n",
        "### Lista de back-ends disponíveis para você\n",
        "\n",
        "Você pode usar o Qiskit ou IBM Quantum Platform para visualizar uma lista de backends disponíveis ou para pesquisar um backend específico.\n",
        "\n",
        "<Admonition type=\"note\" title=\"Nomes de QPU\">\n",
        "  As QPUs hospedadas em IBM Cloud® têm nomes que começam com `ibm_*`. Todas as QPUs recebem o nome de uma cidade - por exemplo, `ibm_kingston`. Este nome não indica onde o QPU real está hospedado.\n",
        "</Admonition>\n",
        "\n",
        "<Tabs>\n",
        "  <TabItem value=\"Qiskit-available\" label=\"View backends with Qiskit\">\n",
        "    Use o [`QiskitRuntimeService.backends()`](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service#backends) método, conforme mostrado no próximo bloco de código. Este método retorna uma lista de [`IBMBackend`](/docs/api/qiskit-ibm-runtime/ibm-backend) instâncias.\n",
        "\n",
        "    Para executar o código a seguir, certifique-se de que você já tenha se autenticado no serviço. Consulte [Configurar sua conta do IBM Cloud](/docs/guides/cloud-setup) para obter mais detalhes.\n",
        "\n",
        "    <CodeCellPlaceholder tag=\"id-initialize\" />\n",
        "\n",
        "    Para procurar um backend específico, use o [`QiskitRuntimeService.backend()`](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service#backend) método (observe que este é singular: *backend* ), que recebe o nome do backend como parâmetro de entrada e retorna uma [`IBMBackend`](/docs/api/qiskit-ibm-runtime/ibm-backend) instância representando esse backend específico:\n",
        "\n",
        "    <CodeCellPlaceholder tag=\"id-search\" />\n",
        "  </TabItem>\n",
        "\n",
        "  <TabItem value=\"IQP-available\" label=\"View backends on IBM Quantum Platform\">\n",
        "    Para visualizar os back-ends aos quais você tem acesso, navegue até a lista de back-ends na [página Recursos de](/computers) computação (observe que a região selecionada pode afetar as QPUs listadas). Clique no ícone do filtro e escolha “Todas as minhas instâncias” ou um nome de instância específico para ver as QPUs disponíveis.\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",
        "  Se você estiver conectado a uma instância ou região específica, ou se tiver inicializado o serviço com uma instância ou região específica usando `QiskitRuntimeService()`, apenas os back-ends disponíveis para você nessa instância ou região serão retornados.\n",
        "</Admonition>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "e6d4dafc-33f1-4010-a8fa-33bf37e7f98f",
      "metadata": {},
      "source": [
        "<span id=\"filter-backends\" />\n",
        "\n",
        "### Back-ends de filtro\n",
        "\n",
        "<Tabs>\n",
        "  <TabItem value=\"Qiskit-filter\" label=\"Filter by properties with Qiskit\">\n",
        "    Você pode filtrar os backends disponíveis por sua [configuração](/docs/api/qiskit-ibm-runtime/models-backend-configuration) ou [status](/docs/api/qiskit-ibm-runtime/models-backend-status). Para filtros mais gerais, defina o `filters` argumento como uma função que aceite um objeto backend e retorne `True` se ele atender aos seus critérios. Consulte a [documentação da](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service#backends) API para obter mais detalhes.\n",
        "\n",
        "    O código a seguir retorna apenas back-ends que atendem a esses critérios e estão disponíveis para você *na instância selecionada atualmente* :\n",
        "\n",
        "    * São dispositivos quânticos reais (`simulator=False`)\n",
        "    * Estão atualmente em funcionamento (`operational=True`)\n",
        "    * Tenha pelo menos cem qubits (`min_num_qubits=100`)\n",
        "\n",
        "    <CodeCellPlaceholder tag=\"id-filter\" />\n",
        "\n",
        "    Um método semelhante é [`QiskitRuntimeService.least_busy()`](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service#least_busy), que utiliza os mesmos filtros que, `backends()` mas retorna o backend que corresponde aos filtros e tem o menor número de tarefas pendentes na fila:\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 visualizar os back-ends aos quais você tem acesso, consulte a tabela na [página Recursos de](/computers) computação. Clique no ícone do filtro para ver as opções de filtro. Você pode filtrar por tipo e status do processador. Observe também que você pode classificar a tabela por qualquer coluna passando o mouse sobre o título da coluna e clicando nas setas que aparecem.\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",
        "## Informações estáticas do backend\n",
        "\n",
        "Algumas informações sobre um backend não mudam regularmente, como seu nome, [versão](#qpu-versioning), número de qubits, tipo de processador (o nome da família de pássaros, que indica a [topologia](#coupling-map) e a contagem aproximada de qubits) e os tipos de recursos que ele suporta. Essas informações estão disponíveis como atributos do objeto `backend` . Para obter uma lista completa de atributos, consulte a [`IBMBackend` documentação da API](/docs/api/qiskit-ibm-runtime/ibm-backend).  Encontre mais informações sobre controle de versão na seção [Controle de versão do](#qpu-versioning) QPU abaixo.\n",
        "\n",
        "A região de um backend (a localização do centro de dados onde seus dados e experimentos serão hospedados e processados) está listada em seu cartão de informações detalhadas na página [Recursos de computação](/computers) em 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",
        "    Navegue até a página [Recursos de computação](/computers) para visualizar uma tabela com todas as QPUs e clique no nome de qualquer QPU para abrir seu cartão de informações detalhadas. Encontre informações de back-end na seção Detalhes do cartão.\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",
        "### Versões da QPU\n",
        "\n",
        "Cada QPU possui um número de versão no formato X.Y.Z ( major.minor.revision ). Um circuito compilado para um determinado número de versão tem garantia de execução nessa QPU. Se o número da revisão mudar, o circuito continuará a funcionar. Se o número principal ou secundário mudar, não há garantia de que o circuito funcione, embora possa funcionar.\n",
        "\n",
        "O número da versão de revisão será incrementado para correções que não afetem o circuito compilado existente.\n",
        "\n",
        "O exemplo de código apresentado anteriormente [nesta seção](#static-backend-information) demonstra como encontrar a versão de um backend. Em IBM Quantum Platform, você pode visualizar a versão no cartão de informações detalhadas de uma QPU (clique no nome da QPU na tabela [Recursos de](/computers) computação para abrir o cartão).\n",
        "\n",
        "As condições sob as quais um número de versão ou revisão pode ser alterado estão listadas na tabela a seguir.\n",
        "\n",
        "| Versão principal                                                                      | Versão secundária                                                                                                                | Versão revisada                                                |\n",
        "| ------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------- |\n",
        "| Alterações na amostra                                                                 | Ciclos de aquecimento/desaquecimento                                                                                             | Atualizações de software da QPU                                |\n",
        "| Grandes mudanças na eletrônica de controle                                            | Trocar alguns componentes eletrônicos, se a substituição afetar significativamente o funcionamento                               | Calibrações manuais para melhorar a fidelidade                 |\n",
        "| Mudança da QPU para um novo local, se houver mudanças significativas no comportamento | Desativar um portão por algum tempo devido a problemas de calibração, e as correções não podem ser feitas facilmente no software | Pequenas alterações eletrônicas que não afetam o funcionamento |\n",
        "|                                                                                       | Alterando a direção de uma porta 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",
        "### Instruções suportadas\n",
        "\n",
        "Cada [família de processadores](/docs/guides/processor-types) suporta nativamente um conjunto limitado de instruções. Este conjunto inclui portas de um e dois qubits, bem como operações não unitárias, tais como medição e reinicialização. Cada porta do circuito deve ser traduzida (pelo transpiler) para os elementos do conjunto de instruções suportadas por uma QPU antes de poder ser executada na QPU.\n",
        "\n",
        "Você pode visualizar os conjuntos de instruções suportados para uma QPU com o Qiskit. A página Recursos de computação do IBM Quantum Platform lista apenas os portões unitários (portões básicos) suportados por uma 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",
        "    Navegue até a página [Recursos de computação](/computers) para visualizar uma tabela com todas as QPUs e clique no nome de qualquer QPU para abrir seu cartão de informações detalhadas. Os portões básicos para essa QPU estão listados na seção Detalhes.\n",
        "  </TabItem>\n",
        "</Tabs>\n",
        "\n",
        "<span id=\"native-gates\" />\n",
        "\n",
        "<span id=\"table-of-supported-instructions\" />\n",
        "\n",
        "### Tabela de instruções suportadas\n",
        "\n",
        "| Categoria de operação    | Nome                                                                                                                                                                                                                                                                                  |\n",
        "| :----------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |\n",
        "| Portas de qubit único    | [`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",
        "| Portas de dois qubits    | [`CZ`](/docs/api/qiskit/qiskit.circuit.library.CZGate), [`ECR`](/docs/api/qiskit/qiskit.circuit.library.ECRGate)                                                                                                                                                                      |\n",
        "| Portas fracionárias      | [`RX`](/docs/api/qiskit/qiskit.circuit.library.RXGate) (qubit único), [`RZZ`](/docs/api/qiskit/qiskit.circuit.library.RZZGate) (dois qubits)                                                                                                                                          |\n",
        "| Instruções não unitárias | [`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",
        "| Fluxo de Controle        | [`if_else`](/docs/api/qiskit/qiskit.circuit.IfElseOp) (alimentação direta clássica)                                                                                                                                                                                                   |\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",
        "## Informações dinâmicas do backend\n",
        "\n",
        "Os backends também possuem propriedades que mudam sempre que o backend é calibrado, como a vida útil do qubit e as taxas de erro de operação. As propriedades do backend são atualizadas após a conclusão da sequência de calibração. Essas propriedades podem ser usadas na otimização de circuitos quânticos ou na construção de modelos de ruído para um simulador clássico. Consulte o guia [de tarefas de calibração](/docs/guides/calibration-jobs) para obter mais informações.\n",
        "\n",
        "Em IBM Quantum Platform, você pode baixar os dados de calibração como um arquivo CSV. Clique em uma QPU na página [Recursos de](/computers) computação para visualizar seu cartão de informações detalhadas e, em seguida, clique no ícone de download no canto superior direito da seção Dados de calibração.\n",
        "\n",
        "<Admonition type=\"note\" title=\"Recuperar dados históricos\">\n",
        "  Você pode recuperar dados históricos de propriedades de backend no Qiskit com o seguinte código:\n",
        "\n",
        "  ```python\n",
        "  backend.properties(datetime=<datetime>)\n",
        "  ```\n",
        "</Admonition>\n",
        "\n",
        "<span id=\"qubit-properties\" />\n",
        "\n",
        "### Propriedades do qubit\n",
        "\n",
        "[Ir para a lista de propriedades do qubit](#view-qubit-properties)\n",
        "\n",
        "`backend.properties().qubit_property()` retorna informações sobre os atributos físicos dos qubits. Ele contém um dicionário com várias propriedades do qubit, cada uma emparelhada com seu valor e o carimbo de data/hora da última calibração.\n",
        "\n",
        "Os exemplos de código a seguir demonstram como listar todas as propriedades ou recuperar propriedades específicas de um qubit específico.\n",
        "\n",
        "<CodeCellPlaceholder tag=\"id-properties\" />\n",
        "\n",
        "<CodeCellPlaceholder tag=\"id-properties2\" />\n",
        "\n",
        "<span id=\"view-qubit-properties\" />\n",
        "\n",
        "#### Ver propriedades do qubit\n",
        "\n",
        "<span id=\"t1\" />\n",
        "\n",
        "<Accordion>\n",
        "  <AccordionItem title=\"`T1` (Tempo de relaxamento)\">\n",
        "    O tempo de decaimento ( $T_1$ ) representa a duração média que um qubit permanece em seu estado excitado ( $|1\\rangle$ ) antes de decair para seu estado fundamental ( $|0\\rangle$ ) devido ao relaxamento de energia. Este parâmetro é usado para caracterizar o comportamento de relaxamento energético do qubit e é expresso em unidades de segundos (s).\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Visualizar com Qiskit</Th>\n",
        "          <Td>`backend.properties().t1(<qubit>)`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver em IBM Quantum Platform</Th>\n",
        "          <Td>Seção de dados de calibração, menu suspenso Qubit; encontre o valor *mediano* de $T_1$ na seção Detalhes</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "\n",
        "  <span id=\"t2\" />\n",
        "\n",
        "  <AccordionItem title=\"`T2` (Tempo de defasagem)\">\n",
        "    O tempo de coesão ( $T_2$ ) denota a escala de tempo durante a qual um qubit mantém a coerência de fase de uma superposição entre os estados $|0\\rangle$ e $|1\\rangle$. Ele leva em consideração tanto o relaxamento energético quanto os processos de desfasamento puro, fornecendo informações sobre as propriedades de coerência do qubit. A análise de espectro de fase ( $T_2$ ) é relatada a partir de uma sequência de eco de Hahn.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Visualizar com Qiskit</Th>\n",
        "          <Td>`backend.properties().t2(<qubit>)`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver em IBM Quantum Platform</Th>\n",
        "          <Td>Seção de dados de calibração, menu suspenso Qubit; encontre o valor *mediano* de $T_2$ na seção Detalhes</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",
        "### Propriedades da instrução\n",
        "\n",
        "[Ir para a lista de propriedades de instrução](#view-instruction-properties)\n",
        "\n",
        "O `backend.target` atributo é um [`qiskit.transpiler.Target`](/docs/api/qiskit/qiskit.transpiler.Target) objeto: um objeto que contém todas as informações necessárias para transpilá-lo para esse backend. Isso inclui erros de instrução e durações. Por exemplo, a célula a seguir obtém as propriedades para um [`cz` portão](/docs/api/qiskit/qiskit.circuit.library.CZGate) atuando entre os qubits 1 e 0.\n",
        "\n",
        "<CodeCellPlaceholder tag=\"id-instructions\" />\n",
        "\n",
        "A célula a seguir mostra as propriedades de uma operação de medição (incluindo o erro de leitura) no qubit 0.\n",
        "\n",
        "<CodeCellPlaceholder tag=\"id-instructions1\" />\n",
        "\n",
        "<span id=\"view-instruction-properties\" />\n",
        "\n",
        "#### Exibir propriedades da instrução\n",
        "\n",
        "<Accordion>\n",
        "  <span id=\"prob-meas0-prep1\" />\n",
        "\n",
        "  <AccordionItem title=\"prob-meas0-prep1\">\n",
        "    Este parâmetro indica a probabilidade de medir um qubit no estado 0 quando se pretendia prepará-lo no estado $|1\\rangle$, denotado como $P(0 | 1)$. Ele reflete erros na preparação e medição do estado (SPAM), particularmente erros de medição em qubits supercondutores.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Visualizar com Qiskit</Th>\n",
        "          <Td>`backend.properties().qubit_property(<qubit>, 'prob_meas0_prep1')`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver em IBM Quantum Platform</Th>\n",
        "          <Td>Seção de dados de calibração, menu suspenso 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",
        "    Da mesma forma, este parâmetro representa a probabilidade de medir um qubit no estado 1 quando se pretendia prepará-lo no estado $|0\\rangle$, denotado como $P(1 | 0)$. Tal como `prob_meas0_prep1`, reflete erros SPAM, sendo os erros de medição o principal contribuinte nos qubits supercondutores.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Visualizar com Qiskit</Th>\n",
        "          <Td>`backend.properties().qubit_property(<qubit>, 'prob_meas0_prep0')`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver em IBM Quantum Platform</Th>\n",
        "          <Td>Seção de dados de calibração, menu suspenso Qubit</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "\n",
        "  <span id=\"2q-error\" />\n",
        "\n",
        "  <AccordionItem title=\"2Q erro (Heron e Nighthawk: CZ, Eagle: ECR)\">\n",
        "    O erro de dois qubits por borda do mesmo lote de medições usado para calcular o erro [mediano](#2q-error-median) 2Q. **2Q erro (melhor)** refere-se ao menor erro de dois qubits em qualquer borda do dispositivo, também a partir deste lote de medições.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Visualizar com Qiskit</Th>\n",
        "          <Td>`backend.target['<instruction>'][<qubit 1>, <qubit 2>]`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver em IBM Quantum Platform</Th>\n",
        "          <Td>Seção de calibração: passe o mouse sobre a conexão do qubit na visualização do mapa ou encontre o valor na visualização da tabela na coluna CZ error (Heron e Nighthawk) ou ECR error (Eagle); encontre o valor para *o erro de 2Q (melhor)* na seção Detalhes</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "\n",
        "  <span id=\"2q-error-median\" />\n",
        "\n",
        "  <AccordionItem title=\"Erro mediano de 2Q (Heron: CZ, Eagle: ECR)\">\n",
        "    [Fidelidade média da porta](/docs/api/qiskit/quantum_info#average_gate_fidelity) da operação de dois qubits a partir de benchmarking aleatório. Medido em “isolamento”: lotes com uma separação mínima de dois qubits entre as bordas. Esta comparação aleatória utiliza camadas alternadas de Cliffords de qubit único e portas de dois qubits e, portanto, o valor final do erro de 2Q inclui o erro da camada de Cliffords de qubit único.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Calcule com o Qiskit</Th>\n",
        "          <Td>Siga o exemplo neste [notebook da Comunidade 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 em IBM Quantum Platform</Th>\n",
        "          <Td>Seção Detalhes; também encontre dados por borda na seção Dados de calibração</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "\n",
        "  <span id=\"2q-error-layered\" />\n",
        "\n",
        "  <AccordionItem title=\"Erro de 2Q (em camadas)\">\n",
        "    Erro médio por porta em camadas (EPLG) em uma cadeia de 100 qubits. A EPLG média mede o erro médio de porta em uma cadeia em camadas de qubits de $N$ ( $N$ =100 aqui). É derivado de uma quantidade semelhante conhecida como fidelidade de camada (LF), em que EPLG $_{100}$ = 4/5(1-LF $^{\\frac{1}{99}}$ ) e a fidelidade de camada é a fidelidade do processo da cadeia em camadas de qubits $N$. Para obter detalhes, consulte o artigo [Benchmarking quantum processor performance at scale](https://arxiv.org/abs/2311.05933) (Avaliação comparativa do desempenho do processador quântico em escala). Observe que, no artigo, o EPLG é definido para erros de processo, mas, para manter a consistência com os erros de porta relatados individualmente, aqui ele é citado para o erro médio de porta, daí o fator de 4/5.\n",
        "\n",
        "    Em IBM Quantum Platform, o cartão de informações detalhadas para cada QPU tem uma seção chamada Erro de porta de dois qubits (em camadas), que fornece uma visão ampliada do valor mais baixo `two-qubit gate error (layered)` medido em função do número de qubits na cadeia. O valor final, com comprimento de cadeia 100, é o valor apresentado na seção Detalhes. Na prática, são medidas seis cadeias de 100 qubits (pré-selecionadas com base no desempenho ideal esperado), e o valor relatado para o número de qubits `N` é o menor erro encontrado em uma cadeia de `N` comprimento de subconjunto que pesquisa as seis cadeias de 100 qubits.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Calcule com o Qiskit</Th>\n",
        "          <Td>Siga o exemplo neste [notebook da Comunidade 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 em IBM Quantum Platform</Th>\n",
        "          <Td>Seção Detalhes e uma visualização ampliada na seção Erro de porta de dois qubits (em camadas)</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "\n",
        "  <span id=\"rzz-error\" />\n",
        "\n",
        "  <AccordionItem title=\"Erro RZZ (Heron)\">\n",
        "    Erro no portão RZZ calculado com base na média dos ângulos RZZ utilizando uma variante de benchmarking aleatório para unitários arbitrários.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Visualizar com Qiskit</Th>\n",
        "          <Td>Importante: Certifique-se de ter definido `use_fractional_gates=True` ao carregar o backend, então você poderá usar `backend.target['rzz'][<qubit 1>, <qubit 2>]`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver em IBM Quantum Platform</Th>\n",
        "          <Td>Seção de calibração: Selecione RZZ no menu suspenso Conexão e passe o mouse sobre a conexão do qubit na visualização Mapa. Você também pode selecionar o erro RZZ no menu suspenso Saída do gráfico na visualização Gráfico ou encontrar o valor na visualização Tabela, na coluna Erro RZZ</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "\n",
        "  <span id=\"finite-duration-discrete\" />\n",
        "\n",
        "  <AccordionItem title=\"Erro de identificação / erro √x (sx) / erro de Pauli-X / erro RX\">\n",
        "    Erro nas portas discretas de um qubit de duração finita, medido a partir de benchmarking aleatório. A sequência de benchmarking aleatória inclui portas SX, ID e X, e presume-se que seus erros sejam os mesmos. O portão ID é um atraso de duração igual à duração dos portões √X e X. O portão RX também tem a mesma duração que os portões √X e X com amplitude variável e, portanto, é relatado como tendo o mesmo erro que esses portões.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Visualizar com Qiskit</Th>\n",
        "          <Td>`backend.target['<instruction>'][<qubit 1>,]`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver em IBM Quantum Platform</Th>\n",
        "          <Td>Seção de calibração: menu suspenso Qubit</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "\n",
        "  <span id=\"median-sx-error\" />\n",
        "\n",
        "  <AccordionItem title=\"Erro de SX (mediana)\">\n",
        "    [Fidelidade média](/docs/api/qiskit/quantum_info#average_gate_fidelity) do portão √X (SX) a partir de benchmarking aleatório, medida simultaneamente em todos os qubits. A sequência de benchmarking aleatória inclui portas SX, ID e X, e presume-se que seus erros sejam os mesmos.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver em IBM Quantum Platform</Th>\n",
        "          <Td>Seção de detalhes</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "\n",
        "  <span id=\"rz-error\" />\n",
        "\n",
        "  <AccordionItem title=\"Erro de rotação do eixo Z (RZ)\">\n",
        "    Erro no portão virtual RZ. Relatado como todo 0, uma vez que são executados no software.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Visualizar com Qiskit</Th>\n",
        "          <Td> `backend.target['<instruction>'][<qubit 1>,]`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver em IBM Quantum Platform</Th>\n",
        "          <Td>Seção de calibração: Menu suspenso de conexão</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "\n",
        "  <span id=\"readout-error\" />\n",
        "\n",
        "  <AccordionItem title=\"Erro de leitura\">\n",
        "    O erro de leitura quantifica a probabilidade média de medir incorretamente o estado de um qubit. É comumente calculado como a média de `prob_meas0_prep1` e `prob_meas1_prep0`, fornecendo uma única métrica para a fidelidade da medição.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Visualizar com Qiskit</Th>\n",
        "          <Td>`backend.properties().readout_error(<qubit>)`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver em IBM Quantum Platform</Th>\n",
        "          <Td>Seção de dados de calibração, menu suspenso Qubit</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "\n",
        "  <span id=\"median-readout-error\" />\n",
        "\n",
        "  <AccordionItem title=\"Erro de leitura (mediana)\">\n",
        "    Precisão da operação de leitura. O erro de leitura é medido preparando o qubit no estado 0 (1) e medindo a probabilidade de uma saída no estado 1 (0). O valor relatado é a média desses dois erros. A mediana é calculada para todos os qubits.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver em IBM Quantum Platform</Th>\n",
        "          <Td>Seção de dados de calibração, seção Detalhes</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "\n",
        "  <span id=\"single-qubit-gate-length\" />\n",
        "\n",
        "  <AccordionItem title=\"Comprimento do porta de qubit único\">\n",
        "    Duração de uma operação de porta de qubit único. Observe que os valores apresentados em IBM Quantum Platform estão em nanossegundos. Os valores retornados no Qiskit são em segundos.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Visualizar com Qiskit</Th>\n",
        "          <Td>`backend.target['<instruction>'][<qubit 1>,].duration`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver em IBM Quantum Platform</Th>\n",
        "          <Td>Seção de calibração: menu suspenso Qubit</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "\n",
        "  <span id=\"gate-length\" />\n",
        "\n",
        "  <AccordionItem title=\"Comprimento do portão (portões 2Q )\">\n",
        "    Duração da operação da porta de dois qubits. Observe que os valores apresentados em IBM Quantum Platform estão em nanossegundos. Os valores retornados no Qiskit são em segundos.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Visualizar com Qiskit</Th>\n",
        "          <Td>`backend.target['<instruction>'][<qubit 1>, <qubit 2>].duration`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver em IBM Quantum Platform</Th>\n",
        "          <Td>Seção de calibração: menu suspenso Qubit</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "\n",
        "  <span id=\"readout-length\" />\n",
        "\n",
        "  <AccordionItem title=\"Comprimento da leitura\">\n",
        "    O comprimento da leitura especifica a duração da operação de leitura para um qubit. Ele mede o tempo desde o início do pulso de medição até a conclusão da digitalização do sinal, após o qual o sistema fica pronto para a próxima operação. Compreender esse parâmetro é fundamental para otimizar a execução do circuito, especialmente ao incorporar medições no meio do circuito.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Visualizar com 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 em IBM Quantum Platform</Th>\n",
        "          <Td>Seção de dados de calibração, menu suspenso 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",
        "### Propriedades adicionais\n",
        "\n",
        "<span id=\"mcps\" />\n",
        "\n",
        "<Accordion>\n",
        "  <AccordionItem title=\"Número máximo de circuitos por segundo (MCPS)\">\n",
        "    O número máximo de circuitos por segundo (MCPS) inclui a medição, o reset e a reinicialização de um circuito com uma porta de Hadamard e uma única medição.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Visualizar com Qiskit</Th>\n",
        "          <Td>`mcps = backend.configuration().mcps`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver em IBM Quantum Platform</Th>\n",
        "          <Td>Seção de detalhes</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "\n",
        "  <span id=\"clops\" />\n",
        "\n",
        "  <AccordionItem title=\"CLOPS (ou CLOPS_h)\">\n",
        "    Operações de camada de circuito por segundo (CLOPS) é uma medida de quantas camadas de um circuito 100x100 (circuito com reconhecimento de hardware) uma QPU pode executar por unidade de tempo.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Calcule com o Qiskit</Th>\n",
        "          <Td>Encontre o [código CLOPS](https://github.com/qiskit-community/qiskit-device-benchmarking/tree/main/qiskit_device_benchmarking/clops#readme) na Comunidade Qiskit GitHub</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver em IBM Quantum Platform</Th>\n",
        "          <Td>Seção de detalhes</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "\n",
        "  <span id=\"status\" />\n",
        "\n",
        "  <AccordionItem title=\"Status\">\n",
        "    Com [`BackendStatus`](/docs/api/qiskit-ibm-runtime/models-backend-status), você pode encontrar o status da QPU (por exemplo, `Active`, `Paused`, `Offline`) bem como o número de tarefas pendentes.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Visualizar com 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 em IBM Quantum Platform</Th>\n",
        "          <Td>Seção de detalhes</Td>\n",
        "        </Tr>\n",
        "      </TBody>\n",
        "    </Table>\n",
        "  </AccordionItem>\n",
        "\n",
        "  <span id=\"coupling-map\" />\n",
        "\n",
        "  <AccordionItem title=\"Diagrama topológico ou mapa de acoplamento\">\n",
        "    Um diagrama que indica os pares de qubits que suportam operações de porta de dois qubits entre eles. Isso também é chamado de mapa de acoplamento ou conectividade. Os qubits são representados como círculos e as operações de porta de dois qubits suportadas são exibidas como linhas conectando os qubits.\n",
        "\n",
        "    <Table>\n",
        "      <TBody>\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Visualizar com Qiskit</Th>\n",
        "          <Td>`from qiskit.visualization import plot_gate_map` então `plot_gate_map(backend)`</Td>\n",
        "        </Tr>\n",
        "\n",
        "        <Tr>\n",
        "          <Th scope=\"row\">Ver em IBM Quantum Platform</Th>\n",
        "          <Td>Seção de dados de calibração; clique em Expandir para ampliar a imagem </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=\"O que isso `error = 1` significa?\">\n",
        "  Se a avaliação comparativa de um qubit ou borda não for bem-sucedida ao longo de vários dias, seja devido à baixa qualidade dos dados ou a outros fatores internos, o valor de erro relatado é considerado obsoleto e será relatado como 1. Isso não significa necessariamente que o qubit ou a borda não estejam funcionando ou que o erro seja 1; em vez disso, o erro é considerado indefinido e você deve proceder com cautela ao operar esse qubit ou porta.\n",
        "</Admonition>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ddeb876a-5260-4b32-83d6-b954c1bd2b9f",
      "metadata": {},
      "source": [
        "<span id=\"next-steps\" />\n",
        "\n",
        "## Próximas etapas\n",
        "\n",
        "<Admonition type=\"tip\" title=\"Recomendações\">\n",
        "  * Aprenda a [construir modelos de ruído](/docs/guides/build-noise-models) para realizar simulações clássicas ruidosas.\n",
        "  * Consulte o tópico [Etapas do transpiler](/docs/guides/transpiler-stages) para saber como o transpiler usa propriedades de back-end para otimização de circuitos.\n",
        "  * Consulte a referência [da API de back-end](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service#backend) do 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
}