{
"cells": [
{
"cell_type": "markdown",
"id": "7ed4867f",
"metadata": {},
"source": [
"---\n",
"title: \"Taglio del circuito per la riduzione della profondità\"\n",
"description: \"Costruisci un modello Qiskit per tagliare i gate in un circuito quantistico al fine di ridurre la profondità del circuito.\"\n",
"---\n",
"\n",
"\n",
"\n",
"# Taglio del circuito per la riduzione della profondità\n",
"\n",
"*Stima di utilizzo: Otto minuti con un processore Eagle (NOTA: questa è solo una stima). Il tempo di esecuzione potrebbe variare)*\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "387c5e80",
"metadata": {},
"source": [
"\n",
"\n",
"## Sfondo\n",
"\n",
"Questa esercitazione mostra come costruire un `Qiskit pattern` per tagliare le porte di un circuito quantistico per ridurre la profondità del circuito. Per una discussione più approfondita sul taglio dei circuiti, visita la [documentazione del componente aggiuntivo Qiskit sul taglio dei circuiti](https://qiskit.github.io/qiskit-addon-cutting/).\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "a62460d9",
"metadata": {},
"source": [
"\n",
"\n",
"## Requisiti\n",
"\n",
"Prima di iniziare questa esercitazione, assicuratevi di aver installato quanto segue:\n",
"\n",
"* Qiskit SDK v2.0 o versioni successive, con supporto [alla visualizzazione](/docs/api/qiskit/visualization)\n",
"* Qiskit Runtime v0.22 o successivamente (`pip install qiskit-ibm-runtime`)\n",
"* Taglio dei circuiti Add-on Qiskit v0.9.0 e o successive (`pip install qiskit-addon-cutting`)\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "a89fe306",
"metadata": {},
"source": [
"\n",
"\n",
"## Configura\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "c795c670",
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"\n",
"from qiskit.circuit.library import EfficientSU2\n",
"from qiskit.quantum_info import PauliList, Statevector, SparsePauliOp\n",
"from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n",
"\n",
"from qiskit_addon_cutting import (\n",
" cut_gates,\n",
" generate_cutting_experiments,\n",
" reconstruct_expectation_values,\n",
")\n",
"\n",
"from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2"
]
},
{
"cell_type": "markdown",
"id": "07f7f75d",
"metadata": {},
"source": [
"\n",
"\n",
"## Fase 1: mappare gli input classici su un problema quantistico\n",
"\n",
"Implementeremo il nostro modello Qiskit utilizzando i quattro passaggi descritti nella [documentazione](/docs/guides/intro-to-patterns). In questo caso, simuleremo i valori di aspettativa su un circuito di una certa profondità tagliando le porte che risultano in porte di scambio ed eseguendo sottoesperimenti su circuiti meno profondi. Il taglio dei gate è rilevante per le fasi 2 (ottimizzazione del circuito per l'esecuzione quantistica mediante la scomposizione di gate distanti) e 4 (post-elaborazione per ricostruire i valori di aspettativa sul circuito originale).\n",
"Nel primo passo, genereremo un circuito dalla libreria di circuiti Qiskit e definiremo alcuni osservabili.\n",
"\n",
"* Ingresso: Parametri classici per definire un circuito\n",
"* Uscita: Circuito astratto e osservabili\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "54ed0f13",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"circuit = EfficientSU2(num_qubits=4, entanglement=\"circular\").decompose()\n",
"circuit.assign_parameters([0.4] * len(circuit.parameters), inplace=True)\n",
"observables = PauliList([\"ZZII\", \"IZZI\", \"IIZZ\", \"XIXI\", \"ZIZZ\", \"IXIX\"])\n",
"circuit.draw(\"mpl\", scale=0.8, style=\"iqp\")"
]
},