{
"cells": [
{
"cell_type": "markdown",
"id": "b6d1e3ec",
"metadata": {},
"source": [
"---\n",
"title: \"Modello di Ising a campo trasversale con gestione delle prestazioni di Q-CTRL\"\n",
"description: \"Costruisci e risolvi il modello di Ising a campo trasversale utilizzando Fire Opal e Qiskit\"\n",
"---\n",
"\n",
"{/* cspell:ignore fontsize sharey rmse RMSE boxstyle */}\n",
"\n",
"\n",
"\n",
"# Modello di Ising a campo trasversale con gestione delle prestazioni di Q-CTRL\n",
"\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"id": "a6f69b77",
"metadata": {},
"source": [
"*Stima di utilizzo: 2 minuti su un processore Heron r2. (NOTA: questa è solo una stima. Il tempo di esecuzione può variare)*\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "8bf80006",
"metadata": {},
"source": [
"\n",
"\n",
"## Sfondo\n",
"\n",
"Il modello Ising a campo trasverso (TFIM) è importante per lo studio del magnetismo quantistico e delle transizioni di fase. Descrive un insieme di spin disposti su un reticolo, dove ogni spin interagisce con i suoi vicini ed è influenzato da un campo magnetico esterno che determina fluttuazioni quantistiche.\n",
"\n",
"Un approccio comune per simulare questo modello consiste nell'utilizzare la decomposizione di Trotter per approssimare l'operatore di evoluzione temporale, costruendo circuiti che alternano rotazioni a singolo qubit e interazioni a due qubit entangling. Tuttavia, questa simulazione su hardware reale è difficile a causa del rumore e della decoerenza, che portano a deviazioni dalla dinamica reale. Per ovviare a questo problema, utilizziamo gli strumenti di soppressione degli errori e di gestione delle prestazioni Fire Opal di Q-CTRL, offerti come funzione Qiskit (vedere la [documentazione di Fire Opal](/docs/guides/q-ctrl-performance-management) ). Fire Opal ottimizza automaticamente l'esecuzione dei circuiti applicando il disaccoppiamento dinamico, il layout avanzato, l'instradamento e altre tecniche di soppressione degli errori, tutte finalizzate alla riduzione del rumore. Grazie a questi miglioramenti, i risultati hardware si allineano maggiormente con le simulazioni senza rumore e quindi possiamo studiare le dinamiche di magnetizzazione del TFIM con maggiore fedeltà.\n",
"\n",
"In questa esercitazione ci occuperemo di:\n",
"\n",
"* Costruire l'hamiltoniana TFIM su un grafo di triangoli di spin collegati\n",
"* Simulare l'evoluzione temporale con circuiti trotterizzati a diverse profondità\n",
"* Calcolo e visualizzazione di magnetizzazioni a singolo qubit $\\langle Z_i \\rangle$ nel tempo\n",
"* Confrontare le simulazioni di base con i risultati delle esecuzioni hardware utilizzando la gestione delle prestazioni di Fire Opal di Q-CTRL\n",
"\n",
"\n",
"\n",
"## Panoramica\n",
"\n",
"Il modello di Ising a campo trasverso (TFIM) è un modello quantistico di spin che cattura le caratteristiche essenziali delle transizioni di fase quantistiche. L'hamiltoniana è definita come:\n",
"\n",
"$$\n",
"H = -J \\sum_{i} Z_i Z_{i+1} - h \\sum_{i} X_i\n",
"$$\n",
"\n",
"dove $Z_i$ e $X_i$ sono operatori di Pauli che agiscono sul qubit $i$, $J$ è la forza di accoppiamento tra spin vicini e $h$ è la forza del campo magnetico trasversale. Il primo termine rappresenta le interazioni ferromagnetiche classiche, mentre il secondo introduce fluttuazioni quantistiche attraverso il campo trasverso. Per simulare la dinamica del TFIM, si utilizza una decomposizione Trotter dell'operatore di evoluzione unitario $e^{-iHt}$, implementato attraverso strati di porte RX e RZZ basate su un grafo personalizzato di triangoli di spin connessi. La simulazione analizza l'evoluzione della magnetizzazione $\\langle Z \\rangle$ con l'aumento dei passi di Trotter.\n",
"\n",
"Le prestazioni dell'implementazione TFIM proposta sono valutate confrontando simulazioni senza rumore con backend rumorosi. Le funzioni avanzate di Fire Opal per l'esecuzione e la soppressione degli errori vengono utilizzate per mitigare l'effetto del rumore nell'hardware reale, ottenendo stime più affidabili delle osservabili di spin come $\\langle Z_i \\rangle$ e dei correlatori $\\langle Z_i Z_j \\rangle$.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "55b94021",
"metadata": {},
"source": [
"\n",
"\n",
"## Requisiti\n",
"\n",
"Prima di iniziare questa esercitazione, assicuratevi di aver installato quanto segue:\n",
"\n",
"* Qiskit SDK v1.4 o versioni successive, con supporto [alla visualizzazione](/docs/api/qiskit/visualization)\n",
"* Qiskit Runtime v0.40 o più tardi (`pip install qiskit-ibm-runtime`)\n",
"* Qiskit Functions Catalog v0.9.0 (`pip install qiskit-ibm-catalog`)\n",
"* Fire Opal SDK v9.0.2 o successivo (`pip install fire-opal`)\n",
"* Q-CTRL Visualizer v8.0.2 o successivo (`pip install qctrl-visualizer`)\n",
"\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"id": "7db2e559",
"metadata": {},
"source": [
"\n",
"\n",
"## Configura\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "ecaa518f",
"metadata": {},
"source": [
"Innanzitutto, autenticati utilizzando la tua [chiave API IBM Quantum](http://quantum.cloud.ibm.com/). Quindi, selezionare la funzione Qiskit come segue. (Questo codice presuppone che tu abbia già [salvato il tuo account](/docs/guides/functions-get-started#install-qiskit-functions-catalog-client) nell'ambiente locale.)\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "bc380c46",
"metadata": {},
"outputs": [],
"source": [
"from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n",
"from qiskit import QuantumCircuit\n",
"from qiskit_ibm_catalog import QiskitFunctionsCatalog\n",
"from qiskit_ibm_runtime import QiskitRuntimeService\n",
"from qiskit_ibm_runtime import SamplerV2 as Sampler\n",
"from qiskit.quantum_info import SparsePauliOp\n",
"from qiskit_aer import AerSimulator\n",
"\n",
"import numpy as np\n",
"import networkx as nx\n",
"import matplotlib.pyplot as plt\n",
"import qctrlvisualizer as qv"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e9d916b6",
"metadata": {},
"outputs": [],
"source": [
"catalog = QiskitFunctionsCatalog(channel=\"ibm_quantum_platform\")\n",
"\n",
"# Access Function\n",
"perf_mgmt = catalog.load(\"q-ctrl/performance-management\")"
]
},
{
"attachments": {},
"cell_type": "markdown",
"id": "988ee237",
"metadata": {},
"source": [
"\n",
"\n",
"## Fase 1: mappare gli input classici su un problema quantistico\n",
"\n",
"\n",
"\n",
"### Genera grafico TFIM\n",
"\n",
"Iniziamo definendo il reticolo di spin e gli accoppiamenti tra di essi. In questa esercitazione, il reticolo è costruito da triangoli connessi disposti in una catena lineare. Ogni triangolo è composto da tre nodi collegati in un anello chiuso e la catena si forma collegando un nodo di ogni triangolo al triangolo precedente.\n",
"\n",
"La funzione helper `connected_triangles_adj_matrix` costruisce la matrice di adiacenza per questa struttura. Per una catena di $n$ triangoli, il grafo risultante contiene $2n+1$ nodi.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "829f1b6d",
"metadata": {},
"outputs": [],
"source": [
"def connected_triangles_adj_matrix(n):\n",
" \"\"\"\n",
" Generate the adjacency matrix for 'n' connected triangles in a chain.\n",
" \"\"\"\n",
" num_nodes = 2 * n + 1\n",
" adj_matrix = np.zeros((num_nodes, num_nodes), dtype=int)\n",
"\n",
" for i in range(n):\n",
" a, b, c = i * 2, i * 2 + 1, i * 2 + 2 # Nodes of the current triangle\n",
"\n",
" # Connect the three nodes in a triangle\n",
" adj_matrix[a, b] = adj_matrix[b, a] = 1\n",
" adj_matrix[b, c] = adj_matrix[c, b] = 1\n",
" adj_matrix[a, c] = adj_matrix[c, a] = 1\n",
"\n",
" # If not the first triangle, connect to the previous triangle\n",
" if i > 0:\n",
" adj_matrix[a, a - 1] = adj_matrix[a - 1, a] = 1\n",
"\n",
" return adj_matrix"
]
},