{ "cells": [ { "cell_type": "markdown", "id": "552b1077", "metadata": {}, "source": [ "---\n", "title: \"Execute seu primeiro circuito no hardware\"\n", "description: \"Comece a usar o Qiskit com um hardwar IBM Quantum e neste exemplo Hello World\"\n", "---\n", "\n", "\n", "\n", "# Execute seu primeiro circuito no hardware\n", "\n" ] }, { "cell_type": "markdown", "id": "7cc19a86-a234-4220-bb4f-d66d3834e0c3", "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", "\n", " \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[all]~=2.5.0\n", " qiskit-ibm-runtime~=0.47.0\n", " ```\n", " \n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "1a3c196d-545d-417f-b34e-fa422aa9a394", "metadata": {}, "source": [ "Este exemplo contém duas partes. Primeiro, você criará um programa quântico simples “Olá, mundo” e o executará em uma unidade de processamento quântico (QPU). Como a pesquisa quântica real requer programas muito mais robustos, na segunda seção ( [Escala para um grande número de qubits](#scale-to-large-numbers-of-qubits) ), você ampliará o programa simples até o nível de utilidade.\n", "\n" ] }, { "cell_type": "markdown", "id": "7b65f7e0", "metadata": {}, "source": [ "\n", "\n", "## Instalar e autenticar\n", "\n", "1. Se você ainda não instalou o Qiskit, consulte as instruções no guia [de início rápido](/docs/guides/quick-start).\n", "\n", " * Instale Qiskit Runtime para executar tarefas em hardware quântico:\n", "\n", " ```bash\n", " pip install qiskit-ibm-runtime\n", " ```\n", "\n", " * Configure um ambiente para executar notebooks Jupyter localmente:\n", "\n", " ```bash\n", " pip install jupyter\n", " ```\n", "\n", "2. Configure sua autenticação para acessar o hardware quântico através do [Open Plan](/docs/guides/plans-overview#open-plan) gratuito.\n", "\n", " (Se você recebeu um convite por e-mail para participar de uma conta, siga as [etapas para usuários convidados](/docs/guides/cloud-setup-invited).)\n", "\n", " * Acesse [IBM Quantum Platform](/) para fazer login ou criar uma conta.\n", " \n", " Se você se conectar por meio de um servidor proxy, deverá usar Qiskit Runtime v0.44.0 ou posterior.\n", " \n", "\n", " * Gere sua chave API (também chamada de *token API* ) no [painel](/) e copie-a para um local seguro.\n", "\n", " * Acesse a página [Instâncias](/instances) e localize a instância que deseja utilizar. Passe o cursor sobre o CRN e clique para copiá-lo.\n", "\n", " * Salve suas credenciais localmente com este código:\n", "\n", " ```python\n", " from qiskit_ibm_runtime import QiskitRuntimeService\n", "\n", " QiskitRuntimeService.save_account(\n", " # For `token`, use the 44-character API_KEY you created\n", " # and saved from the IBM Quantum Platform Home dashboard\n", " token=\"\",\n", " instance=\"\", # Optional\n", " )\n", " ```\n", "\n", "3. Agora você pode usar este Python código sempre que quiser se autenticar no Qiskit Runtime Serviço:\n", " ```python\n", " from qiskit_ibm_runtime import QiskitRuntimeService\n", "\n", " # Run every time you need the service\n", " service = QiskitRuntimeService()\n", " ```\n", "\n", "\n", " Se você estiver usando um computador público ou outro ambiente não seguro, siga as [instruções de autenticação manual](/docs/guides/cloud-setup-untrusted) para manter suas credenciais de autenticação seguras.\n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "80471a0a", "metadata": {}, "source": [ "\n", "\n", "## Crie e execute um programa quântico simples\n", "\n" ] }, { "cell_type": "markdown", "id": "85fe979e", "metadata": { "raw_mimetype": "text/restructuredtext" }, "source": [ "As quatro etapas para escrever um programa quântico usando padrões Qiskit são:\n", "\n", "1. Mapeie o problema para um formato nativo quântico.\n", "\n", "2. Otimize os circuitos e os operadores.\n", "\n", "3. Execute usando uma função primitiva quântica.\n", "\n", "4. Analise os resultados.\n", "\n", "\n", "\n", "### Etapa 1. Mapeie o problema para um formato nativo quântico\n", "\n", "Em um programa quântico, *os circuitos quânticos* são o formato nativo no qual as instruções quânticas são representadas, e *os operadores* representam os observáveis a serem medidos. Ao criar um circuito, você geralmente cria um novo [`QuantumCircuit`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#quantumcircuit-class) objeto e, em seguida, adiciona instruções a ele em sequência.\n", "\n" ] }, { "cell_type": "markdown", "id": "21f7a26c", "metadata": {}, "source": [ "A seguinte célula de código cria um circuito que produz um *estado Bell,* que é um estado em que dois qubits estão totalmente entrelaçados entre si.\n", "\n", "\n", " O Qiskit SDK usa a numeração de bits LSb 0, em que o $n^{th}$ dígito tem valor $1 \\ll n$ ou $2^n$. Para obter mais detalhes, consulte a [ordem dos bits no Qiskit SDK](/docs/guides/bit-ordering) tópico.\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 2, "id": "930ca3b6", "metadata": { "tags": [] }, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit import QuantumCircuit\n", "from qiskit.quantum_info import SparsePauliOp\n", "from qiskit.transpiler import generate_preset_pass_manager\n", "from qiskit_ibm_runtime import QiskitRuntimeService\n", "from qiskit_ibm_runtime import EstimatorOptions\n", "from qiskit_ibm_runtime import EstimatorV2 as Estimator\n", "from matplotlib import pyplot as plt\n", "# Uncomment the next line if you want to use a simulator:\n", "# from qiskit_ibm_runtime.fake_provider import FakeBelemV2\n", "\n", "\n", "# Create a new circuit with two qubits\n", "qc = QuantumCircuit(2)\n", "\n", "# Add a Hadamard gate to qubit 0\n", "qc.h(0)\n", "\n", "# Perform a controlled-X gate on qubit 1, controlled by qubit 0\n", "qc.cx(0, 1)\n", "\n", "# Return a drawing of the circuit using MatPlotLib (\"mpl\").\n", "# These guides are written by using Jupyter notebooks, which\n", "# display the output of the last line of each cell.\n", "# If you're running this in a script, use `print(qc.draw())` to\n", "# print a text drawing.\n", "qc.draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "0c957de9", "metadata": { "raw_mimetype": "text/restructuredtext" }, "source": [ "Consulte [`QuantumCircuit`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#quantumcircuit-class) a documentação para ver todas as operações disponíveis.\n", "\n" ] }, { "cell_type": "markdown", "id": "f3ef4248-7938-44c1-85f1-edc997f0edcd", "metadata": {}, "source": [ "Ao criar circuitos quânticos, é preciso também levar em conta que tipo de dados você deseja obter após a execução. O Qiskit oferece duas maneiras de retornar dados: você pode obter resultados de amostragem para um conjunto de qubits que decidir medir, ou pode obter o valor esperado de uma observável. Prepare sua carga de trabalho para medir seu circuito de uma dessas duas maneiras usando o `Qiskit primitives` (explicado em detalhes na [Etapa 3](#step-3-execute-using-the-quantum-primitives) ).\n", "\n", "Este exemplo mede valores esperados usando o `qiskit.quantum_info` submódulo, que é especificado usando operadores (objetos matemáticos usados para representar uma ação ou processo que altera um estado quântico). A seguinte célula de código cria seis operadores Pauli de dois qubits: `IZ`, `IX`, `ZI` `XI`, `ZZ`, e `XX`.\n", "\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "c57b261c-b757-4432-beab-61b526c98a41", "metadata": { "tags": [] }, "outputs": [], "source": [ "# Set up six different observables.\n", "\n", "observables_labels = [\"IZ\", \"IX\", \"ZI\", \"XI\", \"ZZ\", \"XX\"]\n", "observables = [SparsePauliOp(label) for label in observables_labels]" ] }, { "cell_type": "markdown", "id": "47150779", "metadata": {}, "source": [ "\n", " Aqui, algo como o `ZZ` operador é uma abreviação do produto tensorial $Z\\otimes Z$, o que significa medir Z no qubit 1 e Z no qubit 0 juntos e obter informações sobre a correlação entre o qubit 1 e o qubit 0. Valores esperados como este também são normalmente escritos como $\\langle Z_1 Z_0 \\rangle$.\n", "\n", " Se o estado estiver entrelaçado, então a medição de $\\langle Z_1 Z_0 \\rangle$ deve ser diferente da medição de $\\langle I_1 \\otimes Z_0 \\rangle \\langle Z_1 \\otimes I_0 \\rangle$. Para o estado entrelaçado específico criado pelo nosso circuito descrito acima, a medição de $\\langle Z_1 Z_0 \\rangle$ deve ser 1 e a medição de $\\langle I_1 \\otimes Z_0 \\rangle \\langle Z_1 \\otimes I_0 \\rangle$ deve ser zero.\n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "83bf9151-3bc9-40d2-8615-31570238b08e", "metadata": {}, "source": [ "\n", "\n", "\n", "\n", "### Etapa 2. Otimize os circuitos e operadores\n", "\n", "Ao executar circuitos em um dispositivo, é importante otimizar o conjunto de instruções que o circuito contém e minimizar a profundidade geral (aproximadamente o número de instruções) do circuito. Isso garante que você obtenha os melhores resultados possíveis, reduzindo os efeitos de erros e ruídos. Além disso, as instruções do circuito devem estar em conformidade com a [Arquitetura de Conjunto de Instruções (ISA)](/docs/guides/transpile#instruction-set-architecture) do dispositivo backend e devem considerar as portas básicas do dispositivo e a conectividade qubit.\n", "\n", "O código a seguir instancia um dispositivo real para enviar um trabalho e transforma o circuito e os observáveis para corresponder à ISA desse backend. É necessário que você já tenha [salvo suas credenciais.](/docs/guides/cloud-setup)\n", "\n" ] }, { "cell_type": "code", "execution_count": 4, "id": "9a901271", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "service = QiskitRuntimeService()\n", "\n", "backend = service.least_busy(simulator=False, operational=True)\n", "\n", "# Convert to an ISA circuit and layout-mapped observables.\n", "pm = generate_preset_pass_manager(backend=backend, optimization_level=1)\n", "isa_circuit = pm.run(qc)\n", "\n", "isa_circuit.draw(\"mpl\", idle_wires=False)" ] }, { "cell_type": "markdown", "id": "9acac1d4", "metadata": {}, "source": [ "\n", "\n", "### Etapa 3. Executar usando os primitivos quânticos\n", "\n", "Os computadores quânticos podem produzir resultados aleatórios; por isso, geralmente se coleta uma amostra dos resultados executando o circuito várias vezes. Você pode estimar o valor da observável usando a `Estimator` classe. `Estimator` é uma das duas [primitivas](/docs/guides/get-started-with-estimator); a outra é `Sampler`, que pode ser usada para obter dados de um computador quântico. Esses objetos possuem um `run()` método que executa a seleção de circuitos, observáveis e parâmetros (se aplicável), utilizando um [bloco unificado primitivo ( PUB )](/docs/guides/get-started-with-sampler).\n", "\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "62c4ca44", "metadata": { "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ ">>> Job ID: d9bjj3u6hjac73ffpth0\n" ] } ], "source": [ "# Construct the Estimator instance.\n", "\n", "estimator = Estimator(mode=backend)\n", "estimator.options.resilience_level = 1\n", "estimator.options.default_shots = 5000\n", "\n", "mapped_observables = [\n", " observable.apply_layout(isa_circuit.layout) for observable in observables\n", "]\n", "\n", "# One pub, with one circuit to run against five different observables.\n", "job = estimator.run([(isa_circuit, mapped_observables)])\n", "\n", "# Use the job ID to retrieve your job data later\n", "print(f\">>> Job ID: {job.job_id()}\")" ] }, { "cell_type": "markdown", "id": "47479e76", "metadata": {}, "source": [ "Depois que um trabalho é enviado, você pode esperar até que ele seja concluído na sua instância atual do Python ou usar o `job_id` para recuperar os dados posteriormente. (Consulte a [seção sobre recuperação de tarefas](/docs/guides/monitor-job#retrieve-job-results-at-a-later-time) para obter detalhes.)\n", "\n", "Após a conclusão da tarefa, examine sua saída por meio do atributo `result()` da tarefa.\n", "\n" ] }, { "cell_type": "code", "execution_count": 6, "id": "792d2f01", "metadata": {}, "outputs": [], "source": [ "# This is the result of the entire submission. You submitted one Pub,\n", "# so this contains one inner result (and some metadata of its own).\n", "job_result = job.result()\n", "\n", "# This is the result from our single pub, which had six observables,\n", "# so contains information on all six.\n", "pub_result = job.result()[0]" ] }, { "cell_type": "markdown", "id": "48317a25", "metadata": {}, "source": [ "\n", " Quando você executa seu programa quântico em um dispositivo real, sua carga de trabalho deve aguardar em uma fila antes de ser executada. Para economizar tempo, você pode usar o código a seguir para executar essa pequena carga de trabalho no [`fake_provider`](../api/qiskit-ibm-runtime/fake-provider) com o modo de Qiskit Runtime teste local. Observe que isso só é possível para um circuito pequeno. Ao ampliar na próxima seção, você precisará usar um dispositivo real.\n", "\n", " ```python\n", "\n", " # Use the following code instead if you want to run on a simulator:\n", "\n", " from qiskit_ibm_runtime.fake_provider import FakeBelemV2\n", " backend = FakeBelemV2()\n", " estimator = Estimator(backend)\n", "\n", " # Convert to an ISA circuit and layout-mapped observables.\n", "\n", " pm = generate_preset_pass_manager(backend=backend, optimization_level=1)\n", " isa_circuit = pm.run(qc)\n", " mapped_observables = [\n", " observable.apply_layout(isa_circuit.layout) for observable in observables\n", " ]\n", "\n", " job = estimator.run([(isa_circuit, mapped_observables)])\n", " result = job.result()\n", "\n", " # This is the result of the entire submission. You submitted one Pub,\n", " # so this contains one inner result (and some metadata of its own).\n", "\n", " job_result = job.result()\n", "\n", " # This is the result from our single pub, which had five observables,\n", " # so contains information on all five.\n", "\n", " pub_result = job.result()[0]\n", " ```\n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "d200d1f8", "metadata": {}, "source": [ "\n", "\n", "### Etapa 4. Analise os resultados\n", "\n", "A etapa de análise é normalmente onde você pode pós-processar seus resultados usando, por exemplo, mitigação de erros de medição ou extrapolação de ruído zero (ZNE). Você pode inserir esses resultados em outro fluxo de trabalho para análise posterior ou preparar um gráfico dos valores e dados principais. Em geral, esta etapa é específica para o seu problema. Para este exemplo, trace cada um dos valores esperados que foram medidos para o nosso circuito.\n", "\n", "Os valores esperados e os desvios-padrão das variáveis observáveis que você especificou ao Estimator podem ser consultados nos atributos e `PubResult.data.stds` do `PubResult.data.evs` resultado da tarefa. Para obter os resultados do Sampler, use a `PubResult.data.meas.get_counts()` função, que retornará um `dict` conjunto de medições na forma de cadeias de bits como chaves e contagens como seus valores correspondentes. Para obter mais informações, consulte o guia [de introdução rápida do Sampler](/docs/guides/get-started-with-sampler).\n", "\n" ] }, { "cell_type": "code", "execution_count": 8, "id": "87143fcc", "metadata": { "tags": [] }, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Plot the result\n", "\n", "values = pub_result.data.evs\n", "\n", "errors = pub_result.data.stds\n", "\n", "# plotting graph\n", "plt.plot(observables_labels, values, \"-o\")\n", "plt.xlabel(\"Observables\")\n", "plt.ylabel(\"Values\")\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "e6a9ba84", "metadata": {}, "source": [ "Observe que, para os qubits 0 e 1, os valores esperados independentes de X e Z são 0, enquanto as correlações (`XX` e `ZZ`) são 1. Esta é uma característica marcante do entrelaçamento quântico.\n", "\n" ] }, { "cell_type": "markdown", "id": "0bc582d8", "metadata": {}, "source": [ "\n", "\n", "## Escala para um grande número de qubits\n", "\n", "Na computação quântica, o trabalho em escala utilitária é crucial para o progresso nessa área. Esse trabalho requer cálculos em uma escala muito maior, trabalhando com circuitos que podem usar mais de 100 qubits e mais de 1000 portas. Este exemplo demonstra como você pode realizar trabalhos em escala utilitária em IBM® QPUs criando e analisando um estado GHZ de 100 qubits. Ele usa o fluxo de trabalho de padrões Qiskit e termina medindo o valor esperado $\\langle Z_0 Z_i \\rangle $ para cada qubit.\n", "\n", "\n", "\n", "### Etapa 1. Mapeie o problema\n", "\n", "Escreva uma função que retorne um `QuantumCircuit` que prepare um $n$ estado GHZ de -qubit (essencialmente um estado Bell estendido) e, em seguida, use essa função para preparar um estado GHZ de 100 qubits e coletar os observáveis a serem medidos.\n", "\n" ] }, { "cell_type": "code", "execution_count": 10, "id": "2ac02692", "metadata": {}, "outputs": [], "source": [ "def get_qc_for_n_qubit_GHZ_state(n: int) -> QuantumCircuit:\n", " \"\"\"This function will create a qiskit.QuantumCircuit (qc)\n", " for an n-qubit GHZ state.\n", "\n", " Args:\n", " n (int): Number of qubits in the n-qubit GHZ state\n", "\n", " Returns:\n", " QuantumCircuit: Quantum circuit that generate the n-qubit GHZ state,\n", " assuming all qubits start in the 0 state\n", " \"\"\"\n", " if isinstance(n, int) and n >= 2:\n", " qc = QuantumCircuit(n)\n", " qc.h(0)\n", " for i in range(n - 1):\n", " qc.cx(i, i + 1)\n", " else:\n", " raise Exception(\"n is not a valid input\")\n", " return qc\n", "\n", "\n", "# Create a new circuit with 100 qubits in the GHZ state\n", "n = 100\n", "qc = get_qc_for_n_qubit_GHZ_state(n)" ] }, { "cell_type": "markdown", "id": "5b3d0d74", "metadata": {}, "source": [ "Em seguida, mapeie para os operadores de interesse. Este exemplo usa os `ZZ` operadores entre qubits para examinar o comportamento à medida que eles se distanciam. Valores de expectativa cada vez mais imprecisos (corrompidos) entre qubits distantes revelariam o nível de ruído presente.\n", "\n" ] }, { "cell_type": "code", "execution_count": 11, "id": "863a4ec9", "metadata": {}, "outputs": [], "source": [ "# ZZII...II, ZIZI...II, ... , ZIII...IZ\n", "operator_strings = [\n", " \"Z\" + \"I\" * i + \"Z\" + \"I\" * (n - 2 - i) for i in range(n - 1)\n", "]\n", "\n", "operators = [SparsePauliOp(operator) for operator in operator_strings]" ] }, { "cell_type": "markdown", "id": "a0b462ce", "metadata": {}, "source": [ "\n", "\n", "### Etapa 2. Otimize o problema para execução em hardware quântico\n", "\n", "O código a seguir transforma o circuito e os observáveis para corresponder à ISA do backend. É necessário que você já tenha [salvo suas credenciais.](/docs/guides/cloud-setup)\n", "\n" ] }, { "cell_type": "code", "execution_count": 12, "id": "428f05e7", "metadata": {}, "outputs": [], "source": [ "service = QiskitRuntimeService()\n", "\n", "backend = service.least_busy(\n", " simulator=False, operational=True, min_num_qubits=100\n", ")\n", "pm = generate_preset_pass_manager(optimization_level=1, backend=backend)\n", "\n", "isa_circuit = pm.run(qc)\n", "isa_operators_list = [op.apply_layout(isa_circuit.layout) for op in operators]" ] }, { "cell_type": "markdown", "id": "2d2b5065", "metadata": {}, "source": [ "\n", "\n", "### Etapa 3. Executar no hardware\n", "\n", "Envie o trabalho e ative a supressão de erros utilizando uma técnica chamada [\"desacoplamento dinâmico\"](/docs/api/qiskit-ibm-runtime/options-dynamical-decoupling-options) para reduzir os erros. O nível de resiliência especifica o grau de resiliência a ser implementado contra erros. Níveis mais altos geram resultados mais precisos, mas aumentam o tempo de processamento. Para obter mais informações sobre as opções definidas no código a seguir, consulte [Configurar a mitigação de erros para o Qiskit Runtime](/docs/guides/error-mitigation-and-suppression-techniques).\n", "\n" ] }, { "cell_type": "code", "execution_count": 13, "id": "3aaa5025", "metadata": {}, "outputs": [], "source": [ "options = EstimatorOptions()\n", "options.resilience_level = 1\n", "options.dynamical_decoupling.enable = True\n", "options.dynamical_decoupling.sequence_type = \"XY4\"\n", "\n", "# Create an Estimator object\n", "estimator = Estimator(backend, options=options)" ] }, { "cell_type": "code", "execution_count": 14, "id": "b4c3d3e7-0a0f-4023-8948-1082e225f46c", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "d9bk5brv6alc73ct68ag\n" ] } ], "source": [ "# Submit the circuit to Estimator\n", "job = estimator.run([(isa_circuit, isa_operators_list)])\n", "job_id = job.job_id()\n", "print(job_id)" ] }, { "cell_type": "markdown", "id": "0bc64091", "metadata": {}, "source": [ "\n", "\n", "### Etapa 4. Resultados pós-processamento\n", "\n", "Após a conclusão do trabalho, trace os resultados e observe que $\\langle Z_0 Z_i \\rangle$ diminui com o aumento $i$ de, mesmo que em uma simulação ideal todos $\\langle Z_0 Z_i \\rangle$ devessem ser 1.\n", "\n" ] }, { "cell_type": "code", "execution_count": 15, "id": "de91ebd0", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# data\n", "data = list(range(1, len(operators) + 1)) # Distance between the Z operators\n", "result = job.result()[0]\n", "values = result.data.evs # Expectation value at each Z operator.\n", "values = [\n", " v / values[0] for v in values\n", "] # Normalize the expectation values to evaluate how they decay with distance.\n", "\n", "# plotting graph\n", "plt.plot(data, values, marker=\"o\", label=\"100-qubit GHZ state\")\n", "plt.xlabel(\"Distance between qubits $i$\")\n", "plt.ylabel(r\"$\\langle Z_i Z_0 \\rangle / \\langle Z_1 Z_0 \\rangle $\")\n", "plt.legend()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "0afc307c", "metadata": {}, "source": [ "O gráfico anterior mostra que, à medida que a distância entre os qubits aumenta, o sinal enfraquece devido à presença de ruído.\n", "\n" ] }, { "cell_type": "markdown", "id": "e7c24c81", "metadata": {}, "source": [ "\n", "\n", "## Próximas etapas\n", "\n", "\n", " * Experimente um destes tutoriais:\n", " * [Estimativa da energia do estado fundamental da cadeia de Heisenberg com VQE](/docs/tutorials/spin-chain-vqe)\n", " * Resolva problemas de otimização usando [QAOA](/docs/tutorials/quantum-approximate-optimization-algorithm)\n", " * Treine modelos [de kernel quântico](/docs/tutorials/quantum-kernel-training) para tarefas de aprendizado de máquina\n", " * Encontre instruções detalhadas de instalação no guia [Instalar](/docs/guides/install-qiskit) o Qiskit.\n", " * Se você preferir não instalar o Qiskit localmente, leia sobre as opções para usar o Qiskit em um [ambiente de desenvolvimento online](/docs/guides/online-lab-environments).\n", " * Para salvar várias credenciais de conta ou especificar outras opções de conta, consulte as instruções detalhadas no guia [Salve suas credenciais de login](/docs/guides/save-credentials#save-your-access-credentials).\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "id": "a1b8767d", "source": "© IBM Corp., 2017-2026" } ], "metadata": { "celltoolbar": "Raw Cell Format", "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" }, "widgets": { "application/vnd.jupyter.widget-state+json": { "state": {}, "version_major": 2, "version_minor": 0 } }, "hours": 0.5 }, "nbformat": 4, "nbformat_minor": 5 }