{ "cells": [ { "cell_type": "markdown", "id": "39a1fd9b-a17f-486e-aa7a-38d46b867984", "metadata": {}, "source": [ "---\n", "title: \"Utilidade I\"\n", "description: \"Nesta lição, executamos um circuito em escala utilitária que aparece no que chamamos informalmente de artigo utilitário, publicado na Nature Vol. 618, em 15 de junho de 2023.\"\n", "---\n", "\n", "\n", "\n", "# Experimento em escala utilitária I\n", "\n", "\n", " Tamiya Onodera (5 de julho de 2024)\n", "\n", " [Baixe o pdf](https://ibm.ent.box.com/public/static/k38xhk5yaqy9b3gjdmu0ynhnd9i4c3e1.zip) da palestra original. Observe que alguns trechos de código podem se tornar obsoletos, pois são imagens estáticas.\n", "\n", " *O tempo aproximado da QPU para executar esse experimento é de 45 segundos.*\n", "\n", "\n" ] }, { "attachments": {}, "cell_type": "markdown", "id": "f0d73c71-11ba-4dcb-b230-ecea500e8732", "metadata": {}, "source": [ "\n", "\n", "## 1. Introdução ao documento de utilidade pública\n", "\n", "Nesta lição, executamos um circuito em escala de utilidade que aparece no que chamamos informalmente de [\"o documento de utilidade\"](https://www.nature.com/articles/s41586-023-06096-3) publicado na Nature Vol. 618, 15 de junho de 2023. O artigo trata da evolução temporal do modelo de Ising de campo transversal 2D. Em particular, eles consideram a dinâmica de tempo do Hamiltoniano,\n", "\n", "$$\n", "H = H_{ZZ} + H_X = - J \\sum_{(i,j)} Z_i Z_j + h \\sum_{i} X_i\n", "$$\n", "\n", "em que $J > 0$ é o acoplamento dos spins do vizinho mais próximo com $i < j$ e $h$ é o campo transversal global.\n", "\n" ] }, { "attachments": {}, "cell_type": "markdown", "id": "c92cf6bb-df3e-4020-b980-edf17188e096", "metadata": { "jp-MarkdownHeadingCollapsed": true }, "source": [ "Eles simulam a dinâmica do spin a partir de um estado inicial por meio da decomposição de Trotter de primeira ordem do operador de evolução temporal,\n", "\n", "$$\n", "\\begin{aligned}\n", " \\exp(-i H_{ZZ} \\delta t) &= \\prod_{(i,j)} \\exp (i J \\delta t Z_i Z_j) = \\prod_{(i,j)} \\mathrm{R}_{Z_i Z_j} ( - 2 J \\delta t) \\\\\n", " \\exp(-i H_X \\delta t) &= \\prod_{i} \\exp (-i h \\delta t X_i ) = \\prod_{i} \\mathrm{R}_{X_i} ( 2 h \\delta t)\n", "\\end{aligned}\n", "$$\n", "\n", "em que o tempo de evolução $T$ é discretizado em $T / \\delta t$ etapas de Trotter e $\\mathrm{R}_{Z_i Z_j}(\\theta_J)$ e $\\mathrm{R}_{X_i}(\\theta_h)$ são as portas de rotação $ZZ$ e $X$, respectivamente.\n", "\n", "Eles realizaram experimentos em um processador IBM Quantum® Eagle, que é um dispositivo de 127 qubits com conectividade heavy-hex, aplicando interações $X$ a todos os qubits e interações $ZZ$ a todas as bordas do mapa de acoplamento. Observe que todas as interações do $ZZ$ não podem ser aplicadas simultaneamente devido à \"dependência de dados\". Por isso, eles **colorem o mapa de acoplamento** para agrupá-los em camadas. Os que estão em uma camada recebem a mesma cor e podem ser aplicados em paralelo.\n", "\n", "Além disso, para fins de simplicidade experimental, eles se concentraram no caso $\\theta_J=-\\pi /2$.\n", "\n", "A nova contribuição do artigo é que eles construíram circuitos quânticos em uma escala além da simulação de vetor de estado, executaram-nos em computadores quânticos com ruído e conseguiram extrair resultados confiáveis. Ou seja, eles demonstraram a utilidade dos computadores quânticos barulhentos. Ao fazer isso, eles aplicaram a extrapolação de ruído zero (ZNE) com amplificação de erro probabilístico (PEA) para atenuar os erros de dispositivos ruidosos.\n", "\n", "A partir de então, passamos a chamar esses experimentos e circuitos de \"escala de utilidade\".\n", "\n" ] }, { "cell_type": "markdown", "id": "fcb359b4-469a-4e37-b260-8bf5044d1f60", "metadata": {}, "source": [ "\n", "\n", "### 1.1 Seu objetivo\n", "\n", "Seu objetivo nesta lição é construir um circuito de escala de utilidade e executá-lo em um processador Eagle. Está além do escopo deste notebook extrair resultados confiáveis, em parte porque a AEP é um recurso experimental do Qiskit no momento em que escrevemos e em parte porque a aplicação do ZNE com AEP levará um bom tempo.\n", "\n", "Em termos concretos, pedimos que você construa e execute o circuito correspondente à Figura 4b do documento e trace os pontos \"não mitigados\" por conta própria. Como você pode ver, é um circuito de 127 qubits $\\times$ de 60 camadas (20 etapas de Trotter) com o $\\langle Z_{62} \\rangle$ como um observável.\n", "\n" ] }, { "attachments": {}, "cell_type": "markdown", "id": "a4aecf28-fc89-42db-ad8f-67e8afacff87", "metadata": {}, "source": [ "![image.png](https://eu-de.quantum.cloud.ibm.com/learning/images/courses/utility-scale-quantum-computing/utility-i/utility1.avif)\n", "\n" ] }, { "cell_type": "markdown", "id": "b8c5a5ae-fc75-4fa9-9c70-2de36652f49a", "metadata": {}, "source": [ "Parece muito importante? Não se preocupe. As três últimas lições deste curso fornecem os passos a serem seguidos. Para começar, demonstraremos um experimento de menor escala que consiste em construir e executar em um dispositivo falso um circuito de 27 qubits $\\times$ de 6 camadas (2 etapas de Trotter) com o $\\langle Z_{13} \\rangle$ como observável.\n", "\n", "Isso é tudo para a introdução. Vamos embarcar em uma aventura em escala de serviços públicos!\n", "\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "ad57179f-240e-441d-b2e4-e531cd192b45", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'2.0.2'" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import qiskit\n", "\n", "qiskit.__version__" ] }, { "cell_type": "code", "execution_count": 2, "id": "35fff60f-7c73-4492-ace9-ecdc8fd33b0c", "metadata": {}, "outputs": [], "source": [ "#!pip install qiskit_ibm_runtime\n", "#!pip install qiskit_aer" ] }, { "cell_type": "code", "execution_count": 3, "id": "2f7464cc-4190-400f-b947-4f38100b43d2", "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import rustworkx as rx\n", "\n", "from qiskit import QuantumCircuit, transpile\n", "from qiskit.circuit import Parameter\n", "from qiskit.circuit.library import YGate\n", "from qiskit.quantum_info import SparsePauliOp\n", "from qiskit_ibm_runtime import (\n", " QiskitRuntimeService,\n", " fake_provider,\n", " EstimatorV2 as Estimator,\n", ")\n", "from qiskit_aer import AerSimulator" ] }, { "cell_type": "code", "execution_count": null, "id": "acd628f1-e010-44b7-ba77-cceb3b4198c6", "metadata": {}, "outputs": [], "source": [ "service = QiskitRuntimeService()" ] }, { "cell_type": "markdown", "id": "06556d62-08bc-4c43-a7d0-382b73ec239a", "metadata": {}, "source": [ "\n", "\n", "## 2. Preparação\n", "\n", "\n", "\n", "### 2.1 Construa RZZ(- $\\pi$ /2)\n", "\n", "Primeiro, observe que a porta RZZ em geral requer duas portas $CX$.\n", "\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "d0b96520-3a4b-43c4-ade8-85cec68e3e09", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit.circuit.library import RZZGate\n", "\n", "θ_h = Parameter(\"$\\\\theta_h$\")\n", "qc1 = QuantumCircuit(2)\n", "qc1.append(RZZGate(θ_h), [0, 1])\n", "qc1.decompose(reps=1).draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "2770e3d2-d9d1-4bd5-8f00-8d8401f10438", "metadata": {}, "source": [ "Conforme mencionado acima, para este experimento, nos concentramos na porta RZZ com um ângulo específico, - $\\pi$ / 2. Conforme mostrado no artigo, ele pode ser realizado com apenas uma porta $CX$.\n", "\n" ] }, { "cell_type": "code", "execution_count": 6, "id": "14b0ecb2-a8da-484a-bf49-606450bb074a", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "qc2 = QuantumCircuit(2)\n", "\n", "qc2.sdg([0, 1])\n", "qc2.append(YGate().power(1 / 2), [1])\n", "qc2.cx(0, 1)\n", "qc2.append(YGate().power(1 / 2).adjoint(), [1])\n", "\n", "qc2.draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "269a5094-b4e6-4249-b9d5-ea25ded1767e", "metadata": {}, "source": [ "Para referência futura, definimos uma porta em termos desse circuito.\n", "\n" ] }, { "cell_type": "code", "execution_count": 7, "id": "2b5fbb1a", "metadata": {}, "outputs": [], "source": [ "rzz = qc2.to_gate(label=\"RZZ\")" ] }, { "cell_type": "markdown", "id": "d89cccac-13a8-49b5-9dab-c1e98f9735c8", "metadata": {}, "source": [ "Vamos fazer um uso aleatório do recém-definido `rzz`.\n", "\n" ] }, { "cell_type": "code", "execution_count": 8, "id": "6753b9a4-90b1-4981-82b2-8177ac258af2", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "qc3 = QuantumCircuit(3)\n", "qc3.append(rzz, [0, 1])\n", "qc3.append(rzz, [0, 2])\n", "display(qc3.draw(\"mpl\"))\n", "# display(qc.decompose(reps=1).draw(\"mpl\"))" ] }, { "cell_type": "markdown", "id": "ed9c4589-c996-4199-8dd7-19e8d144a384", "metadata": {}, "source": [ "Antes de continuar usando isso, vamos verificar a equivalência lógica de `qc1` (a porta RZZ) para -pi/2 e nossa porta recém-definida `rzz` ou `qc2` :\n", "\n" ] }, { "cell_type": "code", "execution_count": 9, "id": "b84c6f00-d50a-4874-9fa4-0c81742654e8", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit.quantum_info import Operator\n", "\n", "op1 = Operator(qc1.assign_parameters([-np.pi / 2]))\n", "op2 = Operator(qc2)\n", "\n", "op1.equiv(op2)" ] }, { "cell_type": "markdown", "id": "ace1a98d-2ef7-4fe8-b67d-7799e7566f5a", "metadata": {}, "source": [ "\n", "\n", "### 2.2 Colorir o mapa de acoplamento\n", "\n", "Vamos estudar como colorir o mapa de acoplamento de um backend. Isso é necessário para agrupar as interações do $ZZ$ em camadas.\n", "\n", "Para começar, vamos visualizar o mapa de acoplamento de um backend. Observe que os mapas de acoplamento são hexagonais pesados para todos os dispositivos IBM Quantum atuais.\n", "\n" ] }, { "cell_type": "code", "execution_count": 10, "id": "84e11b8e-bc74-4f3a-8538-d4d34d069e0f", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "backend = service.least_busy(operational=True, simulator=False)\n", "\n", "backend.coupling_map.draw()" ] }, { "cell_type": "markdown", "id": "a5fbfce4-c8cc-49fe-831d-31ad59f84c08", "metadata": {}, "source": [ "Para colorir um mapa de acoplamento, usamos o [rustworkx](https://www.rustworkx.org/), que é um pacote do Python para trabalhar com gráficos e redes complexas. Ele fornece vários algoritmos de coloração, que são todos heurísticos e, portanto, não têm a garantia de encontrar uma coloração mínima.\n", "\n", "Dito isso, como os grafos heavy-hex são bipartidos, pegamos [o graph\\_bipartite\\_edge\\_color](https://www.rustworkx.org/apiref/rustworkx.graph_bipartite_edge_color.html), que deve encontrar uma coloração mínima para esses grafos.\n", "\n" ] }, { "cell_type": "code", "execution_count": 11, "id": "79d3af17-efa0-4e48-89c5-ad9a962cf83b", "metadata": { "scrolled": true }, "outputs": [], "source": [ "def color_coupling_map(backend):\n", " graph = backend.coupling_map.graph\n", " undirected_graph = graph.to_undirected(multigraph=False)\n", " edge_color_map = rx.graph_bipartite_edge_color(undirected_graph)\n", " if edge_color_map is None:\n", " edge_color_map = rx.graph_greedy_edge_color(undirected_graph)\n", " # build a map from color to a list of edges\n", " edge_index_map = undirected_graph.edge_index_map()\n", " color_edges_map = {color: [] for color in edge_color_map.values()}\n", " for edge_index, color in edge_color_map.items():\n", " color_edges_map[color].append(\n", " (edge_index_map[edge_index][0], edge_index_map[edge_index][1])\n", " )\n", " return edge_color_map, color_edges_map" ] }, { "cell_type": "markdown", "id": "1a409faf-cb52-4c1c-95bd-beeca2cfd379", "metadata": {}, "source": [ "Os gráficos hexagonais pesados devem ser pintados em três cores. Vamos verificar isso para o mapa de acoplamento acima.\n", "\n" ] }, { "cell_type": "code", "execution_count": 12, "id": "5cf7f215-2155-498e-a8e8-acc51ccba363", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ibm_strasbourg, 127-qubit device, 3 colors assigned.\n" ] } ], "source": [ "edge_color_map, color_edges_map = color_coupling_map(backend)\n", "print(\n", " f\"{backend.name}, {backend.num_qubits}-qubit device, {len(color_edges_map.keys())} colors assigned.\"\n", ")" ] }, { "cell_type": "markdown", "id": "574bb71f-436e-499c-bb23-1adbab9445db", "metadata": {}, "source": [ "Sim, é verdade!\n", "\n", "Por diversão, vamos pintar o mapa de acoplamento com a coloração obtida, usando o recurso de visualização do rustworks.\n", "\n" ] }, { "cell_type": "code", "execution_count": 13, "id": "fb9b6915-5ace-4104-b81d-91666e689f0d", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "color_str_map = {0: \"green\", 1: \"red\", 2: \"blue\"}\n", "\n", "undirected_graph = backend.coupling_map.graph.to_undirected(multigraph=False)\n", "for i in undirected_graph.edge_indices():\n", " undirected_graph.get_edge_data_by_index(i)[\"color\"] = color_str_map[\n", " edge_color_map[i]\n", " ]\n", "\n", "rx.visualization.graphviz_draw(\n", " undirected_graph, method=\"neato\", edge_attr_fn=lambda edge: {\"color\": edge[\"color\"]}\n", ")" ] }, { "cell_type": "markdown", "id": "4ae34f8d-6a46-4d81-bd0d-66a0d6fca588", "metadata": {}, "source": [ "\n", "\n", "## 3. Resolva a evolução temporal trotterizada de um modelo Ising e 2D.\n", "\n", "Vamos definir uma rotina para construir um circuito do papel de utilidade para a evolução temporal de um modelo 2D Ising. A rotina recebe três parâmetros: um backend, um número inteiro que indica o número de etapas do Trotter e um booleano que controla a inserção da barreira.\n", "\n" ] }, { "cell_type": "code", "execution_count": 14, "id": "b9d5dfd9-997f-4d8c-af1f-7927df31bffb", "metadata": {}, "outputs": [], "source": [ "def get_utility_circuit(backend, num_steps: int, barrier: bool = False):\n", " num_qubits = backend.num_qubits\n", " _, color_edges_map = color_coupling_map(backend)\n", " θ_h = Parameter(\"$\\\\theta_h$\")\n", " qc = QuantumCircuit(num_qubits)\n", "\n", " for i in range(num_steps):\n", " qc.rx(θ_h, range(num_qubits))\n", "\n", " for _, edge_list in color_edges_map.items():\n", " for edge in edge_list:\n", " qc.append(rzz, edge)\n", "\n", " if barrier:\n", " qc.barrier()\n", " return qc" ] }, { "cell_type": "markdown", "id": "e6689c89-8321-44e8-8983-82d6b0735751", "metadata": {}, "source": [ "Observe que já realizamos manualmente o mapeamento e o roteamento de qubits para o circuito construído. Assim, quando transpilarmos o circuito posteriormente, não pediremos (**não devemos** ) que o transpilador faça o mapeamento e o roteamento dos qubits. Como você verá em breve, nós o invocamos com o nível de otimização como 1 e o método de layout como \"trivial\".\n", "\n", "Em seguida, definimos uma rotina simples para obter as informações sobre o circuito construído para uma verificação rápida.\n", "\n" ] }, { "cell_type": "code", "execution_count": 15, "id": "5c002120", "metadata": {}, "outputs": [], "source": [ "def get_circuit_info(qc: QuantumCircuit, reps: int = 0):\n", " qc0 = qc.decompose(reps=reps)\n", " return (\n", " f\"{qc0.num_qubits} qubits × {qc0.depth(lambda x: x.operation.num_qubits == 2)} layers ({qc0.depth()}-depth)\"\n", " + \", \"\n", " + f\"\"\"Gate breakdown: {\", \".join([f\"{k.upper()} {v}\" for k, v in qc0.count_ops().items()])}\"\"\"\n", " )" ] }, { "cell_type": "markdown", "id": "30b69c52-09f0-4d5a-855c-e8f90acd0984", "metadata": {}, "source": [ "Vamos exercitar essas rotinas. Você deverá ver um circuito de 27 qubits $\\times$ 15 camadas (5 etapas de Trotter). Como o dispositivo falso tem 28 bordas, deve haver 28\\*5 medidores de emaranhamento.\n", "\n" ] }, { "cell_type": "code", "execution_count": 16, "id": "af7bdb29-3bdb-4f6e-a53c-76ce935dff03", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "27 qubits × 15 layers (20-depth), Gate breakdown: CIRCUIT-165 140, RX 135, BARRIER 5\n", "27 qubits × 15 layers (60-depth), Gate breakdown: SDG 280, UNITARY 280, CX 140, R 135, BARRIER 5\n" ] } ], "source": [ "backend = fake_provider.FakeTorontoV2()\n", "num_steps = 5\n", "qc = get_utility_circuit(backend, num_steps, True)\n", "\n", "display(qc.draw(output=\"mpl\", fold=-1))\n", "print(get_circuit_info(qc, reps=0))\n", "print(get_circuit_info(qc, reps=1))" ] }, { "cell_type": "markdown", "id": "bf038a4d-4482-4368-8171-8cb4cd828c51", "metadata": {}, "source": [ "\n", "\n", "## 4. Resolva a versão de 27 qubits do problema.\n", "\n", "Agora demonstramos uma versão em menor escala do experimento de utilidade. Criamos um circuito de 27 qubit $\\times$ de 6 camadas (2 etapas de Trotter) com $\\langle Z_{13} \\rangle$ como observável e o executamos em AerSimulator e em um dispositivo falso.\n", "\n", "Obviamente, seguimos nosso fluxo de trabalho de quatro etapas, o \"padrão Qiskit\", que consiste em Mapear, Otimizar, Executar e Pós-processar. De forma mais concreta,\n", "\n", "* Mapear entradas clássicas para uma computação quântica.\n", "* Otimizar circuitos para computação quântica.\n", "* Executar circuitos usando primitivos.\n", "* Pós-processamento e retorno dos resultados em formato clássico.\n", "\n", "A seguir, temos a etapa do mapa para criar um circuito para um experimento de menor escala. Temos então um conjunto de Optimize and Execute para AerSimulator e outro para um dispositivo falso. Por fim, temos a etapa Post-Process para plotar os resultados.\n", "\n" ] }, { "cell_type": "markdown", "id": "ad5f3abd-0f25-47ec-9541-16fe83b7e710", "metadata": {}, "source": [ "\n", "\n", "### 4.1 Passo 1: Mapa\n", "\n" ] }, { "cell_type": "code", "execution_count": 17, "id": "cd9c6774", "metadata": {}, "outputs": [], "source": [ "backend = fake_provider.FakeTorontoV2() # a 27 qubit fake device.\n", "num_steps = 2\n", "qc = get_utility_circuit(backend, num_steps)\n", "obs = SparsePauliOp.from_sparse_list(\n", " [(\"Z\", [13], 1)], num_qubits=backend.num_qubits\n", ") # Falcon\n", "angles = [\n", " 0,\n", " 0.1,\n", " 0.2,\n", " 0.3,\n", " 0.4,\n", " 0.5,\n", " 0.6,\n", " 0.7,\n", " 0.8,\n", " 1.0,\n", " np.pi / 2,\n", "] # We try 11 angles for theta_h." ] }, { "cell_type": "markdown", "id": "81b39024-a7f4-4a7a-a543-59185def648b", "metadata": {}, "source": [ "\n", "\n", "### 4.2 Etapas 2 e 3: Otimizar e Executar (Simulador)\n", "\n" ] }, { "cell_type": "code", "execution_count": 18, "id": "fa307165-fc74-4b6c-88c5-a2ac36341a3c", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "27 qubits × 6 layers (23-depth), Gate breakdown: SDG 112, UNITARY 112, CX 56, R 54\n", "27 qubits × 6 layers (16-depth), Gate breakdown: U3 80, CX 56, R 54, U1 32, U 28\n" ] } ], "source": [ "backend_sim = AerSimulator()\n", "transpiled_qc_sim = transpile(\n", " qc, backend_sim, optimization_level=1, layout_method=\"trivial\"\n", ")\n", "transpiled_obs_sim = obs.apply_layout(layout=transpiled_qc_sim.layout)\n", "\n", "print(get_circuit_info(qc, reps=1))\n", "print(get_circuit_info(transpiled_qc_sim, reps=1))" ] }, { "cell_type": "markdown", "id": "0a101b40-5555-41d9-96b2-a8c986ea9903", "metadata": {}, "source": [ "Um usuário executou a próxima célula usando um MacBook Pro com 2.3 GHz quad-core Intel Core i7 Processor equipado com 32GB 3LPDDR4X RAM, que está executando macOS 14.5. O site 161ms foi levado em tempo de parede. Cada laptop será um pouco diferente.\n", "\n" ] }, { "cell_type": "code", "execution_count": 19, "id": "178dd8c4-439b-4324-ba1f-687acc57a678", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "CPU times: user 231 ms, sys: 186 ms, total: 417 ms\n", "Wall time: 111 ms\n" ] } ], "source": [ "%%time\n", "params = [[p] for p in angles]\n", "estimator = Estimator(mode=backend_sim)\n", "pub = (transpiled_qc_sim, transpiled_obs_sim, params)\n", "result_sim = estimator.run([pub]).result()" ] }, { "cell_type": "markdown", "id": "48b684f9-061a-49fd-acb1-3ed7b4bab1f2", "metadata": {}, "source": [ "\n", "\n", "### 4.3 Etapas 2 e 3: Otimizar e executar (dispositivo falso)\n", "\n" ] }, { "cell_type": "code", "execution_count": 20, "id": "f944eeae-8dc5-4ad6-97ad-92f95159956b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "27 qubits × 6 layers (23-depth), Gate breakdown: SDG 112, UNITARY 112, CX 56, R 54\n", "27 qubits × 6 layers (49-depth), Gate breakdown: SDG 324, U1 274, H 162, CX 56, U3 14\n" ] } ], "source": [ "backend_fake = fake_provider.FakeTorontoV2()\n", "transpiled_qc_fake = transpile(\n", " qc, backend_fake, optimization_level=1, layout_method=\"trivial\"\n", ")\n", "transpiled_obs_fake = obs.apply_layout(layout=transpiled_qc_fake.layout)\n", "\n", "print(get_circuit_info(qc, reps=1))\n", "print(get_circuit_info(transpiled_qc_fake, reps=1))" ] }, { "cell_type": "markdown", "id": "59adfdfb-0954-42f7-9dd2-c819d04264b6", "metadata": {}, "source": [ "Quando o mesmo usuário executou a próxima célula com o mesmo ambiente acima, foi necessário 2min 19s em Wall Time. A execução de um circuito em um dispositivo falso invoca a simulação com ruído, que leva muito mais tempo do que a simulação exata. Recomendamos que você não execute um circuito maior (como um circuito de 27 qubits $\\times$ 9 camadas com 3 etapas de Trotter) em um dispositivo falso.\n", "\n" ] }, { "cell_type": "code", "execution_count": 21, "id": "62d0e0bb-9acb-474a-8d19-b132013131a0", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "CPU times: user 4min 42s, sys: 9.35 s, total: 4min 51s\n", "Wall time: 38.3 s\n" ] } ], "source": [ "%%time\n", "params = [[p] for p in angles]\n", "estimator = Estimator(mode=backend_fake)\n", "pub = (transpiled_qc_fake, transpiled_obs_fake, params)\n", "result_fake = estimator.run([pub]).result()" ] }, { "cell_type": "markdown", "id": "181e5f61-2830-485c-bd22-a1d70b443ed9", "metadata": {}, "source": [ "\n", "\n", "### 4.4 Etapa 4: Pós-processamento\n", "\n", "Apresentamos os resultados de simulações exatas e com ruído. Você vê os graves efeitos do ruído em FakeToronto.\n", "\n" ] }, { "cell_type": "code", "execution_count": 22, "id": "4cf3cad0-e720-469c-a9ed-e397dae0f2f6", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.plot(angles, result_fake[0].data.evs, \"o\", label=\"Fake Device\")\n", "plt.plot(angles, result_sim[0].data.evs, \"o\", label=\"AerSimulator\")\n", "plt.xlabel(\"$\\\\mathrm{R_x}$ angle $\\\\theta_h$\")\n", "plt.title(\"$\\\\langle Z_{13} \\\\rangle$\")\n", "plt.legend()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "1b05966c-efe2-4eb4-b63c-43c07cf81f41", "metadata": {}, "source": [ "\n", "\n", "## 5. Resolva a versão de 127 qubits do problema\n", "\n", "Seu objetivo é executar o experimento em escala de utilidade, conforme mencionado no início. Você criará e executará um circuito de 127 qubits e 60 camadas (20 etapas de Trotter) com $\\langle Z_{62} \\rangle$ como um observável. Recomendamos que você tente fazer isso por conta própria, usando o código para a versão de 27 qubit quando apropriado. Mas a solução é fornecida aqui.\n", "\n", "**Solução:**\n", "\n" ] }, { "cell_type": "markdown", "id": "a18a42dd-5891-4b5f-8c3b-1bc7e1ae4a5e", "metadata": {}, "source": [ "\n", "\n", "### 5.1 Passo 1: Mapa\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "8b900d9a-0351-426a-b25b-19e631fd257e", "metadata": {}, "outputs": [], "source": [ "# backend_map = service.backend(\"ibm_brisbane\")\n", "backend_map = service.least_busy(operational=True, simulator=False)\n", "\n", "num_steps = 20\n", "qc = get_utility_circuit(backend_map, num_steps)\n", "obs = SparsePauliOp.from_sparse_list(\n", " [(\"Z\", [62], 1)], num_qubits=backend_map.num_qubits\n", ") # Eagle\n", "angles = [0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 1.0, np.pi / 2]" ] }, { "cell_type": "markdown", "id": "51ea0288-d8e9-4ee1-bbe8-dc24826a5026", "metadata": {}, "source": [ "\n", "\n", "### 5.2 Etapas 2 e 3: Otimizar e executar\n", "\n", "Observamos que o mapa de acoplamento do processador Eagle tem 144 bordas.\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "f9fadf76-48e3-43a3-b773-8fa3b5fd5f3d", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "156 qubits × 60 layers (221-depth), Gate breakdown: SDG 7040, UNITARY 7040, CX 3520, R 3120\n", "156 qubits × 60 layers (201-depth), Gate breakdown: RZ 11933, SX 6240, CZ 3520\n" ] } ], "source": [ "# backend = service.backend(\"ibm_brisbane\")\n", "backend = backend_map\n", "\n", "transpiled_qc = transpile(qc, backend, optimization_level=1, layout_method=\"trivial\")\n", "transpiled_obs = obs.apply_layout(layout=transpiled_qc.layout)\n", "\n", "print(get_circuit_info(qc, reps=1))\n", "print(get_circuit_info(transpiled_qc))" ] }, { "cell_type": "code", "execution_count": 27, "id": "2ddff1e1-c868-4300-bdbb-cdd3b6932302", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "job id=d1479n6qf56g0081sxa0\n" ] } ], "source": [ "params = [[p] for p in angles]\n", "estimator = Estimator(mode=backend)\n", "pub = (transpiled_qc, transpiled_obs, params)\n", "job = estimator.run([pub])\n", "\n", "job_id = job.job_id()\n", "print(f\"job id={job_id}\")" ] }, { "cell_type": "markdown", "id": "c497fc9d-aa58-4eb2-851e-369c7209da97", "metadata": {}, "source": [ "\n", "\n", "### 5.3 Pós-processamento\n", "\n", "Fornecemos os valores para os pontos \"atenuados\" na Figura 4b do documento de utilidade. Faça um gráfico com seus resultados.\n", "\n" ] }, { "cell_type": "code", "execution_count": 28, "id": "1c4ede0c-e865-41fe-9b38-8ecf39afa64f", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "result_paper = [\n", " 1.0171,\n", " 1.0044,\n", " 0.9563,\n", " 0.9602,\n", " 0.8394,\n", " 0.8120,\n", " 0.5466,\n", " 0.4556,\n", " 0.1953,\n", " 0.0141,\n", " 0.0117,\n", "]\n", "\n", "# REPLACE WITH YOUR OWN JOB ID\n", "job = service.job(job_id)\n", "\n", "plt.plot(angles, job.result()[0].data.evs, \"o\", label=f\"{job.backend().name}\")\n", "plt.plot(angles, result_paper, \"o\", label=\"Utility Paper\")\n", "plt.xlabel(\"$\\\\mathrm{R_x}$ angle $\\\\theta_h$\")\n", "plt.title(\"$\\\\langle Z_{62} \\\\rangle$\")\n", "plt.legend()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "7fb3e103-af1d-4a9f-8016-1a270c5706be", "metadata": {}, "source": [ "Seus resultados são semelhantes aos \"não mitigados\" na Figura 4b? Eles podem ser muito diferentes, dependendo do dispositivo e de sua condição no momento do experimento. Não se preocupe com os resultados em si. O que verificaremos é se você fez a codificação corretamente. Se você fez isso, parabéns, você chegou à linha de partida da era dos serviços públicos.\n", "\n", "Assim como no documento Utility, os cientistas de todo o mundo têm se esforçado muito para extrair resultados significativos mesmo na presença de ruído. O objetivo final desse esforço coletivo é a vantagem quântica: um estado no qual os computadores quânticos podem resolver alguns problemas de uso no setor mais rapidamente, com maior fidelidade ou de forma mais barata do que os computadores clássicos. Não é provável que isso seja um evento único, mas sim uma era em que a reprodução clássica de resultados quânticos leva cada vez mais tempo, até que, em algum momento, o tempo de espera quântico se torna extremamente importante. Uma coisa é clara sobre a vantagem quântica: só chegamos lá por meio de experimentos em escala de utilidade. Se esse curso fizer com que você participe da busca, que é cheia de desafios e diversão, ficaremos muito felizes.\n", "\n" ] }, { "attachments": {}, "cell_type": "markdown", "id": "a346d104-299e-4152-a8ea-5e297d05b6a1", "metadata": {}, "source": [ "\n", "\n", "## Referência\n", "\n", "* Kim, Y., Eddins, A., Anand, S. et al. Evidência da utilidade da computação quântica antes da tolerância a falhas. Nature 618, 500-505 (2023). [https://doi.org/10.1038/s41586-023-06096-3](https://doi.org/10.1038/s41586-023-06096-3)\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "id": "a1b8767d", "source": "© IBM Corp., 2017-2026" } ], "metadata": { "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 } } }, "nbformat": 4, "nbformat_minor": 5 }