
{
"cell_type": "markdown",
"id": "53869b13",
"metadata": {},
"source": [
"Per visualizzare il reticolo appena definito, possiamo tracciare la catena di triangoli connessi ed etichettare ogni nodo. La funzione seguente costruisce il grafico per un numero scelto di triangoli e lo visualizza.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "2fc293aa",
"metadata": {},
"outputs": [],
"source": [
"def plot_triangle_chain(n, side=1.0):\n",
" \"\"\"\n",
" Plot a horizontal chain of n equilateral triangles.\n",
" Baseline: even nodes (0,2,4,...,2n) on y=0\n",
" Apexes: odd nodes (1,3,5,...,2n-1) above the midpoint.\n",
" \"\"\"\n",
" # Build graph\n",
" A = connected_triangles_adj_matrix(n)\n",
" G = nx.from_numpy_array(A)\n",
"\n",
" h = np.sqrt(3) / 2 * side\n",
" pos = {}\n",
"\n",
" # Place baseline nodes\n",
" for k in range(n + 1):\n",
" pos[2 * k] = (k * side, 0.0)\n",
"\n",
" # Place apex nodes\n",
" for k in range(n):\n",
" x_left = pos[2 * k][0]\n",
" x_right = pos[2 * k + 2][0]\n",
" pos[2 * k + 1] = ((x_left + x_right) / 2, h)\n",
"\n",
" # Draw\n",
" fig, ax = plt.subplots(figsize=(1.5 * n, 2.5))\n",
" nx.draw(\n",
" G,\n",
" pos,\n",
" ax=ax,\n",
" with_labels=True,\n",
" font_size=10,\n",
" font_color=\"white\",\n",
" node_size=600,\n",
" node_color=qv.QCTRL_STYLE_COLORS[0],\n",
" edge_color=\"black\",\n",
" width=2,\n",
" )\n",
" ax.set_aspect(\"equal\")\n",
" ax.margins(0.2)\n",
" plt.show()\n",
"\n",
" return G, pos"
]
},