{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "f7d9993f",
      "metadata": {},
      "source": [
        "---\n",
        "title: \"Mitigazione degli errori della rete tensoriale (TEM) - Una funzione Qiskit di Algorithmiq\"\n",
        "description: \"Introduzione a TEM, una funzione Qiskit di Algorithmiq, per calcolare stime con mitigazione degli errori di post-elaborazione software utilizzando reti tensoriali.\"\n",
        "---\n",
        "\n",
        "{/* cspell:ignore POVM, mathbf, Filippov, Lindblad, Leahy, Rossi, García, Pérez, Minev, Kandala, Temme, informationally  */}\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "dde95705",
      "metadata": {},
      "source": [
        "<span id=\"tensor-network-error-mitigation-tem-a-qiskit-function-by-algorithmiq\" />\n",
        "\n",
        "# Mitigazione degli errori della rete tensoriale (TEM): una funzione Qiskit di Algorithmiq\n",
        "\n",
        "*Consulta la [documentazione dell'API](/docs/api/functions/algorithmiq-tem)*\n",
        "\n",
        "<Admonition type=\"note\" title=\"Nota\">\n",
        "  Le funzioni Qiskit sono una funzione sperimentale disponibile solo per gli utenti di IBM Quantum® Premium Plan, Flex Plan e On-Prem (tramite IBM Quantum Platform API) Plan. Sono in stato di anteprima e sono soggetti a modifiche.\n",
        "</Admonition>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "b130b1ae",
      "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",
        "<Accordion>\n",
        "  <AccordionItem title=\"Versioni del pacchetto\">\n",
        "    Il codice presente in questa pagina è stato sviluppato utilizzando i seguenti requisiti.\n",
        "    Si consiglia di utilizzare queste versioni o versioni più recenti.\n",
        "\n",
        "    ```\n",
        "    qiskit[all]~=2.5.1\n",
        "    ```\n",
        "  </AccordionItem>\n",
        "</Accordion>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "47066e9a",
      "metadata": {},
      "source": [
        "<span id=\"overview\" />\n",
        "\n",
        "## Panoramica\n",
        "\n",
        "Il metodo Tensor-network Error Mitigation (TEM) di Algorithmiq è un algoritmo ibrido algoritmo quantistico-classico progettato per eseguire la mitigazione del rumore interamente in fase di post-elaborazione classica. Con la GST, l'utente può calcolare i valori di aspettativa delle osservabili mitigando gli inevitabili errori indotti dal rumore che si verificano nell'hardware quantistico, con una maggiore precisione ed efficienza dei costi, che la rendono un'opzione molto interessante per i ricercatori quantistici e gli operatori del settore industria.\n",
        "\n",
        "Il metodo consiste nel costruire una rete di tensori che rappresenti l'inverso del del canale di rumore globale che influisce sullo stato del processore quantistico e poi applicare la mappa ai risultati di misura completi dal punto di vista informativo acquisiti dallo stato stato rumoroso per ottenere stimatori imparziali per le osservabili.\n",
        "\n",
        "Come vantaggio, il TEM sfrutta misurazioni complete dal punto di vista informativo per fornire\n",
        "accesso a una vasta serie di valori attesi mitigati di osservabili e ha\n",
        "un overhead di campionamento ottimale sull'hardware quantistico, come descritto in Filippov et\n",
        "al. (2023), e Filippov\n",
        "et [arXiv:2307.11740](https://arxiv.org/abs/2307.11740) al. (2024), [arXiv:2403.13542](https://arxiv.org/abs/2403.13542). Il\n",
        "sovraccarico di misurazione si riferisce al numero di misurazioni aggiuntive necessarie per\n",
        "eseguire un'efficiente mitigazione degli errori, un fattore critico nella fattibilità dei\n",
        "calcoli quantistici. Pertanto, il TEM ha il potenziale per consentire un vantaggio quantistico\n",
        "in scenari complessi, come le applicazioni nei campi del caos quantistico,\n",
        "della fisica dei sistemi a molti corpi, della dinamica di Hubbard e delle simulazioni chimiche di piccole molecole\n",
        ".\n",
        "\n",
        "Le caratteristiche e i vantaggi principali della GST possono essere riassunti come segue:\n",
        "\n",
        "1. **Spese generali di misura ottimali** : La GST è ottimale rispetto ai [limiti teorici](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.131.210601), significa che nessun metodo può ottenere un sovraccarico di misura inferiore. In altre in altre parole, il GST richiede il numero minimo di misurazioni aggiuntive per eseguire la attenuazione degli errori. Questo significa che la GST utilizza un tempo di esecuzione quantistico minimo.\n",
        "2. **Economicità** : Poiché la GST gestisce la mitigazione del rumore interamente nella di post-elaborazione, non è necessario aggiungere altri circuiti al computer quantistico computer quantistico, il che non solo rende il calcolo più economico, ma riduce anche il rischio di introdurre ulteriori errori dovuti alle rischio di introdurre ulteriori errori dovuti alle imperfezioni dei dispositivi quantistici dispositivi quantistici.\n",
        "3. **Stima di più osservabili** : Grazie a misure informaticamente complete, la GST misurazioni, la GST stima in modo efficiente più osservabili con gli stessi dati di misura del computer quantistico.\n",
        "4. **Attenuazione degli errori di misura** : La Funzione GST Qiskit include anche un [metodo proprietario di mitigazione degli errori di misura](https://journals.aps.org/prresearch/abstract/10.1103/PhysRevResearch.5.033154) in grado di ridurre significativamente gli errori di lettura dopo un breve ciclo di calibrazione.\n",
        "5. **Precisione** : La GST migliora significativamente l'accuratezza e l'affidabilità delle simulazioni quantistiche digitali, rendendo gli algoritmi quantistici più precisi e affidabili affidabili.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "5f761442",
      "metadata": {},
      "source": [
        "<span id=\"description\" />\n",
        "\n",
        "## Descrizione\n",
        "\n",
        "La funzione GST consente di ottenere valori di aspettativa mitigati dagli errori per di più osservabili su un circuito quantistico con un overhead di campionamento minimo. Il il circuito viene misurato con una misura a valore operatore positivo completa di informazioni (IC-POVM) misura (IC-POVM) e i risultati delle misure raccolte vengono elaborati su un computer classico. Questa misura viene utilizzata per eseguire i metodi di rete tensoriale e costruire una mappa di e costruire una mappa di inversione del rumore. La funzione applica una mappa che inverte completamente inverte l'intero circuito rumoroso utilizzando reti tensoriali per rappresentare gli strati rumorosi strati.\n",
        "\n",
        "![Schema GST](https://quantum.cloud.ibm.com/docs/images/guides/algorithmiq-tem/tem_scheme.svg \"Stima mitigata dagli errori di un'osservabile O attraverso la post-elaborazione dei risultati delle misure del processore quantistico rumoroso. U e N indicano un'operazione quantistica ideale e la mappa di rumore associata, che può essere generalmente non locale (ed estesa alle caselle grigie). D rappresenta un tensore di operatori duali agli effetti della misura IC. Il modulo di attenuazione del rumore M è una rete tensoriale che viene contratta in modo efficiente dal centro verso l'esterno. La prima iterazione della contrazione è rappresentata dalla linea viola tratteggiata, la seconda dalla linea tratteggiata e la terza dalla linea continua.\")\n",
        "\n",
        "Una volta sottoposti alla funzione, i circuiti sono transpilati e ottimizzati per ridurre al minimo il numero di strati ottimizzati per ridurre al minimo il numero di strati con porte a due qubit (le porte più rumorose dei dispositivi quantistici) più rumorose dei dispositivi quantistici). Il rumore che colpisce gli strati viene appreso attraverso [Qiskit Runtime](/docs/api/qiskit-ibm-runtime/noise-learner-noise-learner) utilizzando un modello di rumore sparso di Pauli-Lindblad come descritto in E. van den Berg, Z. Minev, A. Kandala, K. Temme, Nat. Fisico. (2023).\n",
        "[arXiv:2201.09866](https://arxiv.org/abs/2201.09866).\n",
        "\n",
        "Il modello di rumore è una descrizione accurata del rumore sul dispositivo in grado di di catturare le caratteristiche più sottili, tra cui il cross-talk dei qubit. Tuttavia, il rumore dei dispositivi tuttavia, il rumore dei dispositivi può fluttuare e andare alla deriva e il rumore appreso potrebbe non essere accurato al momento della stima il punto in cui viene effettuata la stima. Questo potrebbe portare a risultati imprecisi risultati imprecisi.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2995da29",
      "metadata": {},
      "source": [
        "<span id=\"get-started\" />\n",
        "\n",
        "## Introduzione\n",
        "\n",
        "Autenticati utilizzando la tua [chiave API IBM Quantum Platform](http://quantum.cloud.ibm.com/) e seleziona la funzione TEM come segue. (Questo frammento di 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": 1,
      "id": "cc0a8093",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[QiskitFunction(qunova/hivqe-chemistry),\n",
              " QiskitFunction(global-data-quantum/quantum-portfolio-optimizer),\n",
              " QiskitFunction(algorithmiq/tem),\n",
              " QiskitFunction(qedma/qesem),\n",
              " QiskitFunction(multiverse/singularity),\n",
              " QiskitFunction(ibm/circuit-function),\n",
              " QiskitFunction(q-ctrl/optimization-solver),\n",
              " QiskitFunction(colibritd/quick-pde),\n",
              " QiskitFunction(q-ctrl/performance-management),\n",
              " QiskitFunction(kipu-quantum/iskay-quantum-optimizer)]"
            ]
          },
          "execution_count": 1,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "from qiskit_ibm_catalog import QiskitFunctionsCatalog\n",
        "\n",
        "tem_function_name = \"algorithmiq/tem\"\n",
        "catalog = QiskitFunctionsCatalog(channel=\"ibm_quantum_platform\")\n",
        "# verify that you have access to the function\n",
        "catalog.list()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "id": "08fa6dcf",
      "metadata": {},
      "outputs": [],
      "source": [
        "# Load your function\n",
        "tem = catalog.load(tem_function_name)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ae7adcc7",
      "metadata": {},
      "source": [
        "<span id=\"example\" />\n",
        "\n",
        "## Esempio\n",
        "\n",
        "Il seguente frammento mostra un esempio in cui la GST viene utilizzata per calcolare i valori di aspettativa di un osservabile dato un semplice circuito quantistico.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "id": "ab05b87f",
      "metadata": {},
      "outputs": [],
      "source": [
        "from qiskit import QuantumCircuit\n",
        "from qiskit.quantum_info import SparsePauliOp\n",
        "\n",
        "# Create a quantum circuit\n",
        "qc = QuantumCircuit(3)\n",
        "qc.u(0.4, 0.9, -0.3, 0)\n",
        "qc.u(-0.4, 0.2, 1.3, 1)\n",
        "qc.u(-1.2, -1.2, 0.3, 2)\n",
        "for _ in range(2):\n",
        "    qc.barrier()\n",
        "    qc.cx(0, 1)\n",
        "    qc.cx(2, 1)\n",
        "    qc.barrier()\n",
        "    qc.u(0.4, 0.9, -0.3, 0)\n",
        "    qc.u(-0.4, 0.2, 1.3, 1)\n",
        "    qc.u(-1.2, -1.2, 0.3, 2)\n",
        "\n",
        "# Define the observables\n",
        "observable = SparsePauliOp(\"IYX\", 1.0)\n",
        "\n",
        "# Define the execution options\n",
        "pub = (qc, [observable])\n",
        "options = {\"default_precision\": 0.02}\n",
        "\n",
        "# Define backend to use. TEM will choose the least-busy device\n",
        "# reported by IBM if not specified\n",
        "backend_name = \"ibm_marrakesh\"\n",
        "\n",
        "# Run the TEM function (uses around three minutes of QPU time)\n",
        "job = tem.run(pubs=[pub], backend_name=backend_name, options=options)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6e2a97e2",
      "metadata": {},
      "source": [
        "Utilizzare le API di Qiskit Serverless per controllare lo stato del carico di lavoro di Qiskit Function:\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "id": "47b0db71",
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "ea1d7802-b067-4cc9-af39-3c2402d22413\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "QUEUED\n"
          ]
        }
      ],
      "source": [
        "# Print the ID so you can use it later, if necessary\n",
        "print(job.job_id)\n",
        "print(job.status())"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "fbaeace8",
      "metadata": {},
      "source": [
        "È possibile restituire i risultati come:\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "id": "ad5b9a53",
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "-0.10628832892063486\n"
          ]
        }
      ],
      "source": [
        "result = job.result()\n",
        "evs = result[0].data.evs\n",
        "print(evs[0])"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "e5e138d3",
      "metadata": {},
      "source": [
        "<Admonition type=\"info\">\n",
        "  Il valore atteso per il circuito senza rumore per l'operatore dato dovrebbe essere intorno a `0.18409094298943401`.\n",
        "</Admonition>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "e9ec2e67",
      "metadata": {},
      "source": [
        "<span id=\"get-support\" />\n",
        "\n",
        "## Ottenere supporto\n",
        "\n",
        "Rivolgetevi a [qiskit \\_ibm@algorithmiq.fi](mailto:qiskit_ibm@algorithmiq.fi)\n",
        "\n",
        "Assicuratevi di includere le seguenti informazioni:\n",
        "\n",
        "* Qiskit Function Job ID (`qiskit-ibm-catalog`), `job.job_id`\n",
        "* Una descrizione dettagliata del problema\n",
        "* Eventuali messaggi o codici di errore rilevanti\n",
        "* Passi per riprodurre il problema\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "5a6a25c8",
      "metadata": {},
      "source": [
        "<span id=\"next-steps\" />\n",
        "\n",
        "## Passi successivi\n",
        "\n",
        "<Admonition type=\"tip\" title=\"Suggerimenti\">\n",
        "  * [Richiedi l'accesso alla funzione di mitigazione degli errori della rete Tensor di Algorithmiq](https://quantum.ibm.com/functions?id=4b1b9d76-c18b-4788-b70b-15125111fbe6).\n",
        "  * Consulta la documentazione [di riferimento dell'API](/docs/api/functions/algorithmiq-tem) relativa a questa funzione di Qiskit.\n",
        "</Admonition>\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": 5
}