
{
"cell_type": "markdown",
"id": "080a2a8b",
"metadata": {},
"source": [
"\n",
"\n",
"## Fase 2: Ottimizzazione del problema per l'esecuzione su hardware quantistico\n",
"\n",
"* Ingresso: Circuito astratto e osservabili\n",
"* Output: Circuito target e osservabili prodotti dal taglio di porte distanti per ridurre la profondità del circuito transpilato\n",
"\n",
"Abbiamo scelto un layout iniziale che richiede due scambi per eseguire i gate tra i qubit 3 e 0 e altri due scambi per riportare i qubit alle loro posizioni iniziali. Abbiamo scelto `optimization_level=3`, che è il massimo livello di ottimizzazione disponibile con un gestore di passaggi preimpostato.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b394da7a",
"metadata": {},
"outputs": [],
"source": [
"service = QiskitRuntimeService()\n",
"backend = service.least_busy(\n",
" operational=True, min_num_qubits=circuit.num_qubits, simulator=False\n",
")\n",
"\n",
"pm = generate_preset_pass_manager(\n",
" optimization_level=3, initial_layout=[0, 1, 2, 3], backend=backend\n",
")\n",
"transpiled_qc = pm.run(circuit)"
]
},
{
"cell_type": "markdown",
"id": "68c00476",
"metadata": {},
"source": [
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "4fe4af43",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Transpiled circuit depth: 103\n"
]
},
{
"data": {
"text/plain": [
""
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"print(f\"Transpiled circuit depth: {transpiled_qc.depth()}\")\n",
"transpiled_qc.draw(\"mpl\", scale=0.4, idle_wires=False, style=\"iqp\", fold=-1)"
]
},
{
"cell_type": "markdown",
"id": "babfbd0f",
"metadata": {},
"source": [
"*Trova e taglia i gate distanti:* sostituiremo i gate distanti (gate che collegano qubit non locali, 0 e 3) con `TwoQubitQPDGate` oggetti specificandone gli indici. `cut_gates` sostituirà i gate negli indici specificati con `TwoQubitQPDGate` oggetti e restituirà anche un elenco di `QPDBasis` istanze, una per ogni decomposizione del gate. L'oggetto `QPDBasis` contiene informazioni su come scomporre i gate tagliati in operazioni a singolo qubit.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "23e3d25e",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Find the indices of the distant gates\n",
"cut_indices = [\n",
" i\n",
" for i, instruction in enumerate(circuit.data)\n",
" if {circuit.find_bit(q)[0] for q in instruction.qubits} == {0, 3}\n",
"]\n",
"\n",
"# Decompose distant CNOTs into TwoQubitQPDGate instances\n",
"qpd_circuit, bases = cut_gates(circuit, cut_indices)\n",
"\n",
"qpd_circuit.draw(\"mpl\", scale=0.8)"
]
},
{
"cell_type": "markdown",
"id": "069eb942-e947-4eff-a250-9a99c5ec47f0",
"metadata": {},
"source": [
"*Generare i sottoesperimenti da eseguire sul backend* : `generate_cutting_experiments` accetta un circuito contenente istanze e osservabili di `TwoQubitQPDGate` come `PauliList`.\n",
"\n",
"Per simulare il valore di aspettativa del circuito completo, vengono generati molti sottoesperimenti dalla distribuzione congiunta di quasiprobabilità delle porte scomposte e poi eseguiti su uno o più backend. Il numero di campioni prelevati dalla distribuzione è controllato da `num_samples`, e per ogni campione unico viene fornito un coefficiente combinato. Per maggiori informazioni sulle modalità di calcolo dei coefficienti, consultare il [materiale esplicativo](https://qiskit.github.io/qiskit-addon-cutting/explanation/index.html).\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "83b1efed-bafa-48c4-bbf0-cf7eb9027ac5",
"metadata": {},
"outputs": [],
"source": [
"# Generate the subexperiments and sampling coefficients\n",
"subexperiments, coefficients = generate_cutting_experiments(\n",
" circuits=qpd_circuit, observables=observables, num_samples=np.inf\n",
")"
]
},
{
"cell_type": "markdown",
"id": "6929264d",
"metadata": {},
"source": [
"*A titolo di confronto, vediamo che i sottoesempi QPD saranno meno profondi dopo il taglio di porte distanti* : Ecco un esempio di un sottoesperimento scelto arbitrariamente e generato dal circuito QPD. La sua profondità è stata ridotta di oltre la metà. Molti di questi sottoesperimenti probabilistici devono essere generati e valutati per ricostruire un valore di aspettativa del circuito più profondo.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "70e2f1b6",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Original circuit depth after transpile: 103\n",
"QPD subexperiment depth after transpile: 46\n"
]
},
{
"data": {
"text/plain": [
""
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Transpile the decomposed circuit to the same layout\n",
"transpiled_qpd_circuit = pm.run(subexperiments[100])\n",
"\n",
"print(f\"Original circuit depth after transpile: {transpiled_qc.depth()}\")\n",
"print(\n",
" f\"QPD subexperiment depth after transpile: {transpiled_qpd_circuit.depth()}\"\n",
")\n",
"transpiled_qpd_circuit.draw(\n",
" \"mpl\", scale=0.6, style=\"iqp\", idle_wires=False, fold=-1\n",
")"
]
},