
{
"cell_type": "markdown",
"id": "8abc0622",
"metadata": {},
"source": [
"Per questa esercitazione utilizzeremo una catena di 20 triangoli.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "861ab6e3",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"n_triangles = 20\n",
"n_qubits = 2 * n_triangles + 1\n",
"plot_triangle_chain(n_triangles, side=1.0)\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "ac6f36e3",
"metadata": {},
"source": [
"\n",
"\n",
"### Colorazione dei bordi dei grafici\n",
"\n",
"Per implementare l'accoppiamento spin-spin, è utile raggruppare i bordi che non si sovrappongono. Questo ci permette di applicare porte a due qubit in parallelo. Possiamo farlo con una semplice procedura di colorazione degli spigoli [\\[1\\]](#references), che assegna un colore a ogni spigolo in modo che gli spigoli che si incontrano nello stesso nodo siano collocati in gruppi diversi.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c893b88f",
"metadata": {},
"outputs": [],
"source": [
"def edge_coloring(graph):\n",
" \"\"\"\n",
" Takes a NetworkX graph and returns a list of lists\n",
" where each inner list contains\n",
" the edges assigned the same color.\n",
" \"\"\"\n",
" line_graph = nx.line_graph(graph)\n",
" edge_colors = nx.coloring.greedy_color(line_graph)\n",
"\n",
" color_groups = {}\n",
" for edge, color in edge_colors.items():\n",
" if color not in color_groups:\n",
" color_groups[color] = []\n",
" color_groups[color].append(edge)\n",
"\n",
" return list(color_groups.values())"
]
},
{
"attachments": {},
"cell_type": "markdown",
"id": "b4d480b3",
"metadata": {},
"source": [
"\n",
"\n",
"## Fase 2: Ottimizzazione del problema per l'esecuzione su hardware quantistico\n",
"\n",
"\n",
"\n",
"### Generare circuiti Trotterizzati su grafici di spin\n",
"\n",
"Per simulare la dinamica del TFIM, costruiamo circuiti che approssimano l'operatore di evoluzione temporale.\n",
"\n",
"$$\n",
"U(t) = e^{-i H t}, \\quad \\text{where} \\quad H = -J \\sum_{\\langle i,j \\rangle} Z_i Z_j - h \\sum_i X_i .\n",
"$$\n",
"\n",
"Utilizziamo una decomposizione di Trotter del secondo ordine:\n",
"\n",
"$$\n",
"e^{-i H \\Delta t} \\approx e^{-i H_X \\Delta t / 2}\\, e^{-i H_Z \\Delta t}\\, e^{-i H_X \\Delta t / 2},\n",
"$$\n",
"\n",
"dove $H_X = -h \\sum_i X_i$ e $H_Z = -J \\sum_{\\langle i,j \\rangle} Z_i Z_j$.\n",
"\n",
"* Il termine $H_X$ è implementato con strati di rotazioni `RX` .\n",
"* Il termine $H_Z$ è implementato con strati di porte `RZZ` lungo i bordi del grafo di interazione.\n",
"\n",
"Gli angoli di queste porte sono determinati dal campo trasversale $h$, dalla costante di accoppiamento $J$ e dal passo temporale $\\Delta t$. Impilando più passi di Trotter, generiamo circuiti di profondità crescente che approssimano la dinamica del sistema. Le funzioni `generate_tfim_circ_custom_graph` e `trotter_circuits` costruiscono un circuito quantistico Trotterizzato a partire da un grafo di interazione di spin arbitrario.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ebe5c712",
"metadata": {},
"outputs": [],
"source": [
"def generate_tfim_circ_custom_graph(\n",
" steps, h, J, dt, psi0, graph: nx.graph.Graph, meas_basis=\"Z\", mirror=False\n",
"):\n",
" \"\"\"\n",
" Generate a second order trotter of the form e^(a+b) ~ e^(b/2) e^a e^(b/2)\n",
" for simulating a transverse field ising model:\n",
" e^{-i H t} where the Hamiltonian H = -J \\\\sum_i Z_i Z_{i+1} + h \\\\sum_i X_i.\n",
"\n",
" steps: Number of trotter steps\n",
" theta_x: Angle for layer of X rotations\n",
" theta_zz: Angle for layer of ZZ rotations\n",
" theta_x: Angle for second layer of X rotations\n",
" J: Coupling between nearest neighbor spins\n",
" h: The transverse magnetic field strength\n",
" dt: t/total_steps\n",
" psi0: initial state (assumed to be prepared in the computational basis).\n",
" meas_basis: basis to measure all correlators in\n",
"\n",
" This is a second order trotter of the form e^(a+b) ~ e^(b/2) e^a e^(b/2)\n",
" \"\"\"\n",
" theta_x = h * dt\n",
" theta_zz = -2 * J * dt\n",
" nq = graph.number_of_nodes()\n",
" color_edges = edge_coloring(graph)\n",
" circ = QuantumCircuit(nq, nq)\n",
" # Initial state, for typical cases in the computational basis\n",
" for i, b in enumerate(psi0):\n",
" if b == \"1\":\n",
" circ.x(i)\n",
" # Trotter steps\n",
" for step in range(steps):\n",
" for i in range(nq):\n",
" circ.rx(theta_x, i)\n",
" if mirror:\n",
" color_edges = [sublist[::-1] for sublist in color_edges[::-1]]\n",
" for edge_list in color_edges:\n",
" for edge in edge_list:\n",
" circ.rzz(theta_zz, edge[0], edge[1])\n",
" for i in range(nq):\n",
" circ.rx(theta_x, i)\n",
"\n",
" # some typically used basis rotations\n",
" if meas_basis == \"X\":\n",
" for b in range(nq):\n",
" circ.h(b)\n",
" elif meas_basis == \"Y\":\n",
" for b in range(nq):\n",
" circ.sdg(b)\n",
" circ.h(b)\n",
"\n",
" for i in range(nq):\n",
" circ.measure(i, i)\n",
"\n",
" return circ\n",
"\n",
"\n",
"def trotter_circuits(G, d_ind_tot, J, h, dt, meas_basis, mirror=True):\n",
" \"\"\"\n",
" Generates a sequence of Trotterized circuits, each with increasing depth.\n",
" Given a spin interaction graph and Hamiltonian parameters, it constructs\n",
" a list of circuits with 1 to d_ind_tot Trotter steps\n",
"\n",
" G: Graph defining spin interactions (edges = ZZ couplings)\n",
" d_ind_tot: Number of Trotter steps (maximum depth)\n",
" J: Coupling between nearest neighboring spins\n",
" h: Transverse magnetic field strength\n",
" dt: (t / total_steps\n",
" meas_basis: Basis to measure all correlators in\n",
" mirror: If True, mirror the Trotter layers\n",
" \"\"\"\n",
" qubit_count = len(G)\n",
" circuits = []\n",
" psi0 = \"0\" * qubit_count\n",
"\n",
" for steps in range(1, d_ind_tot + 1):\n",
" circuits.append(\n",
" generate_tfim_circ_custom_graph(\n",
" steps, h, J, dt, psi0, G, meas_basis, mirror\n",
" )\n",
" )\n",
" return circuits"
]
},