{ "cells": [ { "cell_type": "markdown", "id": "83596f71-5e63-4aa2-907b-75de8813d85a", "metadata": {}, "source": [ "---\n", "title: \"Eseguire circuiti dinamici\"\n", "description: \"Utilizzare il servizio di calcolo \\\" IBM Quantum \\\" per i circuiti classici a propagazione diretta e di controllo, noti anche come circuiti dinamici\"\n", "---\n", "\n", "\n", "\n", "# Eseguire circuiti dinamici\n", "\n" ] }, { "cell_type": "markdown", "id": "2228a8a2-02b7-4a0b-bbe8-0c2933fbe44a", "metadata": {}, "source": [ "I circuiti dinamici sono potenti strumenti che consentono di misurare i qubit nel corso dell'esecuzione di un circuito quantistico e quindi di eseguire operazioni logiche classiche all'interno del circuito, sulla base dei risultati di tali misurazioni effettuate durante l'esecuzione. Questo processo è noto anche come *feedforward classico*. Sebbene siamo ancora agli inizi nel comprendere come sfruttare al meglio i circuiti dinamici, la comunità dei ricercatori quantistici ha già individuato una serie di casi d'uso, quali ad esempio:\n", "\n", "* Preparazione efficiente degli stati quantistici, quali [lo stato GHZ](https://journals.aps.org/prxquantum/abstract/10.1103/PRXQuantum.5.030339), [lo stato W](https://arxiv.org/abs/2403.07604) (per ulteriori informazioni sullo stato W, si veda anche [\"Preparazione degli stati mediante circuiti superficiali con alimentazione diretta\"](https://arxiv.org/abs/2307.14840) ) e un'ampia classe di [stati di prodotto matriciale](https://arxiv.org/abs/2404.16083)\n", "* [Entanglement a lungo raggio efficiente](https://journals.aps.org/prxquantum/abstract/10.1103/PRXQuantum.5.030339) tra qubit sullo stesso chip mediante l'uso di circuiti a bassa profondità\n", "* [Campionamento](https://arxiv.org/pdf/2505.04705) efficiente di circuiti di tipo IQP\n", "\n", "Questi miglioramenti apportati dai circuiti dinamici, tuttavia, comportano alcuni compromessi. Le misurazioni a metà circuito e le operazioni classiche hanno in genere tempi di esecuzione più lunghi rispetto ai gate a due qubit, e questo aumento di tempo potrebbe vanificare i vantaggi derivanti dalla ridotta profondità del circuito. Pertanto, la riduzione della durata delle misurazioni a metà circuito rappresenta un’area di miglioramento prioritaria, in vista del lancio della [nuova versione](/docs/guides/changelog-quantum-compute-service#new-version-dynamic-circuits) dei circuiti dinamici da parte di IBM Quantum®. Per ulteriori restrizioni relative all'uso dei circuiti dinamici, consultare la tabella di compatibilità delle funzionalità [\"Estimator\"](/docs/guides/estimator-options#options-compatibility-table) o [\"Sampler\"](/docs/guides/sampler-options#options-compatibility-table).\n", "\n", "La [specifica \" OpenQASM e 3\"](https://openqasm.com/language/classical.html#looping-and-branching) definisce una serie di strutture di controllo del flusso, ma il servizio di calcolo \" IBM Quantum \" attualmente supporta solo l'istruzione `if` condizionale. In Qiskit SDK, ciò corrisponde al metodo [if\\_test](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#if_test) disponibile su [QuantumCircuit](/docs/api/qiskit/qiskit.circuit.QuantumCircuit). Questo metodo restituisce un [gestore di contesto](https://docs.python.org/3/reference/datamodel.html#with-statement-context-managers) e viene solitamente utilizzato in un'istruzione `with` . Questa guida illustra come utilizzare questa istruzione condizionale.\n", "\n", "\n", " Gli esempi di codice riportati in questa guida utilizzano l'istruzione di misura standard per le misurazioni a circuito aperto. Tuttavia, si consiglia di utilizzare invece `MidCircuitMeasure` l'istruzione, se il backend la supporta. Per ulteriori dettagli, consultare la [sezione \"Misurazioni a metà circuito\"](#midcircuit).\n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "7e9dc06d-85fa-4425-9bd1-ce5085be9741", "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 presente in questa pagina è stato sviluppato sulla base dei seguenti requisiti.\n", " Si consiglia di utilizzare queste versioni o quelle più recenti.\n", "\n", " ```\n", " qiskit[all]~=2.5.1\n", " qiskit-ibm-runtime~=0.47.0\n", " ```\n", " \n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "c4616d43-f296-4a84-a79c-deb37fcdac15", "metadata": {}, "source": [ "\n", "\n", "## Trova backend che supportano circuiti dinamici\n", "\n", "Per individuare tutti i backend a cui il tuo account può accedere e che supportano i circuiti dinamici, esegui un codice simile al seguente. In questo esempio si presume che tu abbia [salvato le tue credenziali di accesso](/docs/guides/save-credentials). È inoltre possibile [specificare esplicitamente le credenziali](/docs/guides/initialize-account#explicit) al momento dell'inizializzazione dell'account di IBM Quantum Compute Service. Questo ti consentirebbe, ad esempio, di visualizzare i backend disponibili su una specifica istanza o per un determinato tipo di piano.\n", "\n", "\n", " * I backend disponibili per l'account dipendono dall'istanza specificata nelle credenziali.\n", " * La nuova versione dei circuiti dinamici è ora disponibile per tutti gli utenti su tutti i backend. Per ulteriori dettagli, consulta [l'annuncio](/docs/guides/changelog-quantum-compute-service#new-dynamic-circuits).\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 2, "id": "a63f07b1-9e8a-4086-ab01-552bd444dc9b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[, , , , ]\n" ] } ], "source": [ "from qiskit_ibm_runtime import QiskitRuntimeService\n", "\n", "service = QiskitRuntimeService()\n", "dc_backends = service.backends(dynamic_circuits=True)\n", "print(dc_backends)" ] }, { "cell_type": "markdown", "id": "1dca7d79-99ea-42bd-86f7-182266907a85", "metadata": {}, "source": [ "\n", "\n", "\n", "\n", "## Misure a metà circuito\n", "\n", "Prima dell'introduzione di `qiskit-ibm-runtime` `v0.43.0`, `measure` questa era l'unica istruzione di misurazione disponibile in Qiskit. Le misurazioni a metà circuito, tuttavia, presentano requisiti di regolazione diversi rispetto alle misurazioni *ai terminali* (misurazioni effettuate all'estremità di un circuito). Ad esempio, quando si ottimizza una misurazione a metà circuito è necessario tenere conto della durata dell'istruzione, poiché le istruzioni più lunghe generano circuiti più rumorosi. Non è necessario tenere conto della durata delle istruzioni per le misurazioni terminali, poiché dopo tali misurazioni non seguono altre istruzioni.\n", "\n", "\n", " L'istruzione `MidCircuitMeasure` corrisponde `measure_2` all'istruzione riportata nel file. del backend `supported_instructions`. Tuttavia, non `measure_2` è supportato su tutti i backend. Usa `service.backends(filters=lambda b: \"measure_2\" in b.supported_instructions)` per trovare i backend che lo supportano. In futuro potrebbero essere aggiunte nuove misurazioni, ma ciò non è garantito.\n", "\n", "\n", "\n", "\n", "### `MidCircuitMeasure` metodo\n", "\n", "In `qiskit-ibm-runtime` v0.43.0 è stata introdotta `MidCircuitMeasure` l'istruzione. Come suggerisce il nome, si tratta di una nuova istruzione di misurazione ottimizzata per l'esecuzione a metà ciclo sulle QPU dell' IBM®. Sebbene sia possibile utilizzare `QuantumCircuit.measure` per una misurazione a metà circuito, grazie alla sua struttura, `MidCircuitMeasure` rappresenta in genere la scelta migliore. Ad esempio, comporta un carico minore sul circuito rispetto all'uso di `QuantumCircuit.measure`.\n", "\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "87dfb9c7-1dc2-4752-bdc1-17b9144369f4", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " ┌───┐┌────────────┐\n", "q_0: ┤ X ├┤0 ├\n", " └───┘│ │\n", "q_1: ─────┤ Measure_2 ├\n", " │ │\n", "c_0: ═════╡0 ╞\n", " └────────────┘\n", "c_1: ═══════════════════\n", " \n" ] } ], "source": [ "from qiskit import QuantumCircuit\n", "from qiskit_ibm_runtime import QiskitRuntimeService\n", "from qiskit_ibm_runtime.circuit import MidCircuitMeasure\n", "\n", "service = QiskitRuntimeService()\n", "backend = service.least_busy(\n", " operational=True, simulator=False, dynamic_circuits=True\n", ")\n", "\n", "circ = QuantumCircuit(2, 2)\n", "circ.x(0)\n", "circ.append(MidCircuitMeasure(), [0], [0])\n", "# circ.measure([0], [0])\n", "# circ.measure_all()\n", "print(circ.draw(cregbundle=False))" ] }, { "cell_type": "markdown", "id": "2b603f88-2e0e-4819-8342-8e3662949ff3", "metadata": {}, "source": [ "\n", " * Per poter utilizzare le misurazioni, è necessario che sia presente almeno un registro classico.\n", " * La primitiva Sampler richiede misurazioni del circuito. È possibile aggiungere misure di circuito con la primitiva Estimator, ma queste vengono ignorate.\n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "9401a5cc-49e0-48b6-8deb-88e9b7da5a5a", "metadata": {}, "source": [ "\n", "\n", "## `Store`\n", "\n", "A partire `qiskit-ibm-runtime` dalla versione 0.47.0, è possibile utilizzare l'istruzione [`store`](/docs/api/qiskit/circuit#store) per salvare il risultato di un'espressione classica, qualora tale espressione debba essere utilizzata più volte. Le operazioni vengono parallelizzate automaticamente, rendendo il codice notevolmente più efficiente in fase di esecuzione.\n", "\n", "Per ulteriori informazioni, consultare la guida [sul feedforward classico e sul flusso di controllo](/docs/guides/classical-feedforward-and-control-flow#store).\n", "\n", "\n", " Quando si utilizza `store` per memorizzare un valore in un registro classico su un backend reale, tale valore viene salvato in memoria solo durante l'esecuzione e non viene copiato né restituito nel risultato del processo.\n", "\n", " `if_test` Ad esempio, nel codice seguente, `temp` ha lo stesso valore di `creg` durante l'esecuzione, e funziona come previsto. Tuttavia, al termine del processo, il `temp` campo « BitArray » riportato nei risultati del processo **non** contiene il valore di `creg`. Cioè, `job.result()[0].data.temp` è `0`.\n", "\n", " ```python\n", " creg = ClassicalRegister(3, \"c\")\n", " temp = ClassicalRegister(3, \"temp\")\n", " ...\n", " qc.store(temp, creg)\n", " with circuit.if_test((temp, 0b001)):\n", " ...\n", " ```\n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "3f374a74-c331-40de-8594-686e471058a2", "metadata": {}, "source": [ "\n", "\n", "## Esempio completo\n", "\n", "Il codice seguente crea ed esegue un circuito dinamico su un hardware dell IBM®.\n", "\n" ] }, { "cell_type": "code", "execution_count": 4, "id": "a7a9c998-4031-432f-978b-83edc040798f", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ ">>> Job ID: d9mq9qnurbec73e67acg (DONE)\n" ] } ], "source": [ "from qiskit_ibm_runtime import SamplerV2, QiskitRuntimeService\n", "from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister\n", "from qiskit.transpiler import generate_preset_pass_manager\n", "\n", "service = QiskitRuntimeService()\n", "backend = service.least_busy(\n", " operational=True, simulator=False, dynamic_circuits=True\n", ")\n", "\n", "# Create a dynamic circuit\n", "\n", "qubits = QuantumRegister(1)\n", "clbits = ClassicalRegister(1)\n", "qc = QuantumCircuit(qubits, clbits)\n", "(q0,) = qubits\n", "(c0,) = clbits\n", "\n", "qc.h(q0)\n", "qc.measure(q0, c0)\n", "with qc.if_test((c0, 1)):\n", " qc.x(q0)\n", "qc.measure(q0, c0)\n", "\n", "\n", "# Convert to an ISA circuit for the given backend\n", "\n", "pm = generate_preset_pass_manager(backend=backend, optimization_level=1)\n", "isa_circuit = pm.run(qc)\n", "\n", "# Generate samplers for backend targets\n", "sampler = SamplerV2(backend)\n", "\n", "# Submit jobs\n", "sampler_job = sampler.run([isa_circuit])\n", "result = sampler_job.result()\n", "\n", "print(\n", " f\">>> {' Job ID:':<10} {sampler_job.job_id()} ({sampler_job.status()})\"\n", ")" ] }, { "cell_type": "markdown", "id": "c5b14dcf-edf4-4fef-bb49-e6b86f06afb0", "metadata": {}, "source": [ "\n", "\n", "## Limiti dell'informatica quantistica\n", "\n", "Quando si eseguono circuiti dinamici in Quantum Compute, è necessario tenere presenti i seguenti vincoli.\n", "\n", "* A causa della memoria fisica limitata dell'elettronica di controllo, vi è anche un limite al numero di `if` istruzioni e alla dimensione dei loro operandi. Questo limite dipende dal numero di trasmissioni e dal numero di bit trasmessi in un processo (non in un circuito).\n", "\n", " Durante l'elaborazione di una `if` condizione, i dati di misura devono essere trasmessi alla logica di controllo per consentire tale valutazione. Una trasmissione è un trasferimento di dati classici univoci, mentre i bit trasmessi sono il numero di bit classici trasferiti. Considerare quanto segue:\n", "\n", " ```python\n", " c0 = ClassicalRegister(3)\n", " c1 = ClassicalRegister(5)\n", " ...\n", " with circuit.if_test((c0, 1)) ...\n", " with circuit.if_test((c0, 3)) ...\n", " with circuit.if_test((c1[2], 1)) ...\n", " ```\n", "\n", " Nell'esempio di codice precedente, i primi due `if_test` oggetti su `c0` sono considerati un'unica trasmissione, poiché il contenuto di non `c0` è cambiato e quindi non è necessario ritrasmetterlo. Quella `if_test` in onda `c1` è una replica. Il primo trasmette tutti e tre i bit, `c0` mentre il secondo ne trasmette solo uno, per un totale di quattro bit trasmessi.\n", "\n", " Attualmente, se si trasmettono 60 bit alla volta, il processo può comportare circa 300 trasmissioni. Se però si trasmette un solo bit alla volta, il processo può comportare 2400 trasmissioni.\n", "\n", "* L'operando utilizzato in `if_test` un'istruzione deve avere una lunghezza massima di 32 bit. Pertanto, se si sta confrontando un intero `ClassicalRegister`, la dimensione di quest'ultimo `ClassicalRegister` deve essere pari o inferiore a 32 bit. Se si confronta solo un singolo bit di un dato `ClassicalRegister`, tuttavia, questo `ClassicalRegister` può essere di qualsiasi dimensione (poiché l'operando è costituito da un solo bit).\n", "\n", " Ad esempio, il blocco di codice \"Non valido\" non funziona perché `cr` supera i 32 bit. È tuttavia possibile utilizzare un registro classico di larghezza superiore a 32 bit se si sta verificando un solo bit, come illustrato nel blocco di codice \"Valid\".\n", "\n", " \n", " \n", " ```python\n", " cr = ClassicalRegister(50)\n", " qr = QuantumRegister(50)\n", " circuit = QuantumCircuit(qr, cr)\n", " ...\n", " circ.measure(qr, cr)\n", " with circ.if_test((cr, 15)):\n", " ...\n", " ```\n", " \n", "\n", " \n", " ```python\n", " cr = ClassicalRegister(50)\n", " qr = QuantumRegister(50)\n", " circuit = QuantumCircuit(qr, cr)\n", " ...\n", " circ.measure(qr, cr)\n", " with circ.if_test((cr[5], 1)):\n", " ...\n", " ```\n", " \n", " \n", "\n", "* Non sono consentite le condizioni annidate. Ad esempio, il seguente blocco di codice non funzionerà perché contiene un `if_test` all'interno di un altro `if_test`:\n", "\n", " \n", " \n", " ```python\n", " c1 = ClassicalRegister(1, \"c1\")\n", " c2 = ClassicalRegister(2, \"c2\")\n", " ...\n", " with circ.if_test((c1, 1)):\n", " with circ.if_test(c2, 1)):\n", " ...\n", " ```\n", " \n", "\n", " \n", " ```python\n", " cr = ClassicalRegister(2)\n", " ...\n", " with circuit.if_test((cr, 0b11)):\n", " ...\n", " ```\n", " \n", " \n", "\n", "* L'uso di `reset` o di misurazioni all'interno di espressioni condizionali non è supportato.\n", "\n", "* Le operazioni aritmetiche non sono supportate.\n", "\n", "* Consulta la [tabella delle funzionalità di “ OpenQASM ” 3](/docs/guides/qasm-feature-table) per verificare quali funzionalità di “ OpenQASM ” 3 sono supportate da Qiskit e Quantum Compute.\n", "\n", "* Quando si utilizza `OpenQASM` 3 (anziché `QuantumCircuit`) come formato di input per passare i circuiti alle primitive `IBM Quantum`, sono supportate solo le istruzioni che possono essere caricate in Qiskit. Le operazioni classiche, ad esempio, non sono supportate perché non possono essere caricate in Qiskit. Per ulteriori informazioni, consultare la sezione “[Importazione di un programma da OpenQASM 3 in Qiskit](/docs/guides/interoperate-qiskit-qasm3#import-an-openqasm-3-program-into-qiskit) ”.\n", "\n", "* Le istruzioni `for`, `while` `switch` , e non sono supportate.\n", "\n" ] }, { "cell_type": "markdown", "id": "ca6e0493-d364-40bf-9f47-2e3feed9f82c", "metadata": {}, "source": [ "\n", "\n", "## Utilizza i circuiti dinamici con Estimator\n", "\n", "Poiché Estimator non supporta i circuiti dinamici, puoi utilizzare [Sampler](/docs/guides/get-started-with-sampler) e creare invece i tuoi circuiti di misura.\n", "\n", "Per riprodurre il comportamento di Estimator, procedere come segue:\n", "\n", "1. Raggruppare i termini di tutte le variabili osservabili in una partizione. Ciò può essere fatto utilizzando, ad esempio, [`PauliList` API](/docs/api/qiskit/qiskit.quantum_info.PauliList#group_qubit_wise_commuting)il.\n", " \n", " È possibile utilizzare l'attributo [`BitArray`](/docs/en/api/qiskit/qiskit.primitives.BitArray#expectation_values) `primitive` per calcolare i valori attesi delle grandezze osservabili fornite.\n", " \n", "2. Eseguire un ciclo di modifica della base per ogni partizione (a seconda della modifica della base necessaria per ciascuna partizione). Per ulteriori informazioni, consultare il [modulo `measurement_bases`](https://qiskit.github.io/qiskit-addon-utils/apidocs/qiskit_addon_utils.exp_vals.html#qiskit_addon_utils.exp_vals.get_measurement_bases) aggiuntivo \"Basi di misurazione\". Per ulteriori informazioni, consultare la [documentazione](https://qiskit.github.io/qiskit-addon-utils/) relativa al pacchetto di utilità dell'add-on Qiskit.\n", "3. Somma i risultati relativi a ciascuna partizione.\n", "\n" ] }, { "cell_type": "markdown", "id": "07045397-6db8-4151-a1e4-de24a8f39ab6", "metadata": {}, "source": [ "\n", "\n", "## Limitazioni\n", "\n", "Consultare una [tabella di compatibilità delle funzionalità](/docs/guides/estimator-options#options-compatibility-table) per comprendere le limitazioni relative all'uso dei circuiti dinamici. Si noti che la compatibilità delle funzionalità non dipende dalle primitive.\n", "\n" ] }, { "cell_type": "markdown", "id": "6688e2e3-766b-4194-99db-ae097e9b8bc7", "metadata": {}, "source": [ "\n", "\n", "## Passi successivi\n", "\n", "\n", " * Scopri come implementare un disaccoppiamento dinamico accurato utilizzando [Stretch](/docs/guides/stretch).\n", " * Consulta la guida [sul feedforward classico e sul flusso di controllo.](/docs/guides/classical-feedforward-and-control-flow)\n", " * Utilizza [la visualizzazione dello schema dei circuiti](/docs/guides/qiskit-runtime-circuit-timing) per eseguire il debug e ottimizzare i tuoi circuiti dinamici.\n", " * Non tutte le funzioni sono compatibili con i circuiti dinamici. Per ulteriori dettagli, consulta la sezione dedicata alla compatibilità delle funzionalità di [Sampler](/docs/guides/sampler-options#feature-compatibility).\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 }