{ "cells": [ { "cell_type": "markdown", "id": "4a4b88ed-d21f-4056-9264-0ee8c8ec4b39", "metadata": {}, "source": [ "---\n", "title: \"Simulazione esatta e rumorosa con le primitive Aer di Qiskit\"\n", "description: \"Impara come eseguire simulazioni precise e rumorose di programmi quantistici con le primitive Qiskit Aer\"\n", "---\n", "\n", "\n", "\n", "# Simulazione esatta e rumorosa con le primitive Aer di Qiskit\n", "\n" ] }, { "cell_type": "markdown", "id": "678b9055-9164-417c-9897-9fde615b97ae", "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", " Il codice di questa pagina è stato sviluppato in base ai seguenti requisiti.\n", " Si consiglia di utilizzare queste versioni o versioni più recenti.\n", "\n", " ```\n", " qiskit[all]~=2.5.1\n", " qiskit-aer~=0.17\n", " ```\n", " \n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "6a0ae8b1-b413-44ac-9267-fd36345a02df", "metadata": {}, "source": [ "[La simulazione esatta con le primitive \" Qiskit SDK \"](/docs/guides/simulate-with-qiskit-sdk-primitives) illustra come utilizzare le primitive di riferimento incluse in Qiskit per eseguire la simulazione esatta dei circuiti quantistici. I processori quantistici attualmente esistenti sono soggetti a errori, o rumore, pertanto i risultati di una simulazione esatta non riflettono necessariamente i risultati che ci si aspetterebbe eseguendo i circuiti su hardware reale. Sebbene le primitive di riferimento in Qiskit non supportino la modellizzazione del rumore, [Qiskit Aer](https://qiskit.org/ecosystem/aer/) include implementazioni delle primitive che supportano tale modellizzazione. Qiskit Aer è un simulatore di circuiti quantistici ad alte prestazioni che è possibile utilizzare al posto delle primitive di riferimento per ottenere prestazioni migliori e funzionalità aggiuntive. Fa parte dell ['ecosistema](https://qiskit.github.io/ecosystem/) Qiskit. In questo articolo illustriamo l'uso delle primitive di Qiskit Aer per la simulazione esatta e quella con rumore.\n", "\n", "\n", " * `qiskit-aer` v0.14 o successivo è necessario.\n", " * Sebbene le primitive di Qiskit Aer implementino le interfacce delle primitive, non offrono le stesse opzioni delle primitive di IBM Quantum. Il livello di resilienza, ad esempio, non è disponibile con le primitive di Qiskit Aer.\n", " * Per maggiori dettagli sulle opzioni del metodo di simulazione supportate da Aer, consultare la [documentazione AerSimulator](https://qiskit.github.io/qiskit-aer/stubs/qiskit_aer.AerSimulator).\n", "\n", "\n", "Per esplorare la simulazione esatta e rumorosa, creare un circuito di esempio su otto qubit:\n", "\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "df70b5fd-971d-4e7d-a23a-8df037c0fa47", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit.circuit.library import efficient_su2\n", "\n", "n_qubits = 8\n", "circuit = efficient_su2(n_qubits)\n", "circuit.draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "2074eaf0-746e-4a36-91d9-db9228f96a0d", "metadata": {}, "source": [ "Questo circuito contiene parametri che rappresentano gli angoli di rotazione per le porte $R_y$ e $R_z$. Quando si simula questo circuito, è necessario specificare i valori espliciti di questi parametri. Nella cella successiva, specifichiamo alcuni valori per questi parametri e utilizziamo la primitiva Estimator di Qiskit Aer per calcolare il valore esatto dell'aspettativa dell'osservabile $ZZ \\cdots Z$.\n", "\n" ] }, { "cell_type": "code", "execution_count": 2, "id": "40270ca7-1084-4329-aac5-28c87edc3791", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.8870140234256602" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit.quantum_info import SparsePauliOp\n", "from qiskit.transpiler import generate_preset_pass_manager\n", "from qiskit_aer import AerSimulator\n", "from qiskit_aer.primitives import EstimatorV2 as Estimator\n", "\n", "observable = SparsePauliOp(\"Z\" * n_qubits)\n", "params = [0.1] * circuit.num_parameters\n", "\n", "exact_estimator = Estimator()\n", "# The circuit needs to be transpiled to the AerSimulator target\n", "pass_manager = generate_preset_pass_manager(3, AerSimulator())\n", "isa_circuit = pass_manager.run(circuit)\n", "pub = (isa_circuit, observable, params)\n", "job = exact_estimator.run([pub])\n", "result = job.result()\n", "pub_result = result[0]\n", "exact_value = float(pub_result.data.evs)\n", "exact_value" ] }, { "cell_type": "markdown", "id": "134d97a2-8420-4931-85b4-324679655e24", "metadata": {}, "source": [ "Ora inizializziamo un modello di rumore che includa un errore di depolarizzazione del 2% su ogni gate CX. In pratica, gli errori derivanti dai gate a due qubit, che in questo caso sono gate CX, costituiscono la principale fonte di errore durante l'esecuzione di un circuito. Per una panoramica sulla creazione di [modelli](/docs/guides/build-noise-models) di rumore in Qiskit Aer, consultare la sezione \"Creazione di modelli di rumore\".\n", "\n", "Nella cella successiva, costruiamo uno stimatore che incorpora questo modello di rumore e lo utilizziamo per calcolare il valore di aspettativa dell'osservabile.\n", "\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "82b2f19a-ba10-46a2-ba1b-89cd27bc0e63", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.7247404214143528" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit_aer.noise import NoiseModel, depolarizing_error\n", "\n", "noise_model = NoiseModel()\n", "cx_depolarizing_prob = 0.02\n", "noise_model.add_all_qubit_quantum_error(\n", " depolarizing_error(cx_depolarizing_prob, 2), [\"cx\"]\n", ")\n", "\n", "noisy_estimator = Estimator(\n", " options=dict(backend_options=dict(noise_model=noise_model))\n", ")\n", "job = noisy_estimator.run([pub])\n", "result = job.result()\n", "pub_result = result[0]\n", "noisy_value = float(pub_result.data.evs)\n", "noisy_value" ] }, { "cell_type": "markdown", "id": "6495f179-3fe6-4971-b023-700b8b2c8cbb", "metadata": {}, "source": [ "Come si può notare, il valore di aspettativa in presenza di rumore è molto lontano dal valore corretto. In pratica, è possibile utilizzare una serie di tecniche di mitigazione degli errori per contrastare gli effetti del rumore, ma la discussione di queste tecniche esula dallo scopo di questo articolo.\n", "\n", "Per avere un'idea molto approssimativa di come il rumore influisca sul risultato finale, si consideri il nostro modello di rumore, che aggiunge un errore di depolarizzazione del 2% a ciascun gate CX. L'errore depolarizzante con probabilità $p$ è definito come un canale quantistico $E$ che ha la seguente azione su una matrice di densità $\\rho$ :\n", "\n", "$$\n", "E(\\rho) = (1 - p) \\rho + p\\frac{I}{2^n}\n", "$$\n", "\n", "dove $n$ è il numero di qubit, in questo caso 2. Cioè, con probabilità $p$, lo stato viene sostituito con lo stato completamente misto, mentre lo stato viene conservato con probabilità $1 - p$. Dopo $m$ applicazioni del canale depolarizzante, la probabilità che lo stato sia conservato sarebbe $(1 - p)^m$. Pertanto, ci aspettiamo che la probabilità di conservare lo stato corretto alla fine della simulazione diminuisca esponenzialmente con il numero di porte CX nel nostro circuito.\n", "\n", "Contiamo il numero di porte CX nel nostro circuito e calcoliamo $(1 - p)^m$. Chiamiamo `count_ops` per ottenere un dizionario che mappa i nomi dei gate con i conteggi e recuperiamo la voce relativa al gate CX.\n", "\n" ] }, { "cell_type": "code", "execution_count": 4, "id": "3c20f7bc-203a-4f40-bb84-7cf3d231d66e", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.6542558123199923" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cx_count = circuit.count_ops()[\"cx\"]\n", "(1 - cx_depolarizing_prob) ** cx_count" ] }, { "cell_type": "markdown", "id": "ef506e15-7480-46ba-bce7-aa8f2fa78377", "metadata": {}, "source": [ "Questo valore, 65%, fornisce una stima approssimativa della probabilità che il nostro stato finale sia corretto. Si tratta di una stima conservativa perché non tiene conto dello stato iniziale della simulazione.\n", "\n", "La seguente cella di codice mostra come utilizzare la primitiva Sampler di Qiskit Aer per campionare il circuito rumoroso. È necessario aggiungere delle misure al circuito prima di eseguirlo con la primitiva Sampler.\n", "\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "76c43aee-d559-4e5b-8228-e5bba3b4499c", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'00000000': 60,\n", " '00001111': 1,\n", " '11000000': 3,\n", " '10100000': 3,\n", " '10001111': 1,\n", " '00010000': 1,\n", " '00001010': 1,\n", " '00111100': 1,\n", " '01000000': 6,\n", " '10000000': 5,\n", " '00110000': 1,\n", " '00011000': 2,\n", " '01100000': 2,\n", " '00000110': 2,\n", " '11000100': 1,\n", " '10000110': 1,\n", " '01010000': 2,\n", " '00011110': 1,\n", " '00010100': 2,\n", " '01011010': 1,\n", " '00000010': 1,\n", " '00001100': 1,\n", " '11100000': 1}" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit_aer.primitives import SamplerV2 as Sampler\n", "\n", "measured_circuit = circuit.copy()\n", "measured_circuit.measure_all()\n", "\n", "noisy_sampler = Sampler(\n", " options=dict(backend_options=dict(noise_model=noise_model))\n", ")\n", "# The circuit needs to be transpiled to the AerSimulator target\n", "pass_manager = generate_preset_pass_manager(3, AerSimulator())\n", "isa_circuit = pass_manager.run(measured_circuit)\n", "pub = (isa_circuit, params, 100)\n", "job = noisy_sampler.run([pub])\n", "result = job.result()\n", "pub_result = result[0]\n", "pub_result.data.meas.get_counts()" ] }, { "cell_type": "markdown", "id": "46a8c6b7-3f7c-48e4-9b73-b04a5458ba33", "metadata": {}, "source": [ "\n", "\n", "## Passi successivi\n", "\n", "\n", " * Per simulare circuiti piccoli e semplici, consultare la sezione “[Simulazione esatta con primitive Qiskit SDK](/docs/guides/simulate-with-qiskit-sdk-primitives) ”.\n", " * Esaminare la documentazione di [Qiskit Aer](https://qiskit.github.io/qiskit-aer/).\n", "\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" } }, "nbformat": 4, "nbformat_minor": 4 }