
{
"cell_type": "markdown",
"id": "50b94af2",
"metadata": {},
"source": [
"\n",
"\n",
"### Stima delle magnetizzazioni a singolo qubit $\\langle Z_i \\rangle$\n",
"\n",
"Per studiare la dinamica del modello, vogliamo misurare la magnetizzazione di ciascun qubit, definita dal valore di aspettativa $\\langle Z_i \\rangle = \\langle \\psi | Z_i | \\psi \\rangle$.\n",
"\n",
"Nelle simulazioni, possiamo calcolarlo direttamente dai risultati della misurazione. La funzione `z_expectation` elabora il conteggio delle stringhe di bit e restituisce il valore di $\\langle Z_i \\rangle$ per un indice di qubit scelto. Su un hardware reale, valutiamo la stessa quantità specificando l'operatore di Pauli con la funzione `generate_z_observables`, e poi il backend calcola il valore di aspettativa.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3fc929e0",
"metadata": {},
"outputs": [],
"source": [
"def z_expectation(counts, index):\n",
" \"\"\"\n",
" counts: Dict of mitigated bitstrings.\n",
" index: Index i in the single operator expectation value < II...Z_i...I >\n",
" to be calculated.\n",
" return: < Z_i >\n",
" \"\"\"\n",
" z_exp = 0\n",
" tot = 0\n",
" for bitstring, value in counts.items():\n",
" bit = int(bitstring[index])\n",
" sign = 1\n",
" if bit % 2 == 1:\n",
" sign = -1\n",
" z_exp += sign * value\n",
" tot += value\n",
"\n",
" return z_exp / tot"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "c9e79716",
"metadata": {},
"outputs": [],
"source": [
"def generate_z_observables(nq):\n",
" observables = []\n",
" for i in range(nq):\n",
" pauli_string = \"\".join([\"Z\" if j == i else \"I\" for j in range(nq)])\n",
" observables.append(SparsePauliOp(pauli_string))\n",
" return observables"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "598d11cf",
"metadata": {},
"outputs": [],
"source": [
"observables = generate_z_observables(n_qubits)"
]
},