
{
"cell_type": "markdown",
"id": "87368cb9",
"metadata": {},
"source": [
"*D'altra parte, il taglio comporta la necessità di un campionamento supplementare*. Qui tagliamo tre porte CNOT, con un overhead di campionamento pari a $9^3$. Per maggiori informazioni sull'overhead di campionamento generato dal taglio del circuito, consultare la [documentazione di Circuit Knitting Toolbox](https://qiskit-extensions.github.io/circuit-knitting-toolbox/circuit_cutting/explanation/index.html).\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "2ab65bd4",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Sampling overhead: 729.0\n"
]
}
],
"source": [
"print(f\"Sampling overhead: {np.prod([basis.overhead for basis in bases])}\")"
]
},
{
"cell_type": "markdown",
"id": "fd9a126c",
"metadata": {},
"source": [
"\n",
"\n",
"## Passaggio 3: eseguire utilizzando Qiskit primitives\n",
"\n",
"Eseguire i circuiti di destinazione (\"sottoesperimenti\") utilizzando la primitiva Sampler.\n",
"\n",
"* Ingresso: Circuiti target\n",
"* Output: Distribuzioni di quasi-probabilità\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "a437de20-2042-4e62-87a7-804058cff5db",
"metadata": {},
"outputs": [],
"source": [
"# Transpile the subexperiments to the backend's instruction set architecture (ISA)\n",
"isa_subexperiments = pm.run(subexperiments)\n",
"\n",
"# Set up the IBM Quantum Sampler primitive. For a fake backend, this will use a local simulator.\n",
"sampler = SamplerV2(backend)\n",
"\n",
"# Submit the subexperiments\n",
"job = sampler.run(isa_subexperiments)"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "ca53d638",
"metadata": {},
"outputs": [],
"source": [
"# Retrieve the results\n",
"results = job.result()"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "32d35001",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"czypg1r6rr3g008mgp6g\n"
]
}
],
"source": [
"print(job.job_id())"
]
},
{
"cell_type": "markdown",
"id": "f04d9134-651b-446e-93f4-aa0281786200",
"metadata": {},
"source": [
"\n",
"\n",
"## Fase 4: Post-elaborazione e restituzione del risultato nel formato classico desiderato\n",
"\n",
"Utilizzare i risultati del sottoesperimento, le sottoosservabili e i coefficienti di campionamento per ricostruire il valore di aspettativa del circuito originale.\n",
"\n",
"Input: Distribuzioni di quasi-probabilità Output: Valori di aspettativa ricostruiti\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "ace12f7f",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Final reconstructed expectation value\n",
"1.0751342773437473\n"
]
}
],
"source": [
"reconstructed_expvals = reconstruct_expectation_values(\n",
" results,\n",
" coefficients,\n",
" observables,\n",
")\n",
"# Reconstruct final expectation value\n",
"final_expval = np.dot(reconstructed_expvals, [1] * len(observables))\n",
"print(\"Final reconstructed expectation value\")\n",
"print(final_expval)"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "e6237a6f",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Ideal expectation value\n",
"1.2283177520039992\n"
]
}
],
"source": [
"ideal_expvals = [\n",
" Statevector(circuit).expectation_value(SparsePauliOp(observable))\n",
" for observable in observables\n",
"]\n",
"print(\"Ideal expectation value\")\n",
"print(np.dot(ideal_expvals, [1] * len(observables)).real)"
]
},
{
"cell_type": "markdown",
"id": "e366d14e",
"metadata": {},
"source": [
"\n",
"\n",
"## Sondaggio tutorial\n",
"\n",
"Vi invitiamo a partecipare a questo breve sondaggio per 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_2ftYFf9t72yFNIO)\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.5,
"qpuSeconds": 480
},
"nbformat": 4,
"nbformat_minor": 5
}