{ "cells": [ { "cell_type": "markdown", "id": "frontmatter", "metadata": {}, "source": [ "---\n", "title: \"Simulação de sistemas quânticos sujeitos a ruído com propagação de Pauli\"\n", "description: \"Simule sistemas quânticos com ruído utilizando a propagação de Pauli na versão mais recente da propagação de Pauli\"\n", "---\n", "\n" ] }, { "cell_type": "markdown", "id": "91eb1163-e828-4c59-a06d-e4f0030f8071", "metadata": {}, "source": [ "\n", "\n", "# Simulação de sistemas quânticos sujeitos a ruído com propagação de Pauli\n", "\n", "{/* cspell:ignore mathscr, mapsto */}\n", "\n", "Neste guia, utilizamos o pacote `pauli-prop` para simular, de forma clássica, a dinâmica temporal de um modelo de Ising de campo transversal (TFIM) de nove qubits com ruído em uma rede quadrada de 3x3. Utilizamos instruções do tipo “ [PauliLindbladError](https://qiskit.github.io/qiskit-aer/stubs/qiskit_aer.noise.PauliLindbladError.html) ” para definir um canal de ruído, $\\Lambda$, que atua sobre um conjunto de camadas de entrelaçamento, $\\mathcal{U}$. Em seguida, propagamos o observável, $O$, de trás para frente através do circuito com ruído e estimamos os valores esperados para uma variedade de modelos de ruído, bem como para o caso sem ruído.\n", "\n", "![Veículo elétrico barulhento](https://quantum.cloud.ibm.com/docs/images/addons/pauli-prop/noisy_ev.avif)\n", "\n", "À medida que a grandeza observável é propagada retroativamente pelo circuito, cada canal de ruído, $\\Lambda_k$, associado à camada de entrelaçamento, $\\mathcal{U}_k$, atenua os termos de Pauli em $O$, que anticomutam com seus geradores de Pauli-Lindblad. Especificamente, se $G_{k,i}$ for um gerador de Pauli de $\\Lambda_k$ com taxa $\\gamma_{k,i}$, então um termo de Pauli, $P$, em $O$ se transforma como: $c_P \\mapsto c_P e^{-2\\gamma_{k,i}} \\quad \\text{if } \\{P, G_{k,i}\\}=0$, onde $c_P$ é o coeficiente de $P$. Uma vez que $O$ tenha sido propagado até o início do circuito, o valor esperado em relação ao estado zero, $|0\\rangle^{\\otimes N}$, pode ser calculado de forma trivial somando-se os coeficientes de cada termo diagonal em $O$ (termos que contêm $Z$ ou $I$ em todos os qubits).\n", "\n", "Fluxo de trabalho:\n", "\n", "* Especifique a rede TFIM e utilize a coloração de arestas para identificar um conjunto mínimo de camadas de entrelaçamento\n", "* Gerar modelos de ruído sintético, $\\Lambda_k$, para cada camada de entrelaçamento única, $U_k$\n", " * Criar modelos de ruído em várias escalas para estudar o impacto do ruído das portas no sistema\n", "* Criar circuitos quânticos sem ruído e com ruído para as diversas profundidades e escalas de ruído de interesse\n", " * Em circuitos ruidosos, são inseridas `PauliLindbladError` instruções antes de cada camada de entrelaçamento\n", "* Utilize a propagação de Pauli para simular os valores exatos da esperança do sistema em várias profundidades\n", " * Para nove qubits, isso é feito permitindo que $O$ cresça até $4^9$ termos, abrangendo todo o espaço de Pauli\n", "* Utilize a propagação de Pauli para simular valores esperados com ruído\n", "* Observe como o aumento do ruído do portão prejudica a precisão do modelo quântico\n", "\n" ] }, { "cell_type": "markdown", "id": "b70d9f4d-2771-45fb-98ac-3c2c4ce978b5", "metadata": {}, "source": [ "\n", "\n", "## Gere uma rede quadrada de 3x3 e encontre uma coloração de 4 cores nas arestas\n", "\n", "Os vértices do grafo representam qubits, e as arestas representam uma conexão entre dois qubits. A coloração das arestas corresponde a camadas de entrelaçamento distintas no circuito quântico, de modo que as portas nas conexões associadas a cores diferentes não podem ser aplicadas simultaneamente.\n", "\n", "Identificar um conjunto mínimo de camadas de entrelaçamento únicas costuma ser importante para a implementação de protocolos eficientes de aprendizado de ruído, já que o ruído de cada camada deve ser aprendido de forma independente. Quanto mais camadas precisamos aprender, mais tentativas precisamos fazer a partir da QPU. Nesta demonstração, utilizamos as informações das camadas para construir circuitos com ruído e injetamos instruçõ [PauliLindbladError](https://qiskit.github.io/qiskit-aer/stubs/qiskit_aer.noise.PauliLindbladError.html) es antes `qiskit-aer` de cada camada de entrelaçamento, a fim de modelar o ruído das portas da QPU.\n", "\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "58bcd725-3447-4bfc-8d63-12fd58082ff7", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "outputs": [], "source": [ "from collections import defaultdict\n", "\n", "import numpy as np\n", "from qiskit.transpiler import CouplingMap\n", "from qiskit_addon_utils.coloring import auto_color_edges\n", "\n", "# Define rectangular square-lattice on 20 qubits\n", "num_rows = 3\n", "num_cols = 3\n", "num_qubits = num_rows * num_cols\n", "\n", "coupling_map = CouplingMap.from_grid(\n", " num_rows=num_rows, num_columns=num_cols, bidirectional=False\n", ")\n", "\n", "# Create mapping from color to edge list\n", "coloring = auto_color_edges(coupling_map.get_edges())\n", "color_to_edge = defaultdict(list)\n", "for edge, color in coloring.items():\n", " color_to_edge[color].append(edge)" ] }, { "cell_type": "code", "execution_count": 2, "id": "adbceb93-6344-465c-9c4a-1c6e98ebc3d6", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [ "remove-input" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The circuit will have 9 qubits and 4 unique entangling layers.\n" ] }, { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from rustworkx import PyDiGraph\n", "from rustworkx.visualization import graphviz_draw\n", "\n", "# Inspect graph coupling and unique entangling layers\n", "print(\n", " f\"The circuit will have {num_qubits} qubits and {len(color_to_edge)} unique entangling layers.\"\n", ")\n", "sq_lattice = PyDiGraph()\n", "sq_lattice.extend_from_weighted_edge_list(\n", " [\n", " (source, target, color)\n", " for ((source, target), color) in coloring.items()\n", " ]\n", ")\n", "\n", "\n", "def color_edge_4color(edge):\n", " color_dict = {0: \"red\", 1: \"green\", 2: \"blue\", 3: \"orange\"}\n", " return {\"color\": color_dict[edge]}\n", "\n", "\n", "graphviz_draw(sq_lattice, edge_attr_fn=color_edge_4color, method=\"neato\")" ] }, { "cell_type": "markdown", "id": "538ccd51-897b-4794-aaff-864d0cea02b3", "metadata": {}, "source": [ "\n", "\n", "## Gerar modelos de ruído sintético\n", "\n", "Antes de criar os circuitos quânticos, geramos um modelo de ruído (instância de [PauliLindbladError](https://qiskit.github.io/qiskit-aer/stubs/qiskit_aer.noise.PauliLindbladError.html) ) para cada uma das camadas de entrelaçamento. Mais tarde, vamos incorporá-las como instruções em nossos circuitos quânticos. Para cada camada, geramos canais de ruído em diferentes escalas. Mais especificamente, geramos modelos de ruído com [o Erro por Portão em Camadas (EPLG)](https://www.ibm.com/quantum/blog/quantum-metric-layer-fidelity) de aproximadamente e `.0004, .0008, .0012, .0016,` `.002`.\n", "\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "3b3bb04e-d8f7-429f-b396-258ccd7197da", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "outputs": [], "source": [ "from qiskit.quantum_info import SparsePauliOp, pauli_basis\n", "from qiskit_aer.noise import PauliLindbladError\n", "\n", "# Pauli-Lindblad noise parameters\n", "seed = 1764\n", "target_EPLGs = [0.0004, 0.0008, 0.0012, 0.0016, 0.002]\n", "\n", "\n", "def generate_random_pauli_lindblad_noise(\n", " edges,\n", " num_qubits: int | None = None,\n", " noise_scale: float = 1e-3,\n", " seed: int | None = None,\n", ") -> PauliLindbladError:\n", " \"\"\"Generate random Pauli-Lindblad noise over the full Pauli basis.\"\"\"\n", " if num_qubits is None:\n", " num_qubits = np.max(edges)\n", "\n", " basis_paulis = [p for p in pauli_basis(2) if np.sum(p.x + p.z)]\n", " basis_paulis = SparsePauliOp.from_sparse_list(\n", " [\n", " (pauli.to_label(), edge, 1)\n", " for pauli in basis_paulis\n", " for edge in edges\n", " ],\n", " num_qubits=num_qubits,\n", " )\n", " basis_paulis = basis_paulis.simplify()\n", " basis_paulis = basis_paulis.paulis\n", "\n", " rng = np.random.default_rng(seed=seed)\n", " rates = rng.random(len(basis_paulis)) * noise_scale\n", "\n", " return PauliLindbladError(generators=basis_paulis, rates=rates)\n", "\n", "\n", "num_generators = (\n", " (num_rows * num_cols)\n", " + (num_rows - 1) * num_cols\n", " + num_rows * (num_cols - 1)\n", ")\n", "noise_scales = [\n", " EPLG * (num_rows * num_cols) / num_generators for EPLG in target_EPLGs\n", "]\n", "noise_models_per_EPLG = [\n", " [\n", " generate_random_pauli_lindblad_noise(\n", " color_to_edge[color],\n", " num_qubits=num_qubits,\n", " noise_scale=noise_scale,\n", " seed=seed,\n", " )\n", " for color in range(len(color_to_edge))\n", " ]\n", " for noise_scale in noise_scales\n", "]" ] }, { "cell_type": "markdown", "id": "5e2044c3-d265-4de3-b489-acfb4b4666de", "metadata": {}, "source": [ "\n", "\n", "## Criar os circuitos quânticos\n", "\n", "Nesta demonstração, simulamos a dinâmica temporal de um modelo de Ising de campo transversal (TFIM) para um número crescente de passos de Trotter (1 a 10 passos). Para cada uma das 10 profundidades do circuito, simulamos o efeito do ruído de porta, com base em modelos de ruído de escalas variadas (`EPLGs = .0004, .0008, .0012, .0016, .002`). O ruído é inserido no circuito como `QuantumCircuit` uma instrução [PauliLindbladError](https://qiskit.github.io/qiskit-aer/stubs/qiskit_aer.noise.PauliLindbladError.html) do Qiskit Aer. O hamiltoniano considerado é:\n", "\n", "$H = -J\\sum\\limits_{\\langle i,j \\rangle} Z_iZ_j + h\\sum\\limits_iX_i$\n", "\n", "onde $J>0$ descreve o acoplamento entre os spins vizinhos mais próximos, $i" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from typing import Any\n", "\n", "from qiskit import QuantumCircuit\n", "\n", "# Ising model parameters\n", "num_steps = 10\n", "J = -1.0\n", "dt = 0.25 / abs(J)\n", "h = 2.0 * abs(J)\n", "initial_state_angle = np.pi / 18.0\n", "rx_angle = 2.0 * h * dt\n", "rzz_angle = 2.0 * J * dt\n", "\n", "\n", "def generate_ising_circuit(\n", " num_qubits: int,\n", " num_steps: int,\n", " rx_angle: float,\n", " rzz_angle: float,\n", " coloring: dict[Any, list[tuple[int, int]]],\n", " layer_noise_models: list[PauliLindbladError] | None = None,\n", " initial_state_angle: float | None = None,\n", ") -> QuantumCircuit:\n", " \"\"\"Generate a quantum circuit implementing a transverse-field Ising model\"\"\"\n", " qc = QuantumCircuit(num_qubits)\n", " if initial_state_angle:\n", " qc.ry(initial_state_angle, range(num_qubits))\n", " qc.rx(rx_angle / 2, range(num_qubits))\n", " for i in range(num_steps):\n", " for j, layer in enumerate(coloring):\n", " edges = coloring[layer]\n", " if layer_noise_models:\n", " qc.append(layer_noise_models[j], qargs=range(num_qubits))\n", " for edge in edges:\n", " qc.rzz(rzz_angle, *edge)\n", " if i == num_steps - 1:\n", " qc.rx(rx_angle / 2, range(num_qubits))\n", " else:\n", " qc.rx(rx_angle, range(num_qubits))\n", " return qc\n", "\n", "\n", "# Create the noiseless and noisy circuits\n", "noiseless_circs = []\n", "noisy_circs = []\n", "for steps in range(1, num_steps + 1):\n", " noiseless_circs.append(\n", " generate_ising_circuit(\n", " num_qubits,\n", " steps,\n", " rx_angle,\n", " rzz_angle,\n", " color_to_edge,\n", " initial_state_angle=initial_state_angle,\n", " )\n", " )\n", " noisy_circs_per_step = []\n", " for noise_models in noise_models_per_EPLG:\n", " noisy_circs_per_step.append(\n", " generate_ising_circuit(\n", " num_qubits,\n", " steps,\n", " rx_angle,\n", " rzz_angle,\n", " color_to_edge,\n", " layer_noise_models=noise_models,\n", " initial_state_angle=initial_state_angle,\n", " )\n", " )\n", " noisy_circs.append(noisy_circs_per_step)\n", "print(\n", " f\"{num_steps} noiseless and {num_steps * len(target_EPLGs)} noisy Trotter circuits generated. {num_steps} different depths across {len(target_EPLGs)} different noise models\"\n", ")\n", "print(\"\\nBelow: Initial state and one noisy Trotter step.\")\n", "noisy_circs[0][0].draw(\"mpl\", fold=-1)" ] }, { "cell_type": "markdown", "id": "007a0560-e1bf-4715-a2fd-a8a5f1e5ac24", "metadata": {}, "source": [ "\n", "\n", "## Especifique as variáveis observáveis e execute as simulações\n", "\n", "Para esta demonstração, simulamos os valores esperados do correlacionador médio de dois sítios:\n", "\n", "$\\langle O \\rangle = \\langle Z_{tot}^2(s) \\rangle = \\frac{1}{N^2}\\sum \\langle \\Psi(\\theta)|(\\mathscr{U}^{\\dagger})^sZ_jZ_k(\\mathscr{U})^s|\\Psi(\\theta) \\rangle$\n", "\n", "onde $\\Psi(\\theta)$ corresponde a uma rotação uniforme $R_y(\\theta)$ em todos os qubits, $\\mathscr{U}^s$ descreve $s$ camadas de Trotter e $(j,k)$ indexa todos os pares de vértices conectados na rede.\n", "\n", "Por fim, utilizamos `pauli_prop` para simular os valores esperados observáveis para cada um dos circuitos. Para essa demonstração de nove qubits, realizamos todas as simulações **de forma exata**. **Não será realizado nenhum truncamento da propagação de Pauli; portanto, as diferenças nos valores esperados entre os diferentes modelos de ruído podem ser inteiramente atribuídas ao erro do gate**. O processo de simulação é realizado em quatro etapas:\n", "\n", "* Transforme as portas Clifford do circuito para a parte inicial do circuito usando `pauli_prop.evolve_through_cliffords`\n", "* Propague a observável pela parte não-Clifford do circuito utilizando `pauli_prop.propagate_through_circuit`\n", " * Realizamos simulações exatas permitindo que a observável cresça até atingir o tamanho do espaço de Pauli completo, $4^9$\n", "* Propagar a variável observável resultante pela parte Clifford do circuito utilizando o Qiskit's `SparsePauliOp.evolve`\n", "* Calcule o valor esperado em relação ao estado zero, $|0\\rangle^{\\otimes N}$, somando os coeficientes de cada termo diagonal em $O$ (termos que contêm $Z$ ou $I$ em todos os qubits)\n", "\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "7ceb7937-ef7d-483a-b49a-d3aa2a3e6c43", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Ran 10 noiseless and 50 noisy simulations in 103s.\n" ] } ], "source": [ "import time\n", "\n", "from pauli_prop import evolve_through_cliffords, propagate_through_circuit\n", "from qiskit.quantum_info import Pauli\n", "\n", "# Average ZZ-correlator observable\n", "id_pauli = Pauli(\"I\" * num_qubits)\n", "observable = 2 * SparsePauliOp(\n", " [\n", " id_pauli.dot(Pauli(\"ZZ\"), [i, j])\n", " for i in range(num_qubits)\n", " for j in range(i + 1, num_qubits)\n", " ]\n", ")\n", "observable /= num_qubits**2\n", "\n", "# Pauli propagation parameters\n", "max_terms = 4**num_qubits # Exact propagation\n", "atol = 1e-12\n", "\n", "# Run simulations\n", "exact_evs = []\n", "noisy_evs = [[] for _ in range(len(target_EPLGs))]\n", "st = time.perf_counter()\n", "for i, noiseless_circ in enumerate(noiseless_circs):\n", " cliff, non_cliff = evolve_through_cliffords(noiseless_circ)\n", " evolved_obs = propagate_through_circuit(\n", " observable, non_cliff, max_terms=max_terms, atol=atol, frame=\"h\"\n", " )[0]\n", " evolved_obs.paulis = evolved_obs.paulis.evolve(cliff, frame=\"h\")\n", " exact_evs.append(\n", " float(evolved_obs.coeffs[~evolved_obs.paulis.x.any(axis=1)].sum())\n", " )\n", " for j in range(len(target_EPLGs)):\n", " noisy_circ = noisy_circs[i][j]\n", " cliff, non_cliff = evolve_through_cliffords(noisy_circ)\n", " evolved_obs = propagate_through_circuit(\n", " observable, non_cliff, max_terms=max_terms, atol=1e-12, frame=\"h\"\n", " )[0]\n", " evolved_obs.paulis = evolved_obs.paulis.evolve(cliff, frame=\"h\")\n", " noisy_evs[j].append(\n", " float(evolved_obs.coeffs[~evolved_obs.paulis.x.any(axis=1)].sum())\n", " )\n", "print(\n", " f\"Ran {len(noiseless_circs)} noiseless and {len(target_EPLGs) * num_steps} noisy simulations in {int(time.perf_counter() - st)}s.\"\n", ")" ] }, { "cell_type": "markdown", "id": "d138fc46-5a47-46d8-9074-6aa30b273a86", "metadata": {}, "source": [ "\n", "\n", "## Observe o efeito do erro de porta no modelo\n", "\n", "Lembre-se de que, como se trata de um experimento com nove qubits, a rotina de propagação de Pauli é exata, e todo o erro nos gráficos de ruído pode ser atribuído ao erro das portas.\n", "\n" ] }, { "cell_type": "code", "execution_count": 6, "id": "73b00aa9-ee66-4b65-ad41-f6278555e5c5", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [ "remove-input" ] }, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "\n", "xs = range(1, num_steps + 1)\n", "plt.plot(xs, exact_evs, label=\"Noiseless\", color=\"black\", marker=\"o\")\n", "colors = [\".3\", \".4\", \".5\", \".6\", \".7\"]\n", "for i, evs in enumerate(noisy_evs):\n", " plt.plot(\n", " xs,\n", " evs,\n", " label=f\"{target_EPLGs[i]} EPLG\",\n", " linestyle=\"--\",\n", " color=colors[i],\n", " marker=\"o\",\n", " )\n", "plt.xlabel(\"# Trotter steps\")\n", "plt.ylabel(r\"$\\langle Z_{tot}^2 \\rangle$\")\n", "plt.legend()\n", "plt.show()" ] }, { "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" } }, "nbformat": 4, "nbformat_minor": 5 }