
{
"cell_type": "markdown",
"id": "397d9b05",
"metadata": {},
"source": [
"Definiamo ora i parametri per la generazione dei circuiti trotterizzati. In questa esercitazione, il reticolo è una catena di 20 triangoli connessi, che corrisponde a un sistema a 41 qubit.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "2853d21b",
"metadata": {},
"outputs": [],
"source": [
"all_circs_mirror = []\n",
"for num_triangles in [n_triangles]:\n",
" for meas_basis in [\"Z\"]:\n",
" A = connected_triangles_adj_matrix(num_triangles)\n",
" G = nx.from_numpy_array(A)\n",
" nq = len(G)\n",
" d_ind_tot = 22\n",
" dt = 2 * np.pi * 1 / 30 * 0.25\n",
" J = 1\n",
" h = -7\n",
" all_circs_mirror.extend(\n",
" trotter_circuits(G, d_ind_tot, J, h, dt, meas_basis, True)\n",
" )\n",
"circs = all_circs_mirror"
]
},
{
"cell_type": "markdown",
"id": "a4b0476d",
"metadata": {},
"source": [
"\n",
"\n",
"## Passaggio 3: eseguire utilizzando Qiskit primitives\n",
"\n",
"\n",
"\n",
"### Esegui simulazione MPS\n",
"\n",
"L'elenco dei circuiti trotterizzati viene eseguito utilizzando il simulatore `matrix_product_state` con una scelta arbitraria di colpi $4096$. Il metodo MPS fornisce un'approssimazione efficiente della dinamica del circuito, con una precisione determinata dalla dimensione del legame scelta. Per le dimensioni del sistema qui considerate, la dimensione predefinita del legame è sufficiente per catturare la dinamica della magnetizzazione con alta fedeltà. I conteggi grezzi vengono normalizzati e da questi si calcolano i valori di aspettativa a singolo qubit $\\langle Z_i \\rangle$ a ogni passo di Trotter. Infine, calcoliamo la media su tutti i qubit per ottenere una singola curva che mostra come la magnetizzazione cambia nel tempo.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "3709531f",
"metadata": {},
"outputs": [],
"source": [
"backend_sim = AerSimulator(method=\"matrix_product_state\")\n",
"\n",
"\n",
"def normalize_counts(counts_list, shots):\n",
" new_counts_list = []\n",
" for counts in counts_list:\n",
" a = {k: v / shots for k, v in counts.items()}\n",
" new_counts_list.append(a)\n",
" return new_counts_list\n",
"\n",
"\n",
"def run_sim(circ_list):\n",
" shots = 4096\n",
" res = backend_sim.run(circ_list, shots=shots)\n",
" normed = normalize_counts(res.result().get_counts(), shots)\n",
" return normed\n",
"\n",
"\n",
"sim_counts = run_sim(circs)"
]
},