{ "cells": [ { "cell_type": "markdown", "id": "116af785-a9b7-4eaf-8a86-b1eeb235da18", "metadata": {}, "source": [ "---\n", "title: \"Porte frazionarie\"\n", "description: \"Utilizzare porte frazionarie per eseguire rotazioni a uno e due qubit\"\n", "---\n", "\n", "\n", "\n", "# Porte frazionarie\n", "\n" ] }, { "cell_type": "markdown", "id": "5d679872", "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.3.1\n", " qiskit-ibm-runtime~=0.45.1\n", " ```\n", " \n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "f0d7fa16", "metadata": {}, "source": [ "Questa pagina introduce due nuovi tipi di gate supportati dalla flotta di QPU IBM Quantum®. Queste porte *frazionali* sono supportate sulle [QPU Heron](/docs/guides/processor-types#heron) sotto forma di:\n", "\n", "* $R_{ZZ}(\\theta)$ per $0 \\lt \\theta \\leq \\pi/2$\n", "* $R_X(\\theta)$ per qualsiasi $\\theta$\n", "\n", "In questa pagina vengono illustrati i casi d'uso in cui l'implementazione di porte frazionarie può migliorare l'efficienza dei vostri flussi di lavoro, nonché le modalità di utilizzo di queste porte sulle QPU Quantum di IBM.\n", "\n" ] }, { "cell_type": "markdown", "id": "ee241e99-d095-4cb5-9506-da3d92c32e1c", "metadata": {}, "source": [ "\n", "\n", "## Come utilizzare i gate frazionari\n", "\n", "Internamente, questi gate frazionari funzionano eseguendo direttamente una rotazione $R_{ZZ}(\\theta)$ e $R_X(\\theta)$ per un angolo arbitrario. L'uso del gate $R_X(\\theta)$ può ridurre fino a un fattore due la durata e l'errore delle rotazioni di un singolo qubit con angolo arbitrario. L'esecuzione diretta della rotazione del gate dell' $R_{ZZ}(\\theta)$ e evita la scomposizione in più `CZGate` oggetti, riducendo in modo simile la durata e l'errore di un circuito. Ciò è particolarmente utile per i circuiti che contengono molte rotazioni a uno e due qubit, come quando si simula la dinamica di un sistema quantistico o quando si utilizza un approccio variazionale con molti parametri.\n", "\n", "Sebbene questi tipi di porte facciano parte della [libreria di porte standard](/docs/guides/circuit-library) di cui `QuantumCircuit` si può disporre, possono essere utilizzati solo su specifiche QPU IBM Quantum, che devono essere caricate con il flag `use_fractional_gates` impostato su `True` (come mostrato di seguito). Questo flag garantirà che i gate frazionari vengano inclusi nel backend `Target` del transpiler.\n", "\n", "```python\n", "service = QiskitRuntimeService()\n", "backend = service.backend('ibm_torino', use_fractional_gates=True)\n", "```\n", "\n", "Questo esempio di codice mostra come utilizzare le porte frazionali nel contesto di un flusso di lavoro che simula la dinamica di una catena di Ising utilizzando porte frazionali. La durata del circuito viene quindi confrontata con un backend che non utilizza porte frazionarie.\n", "\n", "\n", " Il valore di errore riportato nel sito `Target` di un backend con gate frazionali abilitati è solo una copia della controparte del gate non frazionale (che potrebbe non essere la stessa). Questo perché la segnalazione dei tassi di errore sulle porte frazionali non è ancora supportata.\n", "\n", " Tuttavia, poiché il tempo di gate delle porte frazionarie e di quelle non frazionarie è lo stesso, è ragionevole supporre che i loro tassi di errore siano comparabili, soprattutto quando la fonte di errore dominante in un circuito è dovuta al rilassamento.\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "9cb7f696-dec0-4393-9320-fe945326c893", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit import QuantumCircuit\n", "from qiskit.circuit import Parameter\n", "from qiskit.transpiler import generate_preset_pass_manager\n", "from qiskit.visualization.timeline import draw as draw_timeline, IQXSimple\n", "\n", "from qiskit_ibm_runtime import QiskitRuntimeService\n", "\n", "\n", "num_qubits = 5\n", "num_time_steps = 3\n", "rx_angle = 0.1\n", "rzz_angle = 0.1\n", "\n", "ising_circuit = QuantumCircuit(num_qubits)\n", "for i in range(num_time_steps):\n", " # rx layer\n", " for q in range(num_qubits):\n", " ising_circuit.rx(rx_angle, q)\n", " for q in range(1, num_qubits - 1, 2):\n", " ising_circuit.rzz(rzz_angle, q, q + 1)\n", " # 2nd rzz layer\n", " for q in range(0, num_qubits - 1, 2):\n", " ising_circuit.rzz(rzz_angle, q, q + 1)\n", " ising_circuit.barrier()\n", "ising_circuit.draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "983bbe11-fa20-4043-a146-66af18cae054", "metadata": {}, "source": [ "Specificare due oggetti backend: uno con le porte frazionarie abilitate e l'altro con le porte disabilitate, quindi transpilare entrambi.\n", "\n" ] }, { "cell_type": "code", "execution_count": 2, "id": "09ef3ed0-7126-45a2-a876-35a4f540c949", "metadata": {}, "outputs": [], "source": [ "service = QiskitRuntimeService()\n", "backend_fractional = service.backend(\"ibm_torino\", use_fractional_gates=True)\n", "backend_conventional = service.backend(\n", " \"ibm_torino\", use_fractional_gates=False\n", ")\n", "\n", "pm_fractional = generate_preset_pass_manager(\n", " optimization_level=3, backend=backend_fractional, scheduling_method=\"alap\"\n", ")\n", "pm_conventional = generate_preset_pass_manager(\n", " optimization_level=3,\n", " backend=backend_conventional,\n", " scheduling_method=\"alap\",\n", ")\n", "\n", "ising_circuit_fractional = pm_fractional.run(ising_circuit)\n", "ising_circuit_conventional = pm_conventional.run(ising_circuit)" ] }, { "cell_type": "markdown", "id": "cf108858-b8ee-44a8-b252-3e7748b691f8", "metadata": {}, "source": [ "Visualizzate la linea temporale del circuito che utilizza i due tipi di porte.\n", "\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "0013f5fa-4072-4aa4-94fe-7e195435f828", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Draw timeline of circuit with conventional gates\n", "draw_timeline(\n", " ising_circuit_conventional,\n", " idle_wires=False,\n", " target=backend_conventional.target,\n", " time_range=(0, 500),\n", " style=IQXSimple(),\n", ")" ] }, { "cell_type": "code", "execution_count": 4, "id": "08dd1cdf-8b34-47c2-8324-f3538c9d1ab6", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Draw timeline of circuit with fractional gates\n", "draw_timeline(\n", " ising_circuit_fractional,\n", " idle_wires=False,\n", " target=backend_fractional.target,\n", " time_range=(0, 500),\n", " style=IQXSimple(),\n", ")" ] }, { "cell_type": "markdown", "id": "76f9f94e-f402-4519-b991-708b74a4f88c", "metadata": {}, "source": [ "\n", "\n", "### Vincoli angolari\n", "\n", "Per il gate “ $R_{ZZ}(\\theta)$ ” a due qubit, sull’hardware IBM Quantum è possibile eseguire solo gli angoli compresi tra $0$ e $\\pi/2$. Se un circuito contiene porte di tipo “ $R_{ZZ}(\\theta)$ ” con un angolo al di fuori di questo intervallo, la pipeline di transpilazione standard provvederà generalmente a correggere tale anomalia mediante un’adeguata trasformazione del circuito (attraverso il pass [`FoldRzzAngle`](../api/qiskit-ibm-runtime/transpiler-passes-fold-rzz-angle) ). Tuttavia, per qualsiasi gate di tipo “ $R_{ZZ}(\\theta)$ ” contenente una o più [`Parameter`](/docs/api/qiskit/qiskit.circuit.Parameter)“s”, il transpiler presupporrà che a questi parametri vengano assegnati angoli compresi in tale intervallo in fase di esecuzione. Il processo non andrà a buon fine se uno qualsiasi dei valori dei parametri specificati nel file “ PUB ” inviato al servizio di calcolo IBM Quantum non rientra in questo intervallo.\n", "\n" ] }, { "cell_type": "markdown", "id": "48bad5e6-3c7a-4bd0-b050-e440c3257be2", "metadata": {}, "source": [ "\n", "\n", "## Dove utilizzare i gate frazionari\n", "\n", "Storicamente, le porte di base disponibili sulle QPU Quantum di IBM sono state **`CZ`**, **`X`**, **`RZ`**, **`SX`**, e \\*\\*`ID`\\*\\*che non possono rappresentare in modo efficiente circuiti con rotazioni a uno o due qubit che non siano multipli di $\\pi / 2$. Ad esempio, una porta $R_X(\\theta)$, quando viene trasposta, deve decomporsi in una serie di porte $RZ$ e $\\sqrt{X}$, il che crea un circuito con due porte di durata finita invece di una.\n", "\n", "Allo stesso modo, quando le rotazioni a due qubit, come un gate $R_{ZZ}(\\theta)$, vengono transpilate, la decomposizione richiede due gate e diversi gate a singolo qubit, il che aumenta la profondità del circuito **`CZ`** e diverse porte a singolo qubit, il che aumenta la profondità del circuito. Queste scomposizioni sono mostrate nel codice seguente.\n", "\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "11b003ee-aa8e-4794-a84a-b6870d15fa11", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "qc = QuantumCircuit(1)\n", "param = Parameter(\"θ\")\n", "qc.rx(param, 0)\n", "qc.draw(\"mpl\")" ] }, { "cell_type": "code", "execution_count": 6, "id": "5da9bba4-9a3b-4569-9997-c5b9ccf87b6a", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Decomposition of an RX(θ) gate using the IBM Quantum QPU basis\n", "service = QiskitRuntimeService()\n", "backend = service.backend(\"ibm_torino\")\n", "optimization_level = 3\n", "pm = generate_preset_pass_manager(optimization_level, backend=backend)\n", "transpiled_circuit = pm.run(qc)\n", "transpiled_circuit.draw(\"mpl\", idle_wires=False)" ] }, { "cell_type": "code", "execution_count": 7, "id": "6b256201-0237-4f63-91ff-fde1bb884804", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit import QuantumCircuit\n", "from qiskit.circuit import Parameter\n", "from qiskit.transpiler import generate_preset_pass_manager\n", "\n", "from qiskit_ibm_runtime import QiskitRuntimeService\n", "\n", "qc = QuantumCircuit(2)\n", "param = Parameter(\"θ\")\n", "qc.rzz(param, 0, 1)\n", "qc.draw(\"mpl\")" ] }, { "cell_type": "code", "execution_count": 8, "id": "f07217b9-a6f0-4adf-b341-6da447535c33", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Decomposition of an RZZ(θ) gate using the IBM Quantum QPU basis\n", "service = QiskitRuntimeService()\n", "backend = service.backend(\"ibm_torino\")\n", "optimization_level = 3\n", "pm = generate_preset_pass_manager(optimization_level, backend=backend)\n", "transpiled_circuit = pm.run(qc)\n", "transpiled_circuit.draw(\"mpl\", idle_wires=False)" ] }, { "cell_type": "markdown", "id": "5bc4f276-80e4-49af-bd5c-d9dceedc9aa3", "metadata": {}, "source": [ "Per i flussi di lavoro che richiedono molte rotazioni a un solo qubit $R_X(\\theta)$ o a due qubit (come in un'ansatz variazionale o nella simulazione dell'evoluzione temporale dei sistemi quantistici), questo vincolo fa crescere rapidamente la profondità del circuito. Tuttavia, le porte frazionali eliminano questo requisito, poiché le rotazioni a uno e due qubit vengono eseguite direttamente, e creano un circuito quantistico più efficiente (e quindi a prova di errore).\n", "\n" ] }, { "cell_type": "markdown", "id": "c601cc20-be04-45b6-9917-e8fe2925d36b", "metadata": {}, "source": [ "\n", "\n", "\n", "\n", "\n", "\n", "## Quando *non* utilizzare i gate frazionari\n", "\n", "È importante sottolineare che i gate frazionari sono una funzionalità *sperimentale* e che il comportamento del flag `use_fractional_gates` potrebbe subire modifiche in futuro. Per `qiskit-ibm-runtime` ulteriori informazioni, consultare le [note di rilascio](/docs/api/qiskit-ibm-runtime/release-notes) delle nuove versioni di. Si veda anche la documentazione di riferimento dell'API per [QiskitRuntimeService](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service#backend).backend, che descrive `use_fractional_gates`.\n", "\n", "Inoltre, il transpiler Qiskit ha una capacità limitata di utilizzare $R_{ZZ}(\\theta)$ nei suoi passaggi di ottimizzazione. Ciò richiede una maggiore attenzione nella realizzazione e nell'ottimizzazione dei circuiti che contengono queste istruzioni.\n", "\n", "Infine, l'utilizzo di porte frazionali non è supportato per:\n", "\n", "* [Pauli twirling](/docs/guides/error-mitigation-and-suppression-techniques#pauli-twirling) - tuttavia, *è* supportato il [twirling delle misure con TREX](/docs/guides/error-mitigation-and-suppression-techniques#twirled-readout-error-extinction-trex).\n", "* [Cancellazione probabilistica degli errori](/docs/guides/error-mitigation-and-suppression-techniques#probabilistic-error-cancellation-pec)\n", "* [Estrapolazione a rumore zero (utilizzando l'amplificazione probabilistica degli errori)](/docs/guides/error-mitigation-and-suppression-techniques#probabilistic-error-amplification-pea)\n", "\n", "Leggete la guida sulle [opzioni primitive](/docs/guides/runtime-options-overview) per saperne di più sulla personalizzazione delle tecniche di attenuazione e soppressione degli errori per un determinato carico di lavoro quantistico.\n", "\n" ] }, { "cell_type": "markdown", "id": "58fba520-5d6e-4647-8cb7-2c8790eb8127", "metadata": {}, "source": [ "\n", "\n", "## Quali backend supportano i gate frazionari?\n", "\n", "Non tutti i backend supportano i gate frazionari. Corri `service.backends(use_fractional_gates=True)` per trovare quelli che lo fanno. Con il rilascio di v0.48`qiskit-ibm-runtime` , è anche possibile eseguire il comando per `service.least_busy(fractional_gates=True)` individuare il backend meno carico che supporti i gate frazionari. Un backend fittizio supporta i gate frazionari solo se il relativo backend “reale” li supporta.\n", "\n", "Si noti che i backend fittizi non supportano i gate frazionari per impostazione predefinita, poiché tali gate sono disabilitati di default. Per abilitare i gate frazionari su un backend fittizio che li supporti, aggiorna la sua configurazione.\n", "\n", "Esempio:\n", "\n", "```python\n", "service = QiskitRuntimeService()\n", "fake_backend = FakeBoston()\n", "fake_backend.refresh(service=service, use_fractional_gates=True)\n", "```\n", "\n" ] }, { "cell_type": "markdown", "id": "bf0a38a6-60d1-4848-bbde-df19bb496510", "metadata": {}, "source": [ "\n", "\n", "## Passi successivi\n", "\n", "\n", " * Per saperne di più sulla trasposizione, consultare la pagina [Introduzione alla trasposizione](/docs/guides/transpile).\n", " * Leggete come [scrivere un passaggio di transpiler personalizzato](/docs/guides/custom-transpiler-pass).\n", " * Scopri come [configurare la mitigazione degli errori](/docs/guides/configure-error-mitigation).\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": 2 }