{ "cells": [ { "cell_type": "markdown", "id": "aea62c4c-1e42-4472-9f1d-e52783e81fc6", "metadata": {}, "source": [ "---\n", "title: \"Libreria di circuiti\"\n", "description: \"Maggiori informazioni sui circuiti pronti all'uso forniti dalla libreria di circuiti Qiskit, inclusi circuiti N-locali, di evoluzione temporale e di codifica dei dati\"\n", "---\n", "\n", "{/* cspell:ignore cout */}\n", "\n", "\n", "\n", "# Libreria di circuiti\n", "\n" ] }, { "cell_type": "markdown", "id": "14baab34-71a4-4d3c-bdc1-083bb2c32065", "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.5.1\n", " ```\n", " \n", "\n", "\n" ] }, { "attachments": {}, "cell_type": "markdown", "id": "6f257ff9-15c4-48d8-9503-7f0ab16a91b2", "metadata": {}, "source": [ "L'SDK di Qiskit include una libreria di circuiti popolari da utilizzare come blocchi di costruzione nei vostri programmi. L'uso di circuiti predefiniti consente di risparmiare tempo nella ricerca, nella scrittura del codice e nel debug. La libreria comprende circuiti popolari nell'ambito dell'informatica quantistica, circuiti difficili da simulare in modo classico e circuiti utili per il benchmarking dell'hardware quantistico.\n", "\n", "Questa pagina elenca le diverse categorie di circuiti che la biblioteca mette a disposizione. Per un elenco completo dei circuiti, consultare la [documentazione API della libreria dei circuiti](/docs/api/qiskit/circuit_library).\n", "\n" ] }, { "cell_type": "markdown", "id": "0b473350", "metadata": {}, "source": [ "\n", "\n", "## Cancelli standard\n", "\n", "La libreria di circuiti comprende anche porte quantistiche standard. Alcune sono porte fondamentali (come la `UGate`), altre sono porte multi-qubit che di solito devono essere costruite a partire da porte a uno o due qubit. Per aggiungere gate importati al vostro circuito, utilizzate il metodo `append` ; il primo argomento è il gate e l'argomento successivo è un elenco di qubit a cui applicare il gate.\n", "\n", "Ad esempio, la seguente cella di codice crea un circuito con una porta Hadamard e una porta-X multicontrollata.\n", "\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "a846a845-7ac5-4c92-b124-d2b90a773ba2", "metadata": { "tags": [ "ignore-warnings" ] }, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit import QuantumCircuit\n", "from qiskit.circuit.library import HGate, MCXGate\n", "\n", "mcx_gate = MCXGate(3)\n", "hadamard_gate = HGate()\n", "\n", "qc = QuantumCircuit(4)\n", "qc.append(hadamard_gate, [0])\n", "qc.append(mcx_gate, [0, 1, 2, 3])\n", "qc.draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "e5066595", "metadata": {}, "source": [ "Vedere [Porte standard](/docs/api/qiskit/circuit_library#standard-gates) nella documentazione dell'API della libreria dei circuiti.\n", "\n" ] }, { "cell_type": "markdown", "id": "f1d7c8c9-1b4d-45e1-9cd5-c5d76c2e25ab", "metadata": {}, "source": [ "\n", "\n", "## Circuiti N-locali\n", "\n", "Questi circuiti alternano strati di porte di rotazione a singolo qubit con strati di porte di entangling a più qubit.\n", "\n", "Questa famiglia di circuiti è popolare negli algoritmi quantistici variazionali perché può produrre un'ampia gamma di stati quantistici. Gli algoritmi variazionali regolano i parametri del gate per trovare stati che abbiano determinate proprietà (come gli stati che rappresentano una buona soluzione a un problema di ottimizzazione). A questo scopo, molti circuiti della libreria sono **parametrizzati**, il che significa che è possibile definirli senza valori fissi.\n", "\n", "La seguente cella di codice importa un circuito `n_local` , in cui le porte di entangling sono porte a due qubit. Questo circuito intreccia blocchi di porte parametrate a un solo qubit, seguiti da blocchi di porte a due qubit entangling. Il codice seguente crea un circuito a tre qubit, con porte RX a un qubit e porte CZ a due qubit.\n", "\n" ] }, { "cell_type": "code", "execution_count": 2, "id": "3ccaeb1b-03c6-4dfa-9000-e48db2516303", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit.circuit.library import n_local\n", "\n", "two_local = n_local(3, \"rx\", \"cz\")\n", "two_local.draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "e32e031b-3218-4c1c-af7c-b40ad6c82100", "metadata": {}, "source": [ "È possibile ottenere un oggetto simile a un elenco di parametri del circuito dall'attributo `parameters` .\n", "\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "d503e1c8-0ccd-4868-a5dc-4806d00ab54b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "ParameterView([ParameterVectorElement(θ[0]), ParameterVectorElement(θ[1]), ParameterVectorElement(θ[2]), ParameterVectorElement(θ[3]), ParameterVectorElement(θ[4]), ParameterVectorElement(θ[5]), ParameterVectorElement(θ[6]), ParameterVectorElement(θ[7]), ParameterVectorElement(θ[8]), ParameterVectorElement(θ[9]), ParameterVectorElement(θ[10]), ParameterVectorElement(θ[11])])" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "two_local.parameters" ] }, { "cell_type": "markdown", "id": "555aca2a-a754-4372-8846-22ee4773ece1", "metadata": {}, "source": [ "Si può anche usare per assegnare questi parametri a valori reali, usando un dizionario della forma `{ Parameter: number }`. Per dimostrarlo, la seguente cella di codice assegna ogni parametro del circuito a `0`.\n", "\n" ] }, { "cell_type": "code", "execution_count": 4, "id": "89227b48-12b2-4b1b-9680-55a7fce88a2b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "bound_circuit = two_local.assign_parameters(\n", " {p: 0 for p in two_local.parameters}\n", ")\n", "bound_circuit.decompose().draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "78772993-d0da-4651-9211-706e86a59432", "metadata": {}, "source": [ "Per ulteriori informazioni, consultare le [porte N-locali](/docs/api/qiskit/circuit_library#n-local-circuits) nella documentazione dell'API della libreria dei circuiti o seguire il [corso di progettazione di algoritmi variazionali](/learning/courses/variational-algorithm-design) in IBM Quantum Learning.\n", "\n" ] }, { "cell_type": "markdown", "id": "3e463081-bce9-4ee2-9046-97659e9ac847", "metadata": {}, "source": [ "\n", "\n", "## Circuiti di codifica dati\n", "\n", "Questi circuiti parametrizzati codificano i dati su stati quantistici per l'elaborazione da parte di algoritmi di apprendimento automatico quantistico. Alcuni circuiti supportati da Qiskit sono:\n", "\n", "* Codifica dell'ampiezza, che codifica ogni numero nell'ampiezza di uno stato base. Questo può memorizzare $2^n$ numeri in un singolo stato, ma può essere costoso da implementare.\n", "* Codifica di base, che codifica un intero $k$ preparando il corrispondente stato di base $|k\\rangle$.\n", "* Codifica angolare, che imposta ogni numero dei dati come angolo di rotazione in un circuito parametrizzato.\n", "\n", "L'approccio migliore dipende dalle caratteristiche specifiche dell'applicazione. Nei computer quantistici attuali, tuttavia, si utilizzano spesso circuiti di codifica angolare come `zz_feature_map`.\n", "\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "cf8b1efc-57b3-4681-8e6a-d5b8406d092d", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit.circuit.library import zz_feature_map\n", "\n", "features = [0.2, 0.4, 0.8]\n", "feature_map = zz_feature_map(feature_dimension=len(features))\n", "\n", "encoded = feature_map.assign_parameters(features)\n", "encoded.draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "031bf004-ca80-4cc0-b153-2cd5cd778386", "metadata": {}, "source": [ "Vedere [Circuiti di codifica dei dati](/docs/api/qiskit/circuit_library#data-encoding-circuits) nella documentazione dell'API della libreria dei circuiti.\n", "\n" ] }, { "cell_type": "markdown", "id": "5c5d2735-ef6a-48db-8382-9dc03c9af20a", "metadata": {}, "source": [ "\n", "\n", "## Circuiti a evoluzione temporale\n", "\n", "Questi circuiti simulano uno stato quantistico che si evolve nel tempo. Utilizzare circuiti ad evoluzione temporale per studiare effetti fisici come il trasferimento di calore o le transizioni di fase in un sistema. I circuiti di evoluzione temporale sono anche un elemento fondamentale delle funzioni d'onda della chimica (come gli stati di prova unitari accoppiati a cluster) e dell'algoritmo QAOA che utilizziamo per i problemi di ottimizzazione.\n", "\n" ] }, { "cell_type": "code", "execution_count": 6, "id": "834794df-86e9-4bea-8efa-5380499e359b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit.circuit.library import PauliEvolutionGate\n", "from qiskit.circuit import QuantumCircuit\n", "from qiskit.quantum_info import SparsePauliOp\n", "\n", "\n", "# Prepare an initial state with a Hadamard on the middle qubit\n", "state = QuantumCircuit(3)\n", "state.h(1)\n", "\n", "hamiltonian = SparsePauliOp([\"ZZI\", \"IZZ\"])\n", "evolution = PauliEvolutionGate(hamiltonian, time=1)\n", "\n", "# Evolve state by appending the evolution gate\n", "state.compose(evolution, inplace=True)\n", "\n", "state.draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "e2dad12f-535a-4f42-8ac4-dbfcfb5533cc", "metadata": {}, "source": [ "Leggi il [`PauliEvolutionGate` Documentazione API](/docs/api/qiskit/qiskit.circuit.library.PauliEvolutionGate).\n", "\n" ] }, { "cell_type": "markdown", "id": "0cf7122d-c3fe-41a6-936c-b3770b33f0f1", "metadata": {}, "source": [ "\n", "\n", "## Circuiti di benchmarking e teoria della complessità\n", "\n", "I circuiti di benchmarking ci danno un'idea di quanto funzioni effettivamente il nostro hardware, mentre i circuiti della teoria della complessità ci aiutano a capire quanto siano difficili i problemi che vogliamo risolvere.\n", "\n", "Ad esempio, il benchmark \"quantum volume\" misura la precisione con cui un computer quantistico esegue un tipo di circuito quantistico casuale. Il punteggio del computer quantistico aumenta con la dimensione del circuito che può eseguire in modo affidabile. Ciò tiene conto di tutti gli aspetti del computer, compresi il numero di qubit, la fedeltà delle istruzioni, la connettività dei qubit e lo stack software che trasporta e postelabora i risultati. Per saperne di più sul volume quantistico, leggi l' [articolo originale sul volume quantistico](https://arxiv.org/abs/1811.12926).\n", "\n", "Il codice seguente mostra un esempio di circuito a volume quantistico costruito in Qiskit che funziona su quattro qubit (i blocchi `unitary` sono porte randomizzate a due qubit).\n", "\n" ] }, { "cell_type": "code", "execution_count": 7, "id": "9629a507-8191-409e-b895-fd0833c8fcd7", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit.circuit.library import quantum_volume\n", "\n", "quantum_volume(4).draw(\"mpl\")" ] }, { "attachments": {}, "cell_type": "markdown", "id": "908e4b4a-5edf-4390-82a0-e755050c2a37", "metadata": {}, "source": [ "La libreria di circuiti comprende anche circuiti ritenuti difficili da simulare in modo classico, come i circuiti polinomiali quantistici istantanei (iqp). Questi circuiti inseriscono alcune porte diagonali (nella base computazionale) tra blocchi di porte Hadamard.\n", "\n", "Altri circuiti includono `grover_operator` per l'utilizzo dell'algoritmo di Grover e il circuito `fourier_checking` per il problema della verifica di Fourier. Vedere questi circuiti in [Circuiti quantistici particolari](/docs/api/qiskit/circuit_library#particular-quantum-circuits) nella documentazione dell'API della libreria dei circuiti.\n", "\n" ] }, { "cell_type": "markdown", "id": "58b1a7b8-c173-4de8-957a-ca5d58332073", "metadata": {}, "source": [ "\n", "\n", "## Circuiti aritmetici\n", "\n", "Le operazioni aritmetiche sono funzioni classiche, come l'addizione di numeri interi e le operazioni bit-wise. Questi possono essere utili in algoritmi come la stima dell'ampiezza per applicazioni finanziarie e in algoritmi come l'algoritmo HHL, che risolve sistemi di equazioni lineari.\n", "\n", "A titolo di esempio, proviamo a sommare due numeri a tre bit utilizzando un circuito \"ripple-carry\" per eseguire l'addizione in-place (`FullAdderGate`). Questo adder somma due numeri (che chiameremo \"A\" e \"B\") e scrive il risultato nel registro che conteneva B. Nell'esempio seguente, A=2 e B=3.\n", "\n" ] }, { "cell_type": "code", "execution_count": 8, "id": "77555a5a-a81c-47b8-a9ae-3015d84adcf5", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit.circuit.library import FullAdderGate\n", "from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister\n", "\n", "adder = FullAdderGate(3) # Adder of 3-bit numbers\n", "\n", "# Create the number A=2\n", "reg_a = QuantumRegister(3, \"a\")\n", "number_a = QuantumCircuit(reg_a)\n", "number_a.initialize(2) # Number 2; |010>\n", "\n", "# Create the number B=3\n", "reg_b = QuantumRegister(3, \"b\")\n", "number_b = QuantumCircuit(reg_b)\n", "number_b.initialize(3) # Number 3; |011>\n", "\n", "# Create a circuit to hold everything, including a classical register for\n", "# the result\n", "qregs = [\n", " QuantumRegister(1, \"cin\"),\n", " QuantumRegister(3, \"a\"),\n", " QuantumRegister(3, \"b\"),\n", " QuantumRegister(1, \"cout\"),\n", "]\n", "reg_result = ClassicalRegister(3)\n", "circuit = QuantumCircuit(*qregs, reg_result)\n", "\n", "# Compose number initializers with the adder. Adder stores the result to\n", "# register B, so we'll measure those qubits.\n", "circuit = (\n", " circuit.compose(number_a, qubits=reg_a)\n", " .compose(number_b, qubits=reg_b)\n", " .compose(adder)\n", ")\n", "circuit.measure(reg_b, reg_result)\n", "circuit.draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "e8a8deee-ad46-42cd-844e-51d5541c3f65", "metadata": {}, "source": [ "La simulazione del circuito mostra che esso emette `5` per tutti gli scatti di `1024` (cioè è misurato con probabilità `1.0`).\n", "\n" ] }, { "cell_type": "code", "execution_count": 9, "id": "ede21ca4-0358-4c83-9af5-63a1c67ae3cb", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Count data:\n", " {5: 1024}\n" ] } ], "source": [ "from qiskit.primitives import StatevectorSampler\n", "\n", "result = StatevectorSampler().run([circuit]).result()\n", "\n", "print(f\"Count data:\\n {result[0].data.c0.get_int_counts()}\")" ] }, { "cell_type": "markdown", "id": "cbd99d49-eb5c-4cd5-bac2-528497b8405e", "metadata": {}, "source": [ "Vedere [Aritmetica](/docs/api/qiskit/circuit_library#arithmetic) nella documentazione dell'API della libreria dei circuiti.\n", "\n" ] }, { "cell_type": "markdown", "id": "9a900a84-c52f-4a03-b3e9-87c71fa93e88", "metadata": {}, "source": [ "\n", "\n", "## Passi successivi\n", "\n", "\n", " * Scopri i metodi avanzati per la creazione di circuiti nell'argomento \"[Circuiti in Construct](/docs/guides/construct-circuits) \".\n", " * Un esempio di circuiti utilizzati nel tutorial sull' [algoritmo di Grover](/docs/tutorials/grovers-algorithm).\n", " * Esaminare il riferimento [API della libreria dei circuiti](/docs/api/qiskit/circuit_library).\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": 5 }