
{
"cell_type": "markdown",
"id": "5895aa46",
"metadata": {},
"source": [
"\n",
"\n",
"### Eseguire su hardware\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "4b5a2f87",
"metadata": {},
"outputs": [],
"source": [
"service = QiskitRuntimeService()\n",
"backend = service.backend(\"ibm_marrakesh\")\n",
"\n",
"\n",
"def run_qiskit(circ_list):\n",
" shots = 4096\n",
" pm = generate_preset_pass_manager(backend=backend)\n",
" isa_circuits = [pm.run(qc) for qc in circ_list]\n",
" sampler = Sampler(mode=backend)\n",
" res = sampler.run(isa_circuits, shots=shots)\n",
" res = [r.data.c.get_counts() for r in res.result()]\n",
" normed = normalize_counts(res, shots)\n",
" return normed\n",
"\n",
"\n",
"qiskit_counts = run_qiskit(circs)"
]
},
{
"cell_type": "markdown",
"id": "d30269ee",
"metadata": {},
"source": [
"\n",
"\n",
"### Eseguibile su hardware con Fire Opal\n",
"\n",
"Valutiamo la dinamica della magnetizzazione su hardware quantistico reale. Fire Opal offre una funzione Qiskit che estende la primitiva standard \" IBM Quantum Estimator\" con la soppressione automatica degli errori e la gestione delle prestazioni. Invieremo i circuiti “Trotterizzati” direttamente a un backend IBM®, mentre Fire Opal si occuperà dell’esecuzione sensibile al rumore.\n",
"\n",
"Prepariamo un elenco di `pubs`, dove ogni elemento contiene un circuito e le corrispondenti osservabili Pauli-Z. Questi vengono passati alla funzione stimatore di Fire Opal, che restituisce i valori di aspettativa $\\langle Z_i \\rangle$ per ogni qubit a ogni passo di Trotter. I risultati possono poi essere mediati sui qubit per ottenere la curva di magnetizzazione dall'hardware.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ca8348c9",
"metadata": {},
"outputs": [],
"source": [
"backend_name = \"ibm_marrakesh\"\n",
"estimator_pubs = [(qc, observables) for qc in all_circs_mirror[:]]\n",
"\n",
"# Run the circuit using the estimator\n",
"qctrl_estimator_job = perf_mgmt.run(\n",
" primitive=\"estimator\",\n",
" pubs=estimator_pubs,\n",
" backend_name=backend_name,\n",
" options={\"default_shots\": 4096},\n",
")\n",
"\n",
"result_qctrl = qctrl_estimator_job.result()"
]
},