{ "cells": [ { "cell_type": "markdown", "id": "bc54d7bc-b2d8-4b30-9b0b-05689e07a463", "metadata": {}, "source": [ "---\n", "title: \"Costruire circuiti\"\n", "description: \"Come costruire e visualizzare circuiti quantistici in Qiskit.\"\n", "---\n", "\n", "\n", "\n", "# Costruire circuiti\n", "\n" ] }, { "cell_type": "markdown", "id": "e11dd8ad-7edc-4cf8-bc13-388fe04e84fa", "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" ] }, { "cell_type": "markdown", "id": "c50d8e43-ae82-4e41-8d17-a37332d1bf6d", "metadata": {}, "source": [ "Questa pagina analizza più da vicino la classe [`QuantumCircuit`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit) nell'SDK Qiskit, compresi alcuni metodi più avanzati che si possono utilizzare per creare circuiti quantistici.\n", "\n" ] }, { "cell_type": "markdown", "id": "2664d407-aa95-43a3-9101-d3ad58c2df58", "metadata": {}, "source": [ "\n", "\n", "## Che cos'è un circuito quantistico?\n", "\n", "Un semplice circuito quantistico è un insieme di qubit e un elenco di istruzioni che agiscono su tali qubit. A titolo dimostrativo, la cella seguente crea un nuovo circuito con due nuovi qubit, quindi visualizza l'attributo [`qubits`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#qubits) del circuito, che è un elenco di [`Qubits`](/docs/api/qiskit/circuit#qiskit.circuit.Qubit) in ordine dal bit meno significativo $q_0$ al bit più significativo $q_n$.\n", "\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "b410d397-b67d-4f31-90cf-9c1c34c157c5", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[, ]" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit import QuantumCircuit\n", "\n", "qc = QuantumCircuit(2)\n", "qc.qubits" ] }, { "cell_type": "markdown", "id": "392e3d6c", "metadata": {}, "source": [ "È possibile combinare più oggetti `QuantumRegister` e `ClassicalRegister` per creare un circuito. Ogni [`QuantumRegister`](/docs/api/qiskit/circuit#qiskit.circuit.QuantumRegister) e [`ClassicalRegister`](/docs/api/qiskit/circuit#qiskit.circuit.ClassicalRegister) possono anche essere nominati.\n", "\n" ] }, { "cell_type": "code", "execution_count": 2, "id": "6160e3f7", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[,\n", " ,\n", " ]" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit.circuit import QuantumRegister, ClassicalRegister\n", "\n", "qr1 = QuantumRegister(2, \"qreg1\") # Create a QuantumRegister with 2 qubits\n", "qr2 = QuantumRegister(1, \"qreg2\") # Create a QuantumRegister with 1 qubit\n", "cr1 = ClassicalRegister(3, \"creg1\") # Create a ClassicalRegister with 3 cbits\n", "\n", "combined_circ = QuantumCircuit(\n", " qr1, qr2, cr1\n", ") # Create a quantum circuit with 2 QuantumRegisters and 1 ClassicalRegister\n", "combined_circ.qubits" ] }, { "cell_type": "markdown", "id": "6e7b212f", "metadata": {}, "source": [ "È possibile trovare l'indice e il registro di un qubit utilizzando il metodo del circuito e i suoi attributi [`find_bit`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#qiskit.circuit.QuantumCircuit.find_bit) e i suoi attributi.\n", "\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "faeb3fbc", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Index: 2\n", "Register: [(QuantumRegister(1, 'qreg2'), 0)]\n" ] } ], "source": [ "desired_qubit = qr2[0] # Qubit 0 of register 'qreg2'\n", "\n", "print(\"Index:\", combined_circ.find_bit(desired_qubit).index)\n", "print(\"Register:\", combined_circ.find_bit(desired_qubit).registers)" ] }, { "cell_type": "markdown", "id": "f5c95cb2-a94f-48f3-b2a6-8ec6c25da5cd", "metadata": {}, "source": [ "L'aggiunta di un'istruzione al circuito aggiunge l'istruzione all'attributo del circuito [`data`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#data) del circuito. L'output della cella seguente mostra che `data` è un elenco di oggetti [`CircuitInstruction`](/docs/api/qiskit/qiskit.circuit.CircuitInstruction) oggetti, ognuno dei quali ha un attributo `operation` e un attributo `qubits` .\n", "\n" ] }, { "cell_type": "code", "execution_count": 4, "id": "f7b5573c-b2b2-4cbf-ba55-c53c9221ce71", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[CircuitInstruction(operation=Instruction(name='x', num_qubits=1, num_clbits=0, params=[]), qubits=(,), clbits=())]" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "qc.x(0) # Add X-gate to qubit 0\n", "qc.data" ] }, { "cell_type": "markdown", "id": "17a82d8a-b717-44b8-b3f8-ce89e2588261", "metadata": {}, "source": [ "Il modo più semplice per visualizzare queste informazioni è tramite il [`draw`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#draw) metodo, che restituisce una rappresentazione grafica del circuito. Vedi [la sezione \"Visualizzazione dei circuiti\"](/docs/guides/visualize-circuits) per scoprire diversi modi di rappresentare i circuiti quantistici.\n", "\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "43a57258-3e33-4071-8a48-2bf127c8a5be", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "qc.draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "ab5f4bc9-7d7c-4ee7-b1bc-70a313b4fe29", "metadata": {}, "source": [ "Gli oggetti istruzione possono contenere circuiti di \"definizione\" che descrivono l'istruzione in termini di istruzioni più fondamentali. Ad esempio, la [porta X](/docs/api/qiskit/qiskit.circuit.library.XGate) è definita come un caso specifico della [U3-gate](/docs/api/qiskit/qiskit.circuit.library.U3Gate), una porta a singolo qubit più generale.\n", "\n" ] }, { "cell_type": "code", "execution_count": 6, "id": "653e2427-e301-4d2f-84de-1959185ace8e", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Draw definition circuit of 0th instruction in `qc`\n", "qc.data[0].operation.definition.draw(\"mpl\")" ] }, { "attachments": {}, "cell_type": "markdown", "id": "ee893af1-db43-449f-bfc4-8f636bd98546", "metadata": {}, "source": [ "Istruzioni e circuiti sono simili in quanto entrambi descrivono operazioni su bit e qubit, ma hanno scopi diversi:\n", "\n", "* Le istruzioni sono trattate come fisse e i loro metodi di solito restituiscono nuove istruzioni (senza mutare l'oggetto originale).\n", "* I circuiti sono progettati per essere costruiti su molte righe di codice e i metodi [`QuantumCircuit`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit) spesso i metodi modificano l'oggetto esistente.\n", "\n" ] }, { "cell_type": "markdown", "id": "2e451022", "metadata": {}, "source": [ "\n", "\n", "### Che cos'è la profondità del circuito?\n", "\n", "La [profondità()](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#qiskit.circuit.QuantumCircuit.depth) di un circuito quantistico è una misura del numero di \"strati\" di porte quantistiche, eseguite in parallelo, necessarie per completare la computazione definita dal circuito. Poiché le porte quantistiche richiedono tempo per essere implementate, la profondità di un circuito corrisponde approssimativamente alla quantità di tempo che il computer quantistico impiega per eseguire il circuito. Pertanto, la profondità di un circuito è una grandezza importante utilizzata per misurare se un circuito quantistico può essere eseguito su un dispositivo.\n", "\n", "Il resto di questa pagina illustra come manipolare i circuiti quantistici.\n", "\n" ] }, { "cell_type": "markdown", "id": "ff4f08f3-48eb-454c-9647-2af505bf79bc", "metadata": {}, "source": [ "\n", "\n", "## Costruire circuiti\n", "\n", "Metodi come [`QuantumCircuit.h`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#h) e [`QuantumCircuit.cx`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#cx) aggiungono istruzioni specifiche ai circuiti. Per aggiungere istruzioni a un circuito più in generale, utilizzare il metodo [`append`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#append) metodo. Questo prende un'istruzione e un elenco di qubit a cui applicare l'istruzione. Per un elenco delle istruzioni supportate, consultare la [documentazione dell'API della libreria Circuit](/docs/api/qiskit/circuit_library).\n", "\n" ] }, { "cell_type": "code", "execution_count": 7, "id": "66813cae-9841-47ea-96b7-8fd7b82e9759", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit.circuit.library import HGate\n", "\n", "qc = QuantumCircuit(1)\n", "qc.append(\n", " HGate(), # New HGate instruction\n", " [0], # Apply to qubit 0\n", ")\n", "qc.draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "bbdbef08-07c0-4fb0-ab3e-ed6efb7a3dc3", "metadata": {}, "source": [ "Per combinare due circuiti, utilizzare il metodo [`compose`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#compose) metodo. Accetta un altro [`QuantumCircuit`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit) e un elenco opzionale di mappature di qubit.\n", "\n", "\n", " Il metodo [`compose`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#compose) restituisce un nuovo circuito e **non** modifica nessuno dei circuiti su cui agisce. Per mutare il circuito su cui si sta chiamando il metodo [`compose`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#compose) utilizzare l'argomento `inplace=True`.\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 8, "id": "29152dfa-2275-4bc4-aadb-82185b9e0e86", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "qc_a = QuantumCircuit(4)\n", "qc_a.x(0)\n", "\n", "qc_b = QuantumCircuit(2, name=\"qc_b\")\n", "qc_b.y(0)\n", "qc_b.z(1)\n", "\n", "# compose qubits (0, 1) of qc_a to qubits (1, 3) of qc_b respectively\n", "combined = qc_a.compose(qc_b, qubits=[1, 3])\n", "combined.draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "d4529506-8397-4208-9cfd-31e1a1978741", "metadata": {}, "source": [ "Si potrebbe anche decidere di raggruppare i circuiti in istruzioni per tenerli organizzati. È possibile convertire un circuito in un'istruzione utilizzando il metodo [`to_instruction`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#to_instruction) e poi aggiungerlo a un altro circuito come si farebbe con qualsiasi altra istruzione. Il circuito disegnato nella cella seguente è funzionalmente equivalente al circuito disegnato nella cella precedente.\n", "\n" ] }, { "cell_type": "code", "execution_count": 9, "id": "81b682dd-45cb-4492-809e-d9e8ebbf5600", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "inst = qc_b.to_instruction()\n", "qc_a.append(inst, [1, 3])\n", "qc_a.draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "6e81c46b-a2d2-430e-9d3d-73e5030e3548", "metadata": {}, "source": [ "Se il circuito è unitario, è possibile convertirlo in un circuito [`Gate`](/docs/api/qiskit/qiskit.circuit.Gate) utilizzando il metodo [`to_gate`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#to_gate) metodo. [`Gate`](/docs/api/qiskit/qiskit.circuit.Gate) gli oggetti sono tipi specifici di istruzioni che hanno alcune caratteristiche in più, come il metodo [`control`](/docs/api/qiskit/qiskit.circuit.Gate#control) che aggiunge un controllo quantistico.\n", "\n" ] }, { "cell_type": "code", "execution_count": 10, "id": "ed362e64-d6a4-4dfd-a5cf-5e6bdc7a81b5", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "gate = qc_b.to_gate().control()\n", "qc_a.append(gate, [0, 1, 3])\n", "qc_a.draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "ae850362-84eb-4998-a2cf-a93a1be4ac2a", "metadata": {}, "source": [ "Per vedere cosa succede, si può usare il metodo [`decompose`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#decompose) per espandere ogni istruzione nella sua definizione.\n", "\n", "\n", " Il metodo [`decompose`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#decompose) restituisce un nuovo circuito e **non** modifica il circuito su cui agisce.\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 11, "id": "3c0633db-929b-4428-a888-7a3d493bd6dd", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "qc_a.decompose().draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "87f1e053", "metadata": {}, "source": [ "\n", "\n", "\n", "\n", "## Misurare i qubit\n", "\n", "Le misurazioni vengono utilizzate per rilevare lo stato dei singoli qubit e trasferire i risultati a un registro classico. Si noti che, se si inviano circuiti a una primitiva [Sampler](/docs/guides/get-started-with-sampler), è necessario specificare le misure. Tuttavia, i circuiti inviati a una primitiva [Estimator](/docs/guides/get-started-with-estimator) non devono contenere misure.\n", "\n", "I qubit possono essere misurati utilizzando tre metodi: [`measure`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#qiskit.circuit.QuantumCircuit.measure), [`measure_all`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#measure_all) e [`measure_active`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#measure_active). Per sapere come visualizzare i risultati delle misurazioni, consulta la pagina [Visualizza risultati](/docs/guides/visualize-results).\n", "\n", "1. `QuantumCircuit.measure` : misura ogni qubit del primo argomento sul bit classico dato come secondo argomento. Questo metodo consente di controllare completamente la posizione in cui viene memorizzato il risultato della misurazione.\n", "\n", "2. `QuantumCircuit.measure_all` : non richiede argomenti e può essere utilizzato per circuiti quantistici senza bit classici predefiniti. Crea fili classici e memorizza i risultati delle misure in ordine. Ad esempio, la misura del qubit $q_i$ viene memorizzata nel cbit $meas_i$ ). Aggiunge anche una barriera prima della misurazione.\n", "\n", "3. `QuantumCircuit.measure_active` : simile a `measure_all`, ma misura solo i qubit che hanno operazioni.\n", "\n" ] }, { "cell_type": "code", "execution_count": 12, "id": "0cdb2273", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "qc1 = QuantumCircuit(2, 2)\n", "qc1.measure(0, 1)\n", "qc1.draw(\"mpl\", cregbundle=False)" ] }, { "cell_type": "code", "execution_count": 13, "id": "6f33698c", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "qc2 = QuantumCircuit(2)\n", "qc2.measure_all()\n", "qc2.draw(\"mpl\", cregbundle=False)" ] }, { "cell_type": "code", "execution_count": 14, "id": "ca3f225f", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "qc3 = QuantumCircuit(2)\n", "qc3.x(1)\n", "qc3.measure_active()\n", "qc3.draw(\"mpl\", cregbundle=False)" ] }, { "cell_type": "markdown", "id": "649fc3fd-caf1-45f1-ad8e-3b5d26ca859b", "metadata": {}, "source": [ "\n", "\n", "## Circuiti parametrizzati\n", "\n", "Molti algoritmi quantistici a breve termine prevedono l'esecuzione di molte varianti di un circuito quantistico. Poiché la costruzione e l'ottimizzazione di circuiti di grandi dimensioni può essere computazionalmente costosa, Qiskit supporta circuiti **parametrizzati**. Questi circuiti hanno parametri indefiniti, i cui valori devono essere definiti solo poco prima dell'esecuzione del circuito. Ciò consente di spostare la costruzione e l'ottimizzazione dei circuiti fuori dal ciclo principale del programma. La cella seguente crea e visualizza un circuito parametrizzato.\n", "\n" ] }, { "cell_type": "code", "execution_count": 15, "id": "a580552c-d585-4047-99f0-32aafd06e4f3", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit.transpiler import generate_preset_pass_manager\n", "from qiskit.circuit import Parameter\n", "\n", "angle = Parameter(\"angle\") # undefined number\n", "\n", "# Create and optimize circuit once\n", "qc = QuantumCircuit(1)\n", "qc.rx(angle, 0)\n", "qc = generate_preset_pass_manager(\n", " optimization_level=3, basis_gates=[\"u\", \"cx\"]\n", ").run(qc)\n", "\n", "qc.draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "a174600b-8f4a-47ca-aa4c-cd16dcbecb7c", "metadata": {}, "source": [ "La cella seguente crea molte varianti di questo circuito e mostra una delle varianti.\n", "\n" ] }, { "cell_type": "code", "execution_count": 16, "id": "85af6231-921a-4130-99d3-f6998f761df8", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "circuits = []\n", "for value in range(100):\n", " circuits.append(qc.assign_parameters({angle: value}))\n", "\n", "circuits[0].draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "ede2ff7c-5e68-4458-87b3-887b5b027ee1", "metadata": {}, "source": [ "L'elenco dei parametri non definiti di un circuito si trova nell'attributo `parameters` .\n", "\n" ] }, { "cell_type": "code", "execution_count": 17, "id": "0990b840-f8c4-4416-b2b5-9861173a9471", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "ParameterView([Parameter(angle)])" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "qc.parameters" ] }, { "cell_type": "markdown", "id": "8e415c37", "metadata": {}, "source": [ "\n", "\n", "### Modifica il nome di un parametro\n", "\n", "Per impostazione predefinita, i nomi dei parametri per un circuito parametrizzato sono preceduti dal prefisso `x`-, `x[0]` ad esempio. È possibile modificare i nomi dopo averli definiti, come mostrato nell'esempio seguente.\n", "\n" ] }, { "cell_type": "code", "execution_count": 18, "id": "1d3e6424", "metadata": {}, "outputs": [], "source": [ "from qiskit.circuit.library import z_feature_map\n", "from qiskit.circuit import ParameterVector\n", "\n", "# Define a parameterized circuit with default names\n", "# For example, x[0]\n", "circuit = z_feature_map(2)\n", "\n", "# Set new parameter names\n", "# They will now be prefixed by `hi` instead\n", "# For example, hi[0]\n", "training_params = ParameterVector(\"hi\", 2)\n", "\n", "# Assign parameter names to the quantum circuit\n", "circuit = circuit.assign_parameters(parameters=training_params)" ] }, { "cell_type": "markdown", "id": "5af44bc3", "metadata": {}, "source": [ "\n", "\n", "## Passi successivi\n", "\n", "\n", " * Per conoscere gli algoritmi quantistici a breve termine, seguite il corso di [progettazione di algoritmi variazionali](/learning/courses/variational-algorithm-design).\n", " * Un esempio di circuiti utilizzati nel tutorial sull' [algoritmo di Grover](/docs/tutorials/grovers-algorithm).\n", " * Lavorare con semplici circuiti utilizzando [IBM Quantum Composer](/docs/guides/composer).\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 }