
{
"cell_type": "markdown",
"id": "aa081308",
"metadata": {},
"source": [
"\n",
"\n",
"## Fase 4: Post-elaborazione e restituzione del risultato nel formato classico desiderato\n",
"\n",
"Infine, confrontiamo la curva di magnetizzazione ottenuta dal simulatore con i risultati ottenuti sull'hardware reale. I grafici affiancati mostrano quanto l'esecuzione hardware con Fire Opal si avvicini alla linea di base senza rumore attraverso i passi di Trotter.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 102,
"id": "91dd23a5",
"metadata": {},
"outputs": [],
"source": [
"def make_correlators(test_counts, nq, d_ind_tot):\n",
" mz = np.empty((nq, d_ind_tot))\n",
" for d_ind in range(d_ind_tot):\n",
" counts = test_counts[d_ind]\n",
" for i in range(nq):\n",
" mz[i, d_ind] = z_expectation(counts, i)\n",
" average_z = np.mean(mz, axis=0)\n",
" return np.concatenate((np.array([1]), average_z), axis=0)\n",
"\n",
"\n",
"sim_exp = make_correlators(sim_counts[0:22], nq=nq, d_ind_tot=22)\n",
"qiskit_exp = make_correlators(qiskit_counts[0:22], nq=nq, d_ind_tot=22)"
]
},
{
"cell_type": "code",
"execution_count": 103,
"id": "1581f9f0",
"metadata": {},
"outputs": [],
"source": [
"qctrl_exp = [ev.data.evs for ev in result_qctrl[:]]\n",
"qctrl_exp_mean = np.concatenate(\n",
" (np.array([1]), np.mean(qctrl_exp, axis=1)), axis=0\n",
")"
]
},
{
"cell_type": "code",
"execution_count": 26,
"id": "d1f90811",
"metadata": {},
"outputs": [],
"source": [
"def make_expectations_plot(\n",
" sim_z,\n",
" depths,\n",
" exp_qctrl=None,\n",
" exp_qctrl_error=None,\n",
" exp_qiskit=None,\n",
" exp_qiskit_error=None,\n",
" plot_from=0,\n",
" plot_upto=23,\n",
"):\n",
" import numpy as np\n",
" import matplotlib.pyplot as plt\n",
"\n",
" depth_ticks = [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22]\n",
"\n",
" d = np.asarray(depths)[plot_from:plot_upto]\n",
" sim = np.asarray(sim_z)[plot_from:plot_upto]\n",
"\n",
" qk = (\n",
" None\n",
" if exp_qiskit is None\n",
" else np.asarray(exp_qiskit)[plot_from:plot_upto]\n",
" )\n",
" qc = (\n",
" None\n",
" if exp_qctrl is None\n",
" else np.asarray(exp_qctrl)[plot_from:plot_upto]\n",
" )\n",
"\n",
" qk_err = (\n",
" None\n",
" if exp_qiskit_error is None\n",
" else np.asarray(exp_qiskit_error)[plot_from:plot_upto]\n",
" )\n",
" qc_err = (\n",
" None\n",
" if exp_qctrl_error is None\n",
" else np.asarray(exp_qctrl_error)[plot_from:plot_upto]\n",
" )\n",
"\n",
" # ---- helper(s) ----\n",
" def rmse(a, b):\n",
" if a is None or b is None:\n",
" return None\n",
" a = np.asarray(a, dtype=float)\n",
" b = np.asarray(b, dtype=float)\n",
" mask = np.isfinite(a) & np.isfinite(b)\n",
" if not np.any(mask):\n",
" return None\n",
" diff = a[mask] - b[mask]\n",
" return float(np.sqrt(np.mean(diff**2)))\n",
"\n",
" def plot_panel(ax, method_y, method_err, color, label, band_color=None):\n",
" # Noiseless reference\n",
" ax.plot(d, sim, color=\"grey\", label=\"Noiseless simulation\")\n",
"\n",
" # Method line + band\n",
" if method_y is not None:\n",
" ax.plot(d, method_y, color=color, label=label)\n",
" if method_err is not None:\n",
" lo = np.clip(method_y - method_err, -1.05, 1.05)\n",
" hi = np.clip(method_y + method_err, -1.05, 1.05)\n",
" ax.fill_between(\n",
" d,\n",
" lo,\n",
" hi,\n",
" alpha=0.18,\n",
" color=band_color if band_color else color,\n",
" label=f\"{label} ± error\",\n",
" )\n",
" else:\n",
" ax.text(\n",
" 0.5,\n",
" 0.5,\n",
" \"No data\",\n",
" transform=ax.transAxes,\n",
" ha=\"center\",\n",
" va=\"center\",\n",
" fontsize=10,\n",
" color=\"0.4\",\n",
" )\n",
"\n",
" # RMSE box (vs sim)\n",
" r = rmse(method_y, sim)\n",
" if r is not None:\n",
" ax.text(\n",
" 0.98,\n",
" 0.02,\n",
" f\"RMSE: {r:.4f}\",\n",
" transform=ax.transAxes,\n",
" va=\"bottom\",\n",
" ha=\"right\",\n",
" fontsize=8,\n",
" bbox=dict(\n",
" boxstyle=\"round,pad=0.35\", fc=\"white\", ec=\"0.7\", alpha=0.9\n",
" ),\n",
" )\n",
" # Axes\n",
" ax.set_xticks(depth_ticks)\n",
" ax.set_ylim(-1.05, 1.05)\n",
" ax.grid(True, which=\"both\", linewidth=0.4, alpha=0.4)\n",
" ax.set_axisbelow(True)\n",
" ax.legend(prop={\"size\": 8}, loc=\"best\")\n",
"\n",
" fig, axes = plt.subplots(1, 2, figsize=(10, 4), dpi=300, sharey=True)\n",
"\n",
" axes[0].set_title(\"Fire Opal (Q-CTRL)\", fontsize=10)\n",
" plot_panel(\n",
" axes[0],\n",
" qc,\n",
" qc_err,\n",
" color=\"#680CE9\",\n",
" label=\"Fire Opal\",\n",
" band_color=\"#680CE9\",\n",
" )\n",
" axes[0].set_xlabel(\"Trotter step\")\n",
" axes[0].set_ylabel(r\"$\\langle Z \\rangle$\")\n",
" axes[1].set_title(\"Qiskit\", fontsize=10)\n",
" plot_panel(\n",
" axes[1], qk, qk_err, color=\"blue\", label=\"Qiskit\", band_color=\"blue\"\n",
" )\n",
" axes[1].set_xlabel(\"Trotter step\")\n",
"\n",
" plt.tight_layout()\n",
" plt.show()"
]
},
{
"cell_type": "code",
"execution_count": 27,
"id": "415760ad",
"metadata": {},
"outputs": [],
"source": [
"depths = list(range(d_ind_tot + 1))\n",
"errors = np.abs(np.array(qctrl_exp_mean) - np.array(sim_exp))\n",
"\n",
"errors_qiskit = np.abs(np.array(qiskit_exp) - np.array(sim_exp))"
]
},
{
"cell_type": "code",
"execution_count": 28,
"id": "d4902d14",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"make_expectations_plot(\n",
" sim_exp,\n",
" depths,\n",
" exp_qctrl=qctrl_exp_mean,\n",
" exp_qctrl_error=errors,\n",
" exp_qiskit=qiskit_exp,\n",
" exp_qiskit_error=errors_qiskit,\n",
")"
]
},
{
"cell_type": "markdown",
"id": "ee41a301",
"metadata": {},
"source": [
"\n",
"\n",
"## Riferimenti\n",
"\n",
"\\[1] Colorazione dei grafici. Wikipedia. Recuperato il 15 settembre 2025, da [https://en.wikipedia.org/wiki/Graph \\_coloring](https://en.wikipedia.org/wiki/Graph_coloring)\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "2cb5785c",
"metadata": {},
"source": [
"\n",
"\n",
"## Sondaggio tutorial\n",
"\n",
"Dedicate un minuto a fornire un feedback su questa esercitazione. Le vostre indicazioni ci aiuteranno a migliorare la nostra offerta di contenuti e l'esperienza degli utenti.\n",
"\n",
"[Collegamento al sondaggio](https://your.feedback.ibm.com/jfe/form/SV_3BLFkNVEuh0QBWm)\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"
},
"hours": 1,
"qpuSeconds": 120
},
"nbformat": 4,
"nbformat_minor": 5
}