{
"cells": [
{
"cell_type": "markdown",
"id": "4046fd82",
"metadata": {},
"source": [
"---\n",
"title: \"Sovrapposizione con Qiskit\"\n",
"description: \"Scopri cos'è la sovrapposizione e cosa significa per le misurazioni sui computer quantistici.\"\n",
"---\n",
"\n",
"{/* cspell:ignore nflips fliplist qcoin squareroot qnot qsqrtnot qphase qhadamard */}\n",
"\n",
"\n",
"\n",
"# Quantum Coins — un modulo sulla sovrapposizione e l'interferenza\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "bc3346f6",
"metadata": {},
"source": [
"Per questo modulo Qiskit in Classrooms, gli studenti devono avere un ambiente Python funzionante con i seguenti pacchetti installati:\n",
"\n",
"* `qiskit` v2.1.0 o più recente\n",
"* `qiskit-ibm-runtime` v0.40.1 o più recente\n",
"* `qiskit-aer` v0.17.0 o più recente\n",
"* `qiskit.visualization`\n",
"* `numpy`\n",
"* `pylatexenc`\n",
"\n",
"Per configurare e installare i pacchetti di cui sopra, consultare la guida [Installare Qiskit](/docs/guides/install-qiskit).\n",
"Per poter eseguire lavori su veri computer quantistici, gli studenti dovranno creare un account con IBM Quantum® seguendo i passaggi della guida [Set up your IBM Cloud account](/docs/guides/cloud-setup).\n",
"\n",
"Questo modulo è stato testato e ha utilizzato 47 secondi di tempo della QPU. Si tratta solo di una stima. L'utilizzo effettivo può variare.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3cf87503",
"metadata": {},
"outputs": [],
"source": [
"# Uncomment and modify this line as needed to install dependencies\n",
"#!pip install 'qiskit>=2.1.0' 'qiskit-ibm-runtime>=0.40.1' 'qiskit-aer>=0.17.0' 'numpy' 'pylatexenc'"
]
},
{
"cell_type": "markdown",
"id": "fba0059c-4008-4076-95f2-18dab949ca9e",
"metadata": {},
"source": [
"Guardate la spiegazione del modulo da parte della dottoressa Katie McCormick qui sotto, oppure fate clic [qui](https://www.youtube.com/watch?v=TZ-sUHK8vVQ\\&list=PLOFEBzvs-Vvrs2fuvsuT039ariYPsua3d\\&index=6) per guardarla su YouTube.\n",
"\n",
"***\n",
"\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "8ef56d8f-1358-4c3e-b1be-f56597a5ee89",
"metadata": {
"jp-MarkdownHeadingCollapsed": true
},
"source": [
"\n",
"\n",
"## Introduzione\n",
"\n",
"In questo modulo esploreremo uno dei principi fondamentali della teoria quantistica: la superposizione. Nella nostra esperienza quotidiana, gli oggetti hanno sempre caratteristiche definite. La loro posizione, le dimensioni, la forma, il colore - tutto ciò che li riguarda - è determinato e certo, anche se noi osservatori non li abbiamo ancora misurati. Nel mondo quantistico, questo non è necessariamente il caso. Un oggetto quantistico può trovarsi in una cosiddetta \"sovrapposizione\" di più stati classicamente consentiti. Quando la sovrapposizione viene misurata, \"collassa\" casualmente in uno di questi stati.\n",
"\n",
"Per certi versi, misurare uno stato di sovrapposizione è come lanciare una moneta: non c’è modo di sapere in anticipo da che parte cadrà. Questo indeterminismo fondamentale è un aspetto sconcertante della meccanica quantistica che ha messo in difficoltà persino Einstein. A proposito di questa casualità, disse la famosa frase: «Dio non gioca a dadi». Ma, come vedremo, Dio in realtà gioca davvero a dadi… e lancia la moneta.\n",
"\n",
"Penseremo al classico lancio di una moneta come analogia alla misurazione di uno stato di sovrapposizione. E - giocando con una \"moneta quantistica\" usando Qiskit e un qubit su un processore quantistico IBM® - scopriremo rapidamente i limiti di questa analogia.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "bcf4cb9b-7e3a-49f0-9d0d-756fb42eaae3",
"metadata": {},
"source": [
"\n",
"\n",
"### Moneta classica\n",
"\n",
"Cominciamo con una moneta classica. Lanciando una moneta, si otterrà il testa in su o il testa in giù, con il 50 $~$ % di probabilità di ciascuno. Mentre in *linea di principio* si potrebbe calcolare da che parte atterrerà la moneta se si conoscessero le precise condizioni iniziali della moneta e la forza/coppia del lancio, in *pratica* non c'è modo di sapere a priori da che parte atterrerà la moneta. Ecco perché usiamo il lancio di una moneta come esempio canonico di uno *stato probabilistico classico*, in cui il risultato è essenzialmente casuale. Possiamo scrivere lo stato della moneta prima che atterri per riflettere questa probabilità del 50/50:\n",
"\n",
"$$\n",
"S(coin) = \\frac{1}{2}|up\\rangle + \\frac{1}{2}|down\\rangle\n",
"$$\n",
"\n",
"In questo caso, i due termini rappresentano i due possibili risultati del flip e i loro coefficienti rappresentano le probabilità di ciascuno dei risultati. Si noti che in genere il termine \" $|\\rangle$ \" (noto come \"ket\") viene utilizzato per rappresentare uno stato quantistico, ma qui stiamo parlando di uno stato probabilistico *classico*. Per saperne di più sul modo in cui rappresentiamo le informazioni classiche e quantistiche, si veda la [Lezione 1: Sistemi singoli](/learning/courses/basics-of-quantum-information/single-systems/introduction) del corso Fondamenti dell'informazione quantistica.\n",
"\n",
"Se dovessimo lanciare una moneta 1000 volte e registrare il numero di teste in alto e in basso, otterremmo qualcosa di simile:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "f302ea9f-12af-4950-bce3-7416c163272b",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# import necessary packages:\n",
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"import random\n",
"\n",
"\n",
"nflips = 1000\n",
"fliplist = [random.randint(0, 1) for f in range(nflips)]\n",
"\n",
"\n",
"# bar plots using get_gaussian_probs function\n",
"plt.hist(fliplist)\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "6f2bc32b-cb77-40fc-849a-e1b9de46b813",
"metadata": {},
"source": [
"\n",
"\n",
"### Moneta quantistica\n",
"\n",
"Possiamo creare uno stato probabilistico simile utilizzando un qubit sul nostro computer quantistico. Come il lancio della moneta, anche un qubit può essere misurato in due possibili stati: $|0\\rangle$ e $|1\\rangle$. Creiamo lo stato di \"sovrapposizione\" probabilistica partendo dallo stato $|0\\rangle$ e applicando poi al qubit una cosa chiamata porta di Hadamard. In questo modo si trova in una sovrapposizione uguale di $|0\\rangle$ e $|1\\rangle$. Si noti che mentre questo stato di sovrapposizione può sembrare e comportarsi come la moneta a prima vista, vedremo presto che c'è molto di più. Lo scopo di questo modulo è quello di mostrare che una sovrapposizione non è la stessa cosa di un classico lancio di monete.\n",
"\n",
"Quindi, poiché il qubit è in una sovrapposizione uguale di 0 e 1, quando misuriamo il qubit, ci sarà il 50% di probabilità di misurare $|0\\rangle$, il 50% di probabilità di misurare $|1\\rangle$. Scriviamo questo stato in modo un po' diverso dal caso probabilistico classico, per ragioni che saranno chiare in seguito:\n",
"\n",
"$$\n",
"|\\psi\\rangle = \\frac{1}{\\sqrt{2}} |0\\rangle + \\frac{1}{\\sqrt{2}} |1\\rangle\n",
"$$\n",
"\n",
"In questo caso, le probabilità di misurare ciascuno dei due stati **non sono più** uguali ai coefficienti, come nel caso dello stato probabilistico classico di cui sopra. Invece, è il **quadrato** dei coefficienti che ci dà le probabilità, e ognuno di questi coefficienti può ora essere complesso, cioè può avere sia parti reali che immaginarie.\n",
"\n",
"Nonostante queste differenze, però, il risultato della misurazione di questo stato è essenzialmente lo stesso del lancio di una moneta.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "57f4c8c7-5524-4fcb-a37f-60a2c10bfa9b",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit import QuantumCircuit\n",
"\n",
"qcoin = QuantumCircuit(1)\n",
"qcoin.h(0)\n",
"qcoin.measure_all()\n",
"\n",
"qcoin.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "286f964c-08fb-4df7-be8c-b3c6eebdf8da",
"metadata": {},
"source": [
"Quindi, in pratica, applicare la porta di Hadamard equivale a lanciare una moneta. E proprio come abbiamo lanciato la moneta 1000 volte per analizzare le statistiche relative all'esito del lancio (testa o croce), possiamo fare qualcosa di simile su Qiskit con la nostra “moneta quantistica” Possiamo utilizzare una primitiva denominata `Sampler`, che ripeterà un circuito più volte per ricavare le statistiche dello stato risultante.\n",
"\n",
"Per prima cosa, carichiamo il servizio di calcolo \" IBM Quantum \" e le primitive, quindi selezioniamo un backend su cui eseguire il circuito.\n",
"\n",
"Di seguito è riportato un codice per salvare le credenziali al primo utilizzo. Assicurarsi di eliminare queste informazioni dal blocco note dopo averlo salvato nel proprio ambiente, in modo che le credenziali non vengano accidentalmente condivise quando si condivide il blocco note. Per ulteriori informazioni, vedere [Configurazione dell'account IBM Cloud](/docs/guides/initialize-account) e [Inizializzazione del servizio in un ambiente non attendibile](/docs/guides/cloud-setup-untrusted).\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3afaafe6",
"metadata": {},
"outputs": [],
"source": [
"# Load IBM Quantum Compute Service\n",
"from qiskit_ibm_runtime import QiskitRuntimeService\n",
"\n",
"# Syntax for first saving your token. Delete these lines after saving your credentials.\n",
"# QiskitRuntimeService.save_account(channel='ibm_quantum_platform',\n",
"# instance = '', token='', overwrite=True, set_as_default=True)\n",
"# service = QiskitRuntimeService(channel='ibm_quantum_platform')\n",
"\n",
"# Load saved credentials\n",
"service = QiskitRuntimeService()"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "47c48517-5b27-47df-9ea8-18459d4bf720",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"ibm_kingston\n"
]
}
],
"source": [
"# Load the Runtime primitive and session\n",
"from qiskit_ibm_runtime import (\n",
" SamplerV2 as Sampler,\n",
" EstimatorV2 as Estimator,\n",
")\n",
"\n",
"# Use the least busy backend\n",
"backend = service.least_busy()\n",
"print(backend.name)"
]
},
{
"cell_type": "markdown",
"id": "a2e39d00-db68-46cb-b4af-7b2559955313",
"metadata": {},
"source": [
"Se non avete più tempo a disposizione sul vostro conto, potete anche scegliere di eseguire questa operazione su un simulatore. È sufficiente decommentare il codice ed eseguire la cella sottostante per farlo:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "f85953c3-d67d-4c84-b078-80669e51f9ca",
"metadata": {},
"outputs": [],
"source": [
"## Use a local simulator\n",
"\n",
"# from qiskit_aer import AerSimulator\n",
"\n",
"## Generate a simulator that mimics the real quantum system\n",
"\n",
"# backend_sim = AerSimulator.from_backend(backend)\n",
"\n",
"## Import an estimator, this time from qiskit (we will import from Runtime for real hardware)\n",
"\n",
"# from qiskit.primitives import BackendSamplerV2\n",
"# sampler_sim = BackendSamplerV2(backend = backend_sim)\n",
"# from qiskit.primitives import BackendEstimatorV2\n",
"# estimator_sim = BackendEstimatorV2(backend = backend_sim)"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "634fb53f-944c-4c2c-9e98-357acd0281aa",
"metadata": {},
"outputs": [],
"source": [
"## Transpile\n",
"from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n",
"\n",
"target = backend.target\n",
"pm = generate_preset_pass_manager(target=target, optimization_level=3)\n",
"\n",
"qc_isa = pm.run(qcoin)"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "e7930b08-d235-4c16-8af4-1d258dd80300",
"metadata": {},
"outputs": [],
"source": [
"## Execute\n",
"\n",
"# On real hardware:\n",
"sampler = Sampler(mode=backend)\n",
"pubs = [qc_isa]\n",
"job = sampler.run(pubs, shots=1000)\n",
"res = job.result()\n",
"\n",
"counts = res[0].data.meas.get_counts()\n",
"\n",
"# or with Aer simulator with noise model from real backend\n",
"# job = sampler_sim.run([qc_isa])\n",
"# counts=job.result()[0].data.meas.get_counts()"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "e3b16bd7-276f-4dca-b56e-3dd88bb17b68",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"## Analysis\n",
"from qiskit.visualization import plot_histogram\n",
"\n",
"plot_histogram(counts)"
]
},
{
"cell_type": "markdown",
"id": "61743091-7f5b-4660-875c-6ddf7b61d0ab",
"metadata": {},
"source": [
"Con 1000 campioni del circuito di cui sopra, abbiamo qualcosa che appare fondamentalmente identico all'istogramma classico delle monete, fino a qualche fluttuazione statistica.\n",
"\n",
"Oltre a campionare le statistiche della moneta quantistica, possiamo anche utilizzare un’altra primitiva denominata `Estimator` per misurare il cosiddetto *valore atteso* di un *osservabile* dello stato. Per illustrare in cosa consiste questo valore atteso, prendiamo come esempio la classica moneta. Supponiamo che tu stia usando la moneta per scommettere: ogni volta che la lanci e esce “testa”, vinci un dollaro. Ma ogni volta che cade con la \"faccia in giù\", perdi un dollaro. Se vuoi sapere quanto denaro ti aspetti di ottenere ad ogni \"flip\" (il valore atteso della variabile osservabile \"denaro\"), dovresti calcolare:\n",
"\n",
"$$\n",
"E(money) = \\frac{1}{2} (+ \\text{1 dollar}) + \\frac{1}{2} (- \\text{1 dollar}) = \\text{0 dollars}\n",
"$$\n",
"\n",
"Poiché la probabilità di vincere un dollaro è uguale a quella di perdere un dollaro, il valore dell'aspettativa è pari a 0 dollari.\n",
"\n",
"Allo stesso modo, con uno stato quantistico, possiamo calcolare il valore di aspettativa dell'osservabile \"Z\", dove Z è la matrice di Pauli con valori +1 e -1 associati agli stati $|0\\rangle$ e $|1\\rangle$, rispettivamente.\n",
"\n",
"$$\n",
"\\langle \\psi|Z|\\psi \\rangle = \\frac{1}{2} \\langle 0 | Z | 0 \\rangle + \\frac{1}{2} \\langle 1 | Z | 1 \\rangle = \\frac{1}{2} (+1) + \\frac{1}{2}(-1) = 0\n",
"$$\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "775d62ec-3f26-4238-a1c5-292a6a606581",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit.quantum_info import Pauli\n",
"\n",
"qcoin = QuantumCircuit(1)\n",
"qcoin.h(0)\n",
"\n",
"# for Estimator, we do not apply the measurement to the circuit"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "25350a19-390d-450c-89f3-2646d5b6b1a7",
"metadata": {},
"outputs": [],
"source": [
"## Transpile\n",
"from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n",
"\n",
"target = backend.target\n",
"pm = generate_preset_pass_manager(target=target, optimization_level=3)\n",
"\n",
"obs = Pauli(\"Z\")\n",
"\n",
"qc_isa = pm.run(qcoin)\n",
"obs_isa = obs.apply_layout(layout=qc_isa.layout)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "47ba8097-c109-4f9f-80a4-44e14ce044a2",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"-0.014799284701239441\n"
]
}
],
"source": [
"## Execute\n",
"\n",
"# On real hardware:\n",
"estimator = Estimator(mode=backend)\n",
"pubs = [(qc_isa, obs_isa)]\n",
"job = estimator.run([[qc_isa, obs_isa]])\n",
"res = job.result()\n",
"\n",
"# On a simulator:\n",
"# job = estimator_sim.run([[qc_isa, obs_isa]])\n",
"# res=job.result()\n",
"\n",
"print(res[0].data.evs)"
]
},
{
"cell_type": "markdown",
"id": "eed36776-de55-40a4-b63e-0aa17f144bff",
"metadata": {},
"source": [
"Otteniamo un valore di aspettativa pari a 0, come previsto (ah). Questo è un altro modo per confermare che effettivamente esiste una probabilità uguale di misurare o 0 e 1, e sembra comportarsi come un lancio di moneta.\n",
"\n",
"A questo punto, la \"moneta quantistica\" appare esattamente come la moneta classica. Ma nella prossima sezione faremo alcuni esperimenti che riveleranno le differenze fondamentali tra i due.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "7d10d957-2e8d-4c63-b4a4-7744b9e1a0e9",
"metadata": {},
"source": [
"\n",
"\n",
"## Il quantum rivelato: un esperimento in tre dimensioni\n",
"\n",
"Facciamo un esperimento mentale: Supponiamo che lanciate una moneta in aria e che, invece di lasciarla cadere a terra, abbiate la coordinazione di battere le mani mentre la moneta passa tra le vostre mani e di incastrarla tra i palmi. Ora, invece di essere testa in alto o in basso, la moneta è testa a sinistra o a destra.\n",
"\n",
"\n",
"\n",
"#### Verifica la tua comprensione\n",
"\n",
"Qual è la probabilità di ciascuno di questi risultati, testa a sinistra o testa a destra?\n",
"\n",
"\n",
" \n",
" La probabilità sarà ancora del 50-50. Non dovrebbe essere importante la dimensione lungo la quale scegliamo di misurare il risultato del lancio della moneta.\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "907ac0e3-12cb-4444-ad2e-0b33189b43e6",
"metadata": {},
"source": [
"Si spera che abbiate risposto che la probabilità di trovare testa a sinistra o a destra è ancora del 50-50. La dimensione lungo la quale viene misurato il lancio della moneta non dovrebbe influenzare la probabilità dei risultati.\n",
"\n",
"Ma come cambierebbero le cose per la nostra moneta quantistica? Controlliamo.\n",
"\n",
"Possiamo creare la nostra sovrapposizione quantistica nello stesso modo in cui l'abbiamo fatto l'ultima volta, con una porta di Hadamard. Per misurare \"testa a destra o a sinistra\" sulla nostra moneta quantistica, possiamo fare ciò che abbiamo fatto con la moneta classica: misurare lungo un asse diverso. Le nostre misure standard sul computer quantistico sono lungo l'asse verticale, proprio come la consueta misura \"testa in su o in giù\" della moneta classica. Ma possiamo anche chiedere alla nostra moneta quantistica se è testa a destra o a sinistra o, equivalentemente, se si trova negli stati $|+\\rangle$ o $|-\\rangle$, che sono orientati lungo l'asse $x$. `Sampler` solo campioni nella base di misura Z, ma possiamo utilizzare `Estimator` per ottenere il valore di aspettativa di X. I valori di X sono +1 e -1 per gli stati $|+\\rangle$ o $|-\\rangle$, rispettivamente.\n",
"\n",
"\n",
"\n",
"#### Verifica la tua comprensione\n",
"\n",
"Se la moneta quantistica si comportasse come la moneta classica in questo caso, avremmo una probabilità del 50-50 di misurare lo stato in $|+\\rangle$ e $|-\\rangle$. Quale valore di aspettativa di X ci aspetteremmo che `Estimator` restituisca, se questo fosse il caso?\n",
"\n",
"\n",
" \n",
" Quando applichiamo X allo stato $|+\\rangle$, otteniamo il valore e +1 e allo stato $|-\\rangle$ otteniamo -1, quindi, se avessimo una distribuzione 50-50, otterremmo un valore di aspettativa pari a 0.\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "2cc7a79f-527c-4af1-a207-06cfa20ac92c",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.9985207100591716\n"
]
}
],
"source": [
"# Step 1: map problem\n",
"\n",
"qcoin_lr = QuantumCircuit(1)\n",
"qcoin_lr.h(0)\n",
"\n",
"obs = Pauli(\"X\")\n",
"\n",
"\n",
"# Step 2: Transpile the circuit\n",
"\n",
"pm = generate_preset_pass_manager(target=target, optimization_level=3)\n",
"qc_isa = pm.run(qcoin_lr)\n",
"obs_isa = obs.apply_layout(layout=qc_isa.layout)\n",
"\n",
"# Step 3: Run the circuit on a real quantum computer\n",
"\n",
"estimator = Estimator(mode=backend)\n",
"pubs = [(qc_isa, obs_isa)]\n",
"job = estimator.run([[qc_isa, obs_isa]])\n",
"res = job.result()\n",
"\n",
"# Run the job on the Aer simulator with noise model from real backend\n",
"# job = estimator_sim.run([[qc_isa,obs_isa]])\n",
"# res=job.result()\n",
"\n",
"# Step 4: Return the result in classical form, and analyze.\n",
"\n",
"print(res[0].data.evs)"
]
},
{
"cell_type": "markdown",
"id": "51f97d72-b152-4527-8e42-c066cec33524",
"metadata": {},
"source": [
"Il valore di aspettativa di X per questo stato è 1. Quindi, **non** c'è una probabilità del 50-50 di misurare $|+\\rangle$ e $|-\\rangle$.\n",
"\n",
"\n",
"\n",
"#### Verifica la tua comprensione\n",
"\n",
"Cosa ci dice questo valore di aspettativa sullo stato $|\\psi\\rangle$? Quali sono le probabilità di misurare $|+\\rangle$ e $|-\\rangle$ in questa base X?\n",
"\n",
"\n",
" \n",
" Poiché il valore di aspettativa è uguale al valore di X per lo stato $|+\\rangle$, ciò significa che abbiamo il 100% di probabilità di misurare lo stato $|+\\rangle$ quando misuriamo lungo X.\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "37b04a99-0256-41f4-8bf5-362b3508ca34",
"metadata": {},
"source": [
"Cosa sta succedendo qui? Sembra che la nostra moneta quantistica possa avere esiti casuali e probabilistici lungo una dimensione, ma perfettamente prevedibili lungo un'altra. Sarebbe come lanciare una moneta e garantire che ogni volta che viene presa, mettendola tra due mani, finisca con la testa rivolta a destra.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "ace0c3e8-e9b7-4fc9-a312-78c0264a171a",
"metadata": {},
"source": [
"\n",
"\n",
"### La fase quantistica\n",
"\n",
"La differenza fondamentale della moneta quantistica è che ha un'altra qualità che la moneta classica non ha. Ricordiamo che in uno stato probabilistico classico,\n",
"\n",
"$$\n",
"S(coin) = c_1|up\\rangle + c_2|down\\rangle\n",
"$$\n",
"\n",
"ogni coefficiente è semplicemente un numero reale positivo che rappresenta la probabilità di misurare un particolare stato. In uno stato quantico,\n",
"\n",
"$$\n",
"|\\psi\\rangle = c_1 |0\\rangle + c_2 |1\\rangle\n",
"$$\n",
"\n",
"i coefficienti sono complessi, quindi contengono una parte reale e una parte immaginaria. Ogni coefficiente $c_i$ può essere espresso come un vettore bidimensionale sul piano complesso, con la grandezza $|c_i|$ e l'angolo $\\phi_i$ che forma con l'asse reale:\n",
"\n",
"$$\n",
"c_i = |c_i| e^{i \\phi_i}.\n",
"$$\n",
"\n",
"\n",
"\n",
"Chiamiamo $\\phi_i$ la fase. La fase ci dice come due termini in uno stato quantistico *interferiranno*, ovvero come si sommeranno o annulleranno come onde. Se due onde sono in fase tra loro, quindi le loro creste e i loro avvallamenti si allineano, si combineranno per formare un'onda di altezza doppia. La chiamiamo interferenza costruttiva. Se sono sfasati, cioè una cresta dell'uno si allinea con una cresta dell'altro e viceversa, interferiscono in modo distruttivo e si annullano completamente a vicenda.\n",
"\n",
"Come le onde, anche gli stati quantistici possono sommarsi in modo costruttivo o distruttivo. Può essere più difficile da vedere perché spesso non si tratta di un'onda reale nello spazio fisico. Nel caso dei nostri qubit, l'interferenza avviene nello spazio informativo astratto dei qubit. Si noti inoltre che, poiché solo la fase *relativa* tra le due onde è importante per il modo in cui interferiranno - cioè la differenza delle fasi $\\Delta \\phi = \\phi_2 - \\phi_1$ dei due coefficienti - in genere applichiamo una *fase globale* di $-\\phi_1$ all'intero stato in modo che $c_1$ sia puramente reale e la *fase relativa* sia interamente catturata in $c_2$.\n",
"\n",
"Per vedere come la fase possa causare interferenze nella nostra moneta quantistica, proviamo ad applicare l'Hadamard due volte invece di una sola. Classicamente, questo non avrebbe alcun senso: se applicare l'Hadamard equivale a lanciare una moneta, allora non si può lanciare una moneta che sta già lanciando. Ma vediamo cosa succede alla moneta quantica:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "610af24c-d489-4239-b31f-cea67a563b69",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qcoin_0 = QuantumCircuit(1)\n",
"qcoin_0.h(0)\n",
"qcoin_0.h(0)\n",
"qcoin_0.measure_all()\n",
"\n",
"qcoin_0.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "6fd8711d-1bef-4706-a5a9-039531af658b",
"metadata": {},
"source": [
"Ora, prima di usare `Sampler` per misurare lo stato risultante, pensiamo a come questo qubit sarà trasformato da ogni gate. Si inizia, come al solito, in $|0\\rangle$. Poi, la prima trasformazione di Hadamard trasforma lo stato nella sovrapposizione, come abbiamo già visto:\n",
"\n",
"$$\n",
"H|0\\rangle = \\frac{1}{\\sqrt{2}} |0\\rangle + \\frac{1}{\\sqrt{2}} |1\\rangle.\n",
"$$\n",
"\n",
"In questo caso, entrambi i coefficienti sono completamente reali e positivi, il che significa che la fase è $\\phi=0$.\n",
"\n",
"Il secondo Hadamard viene quindi applicato separatamente a ciascun pezzo dello stato di sovrapposizione. Sappiamo già come la trasformata di Hadamard trasforma lo stato $|0\\rangle$. Ma che dire di $|1\\rangle$?\n",
"\n",
"$$\n",
"H|1\\rangle = \\frac{1}{\\sqrt{2}} |0\\rangle - \\frac{1}{\\sqrt{2}} |1\\rangle\n",
"$$\n",
"\n",
"Anche in questo caso si tratta di una sovrapposizione uguale di 0 e 1, simile al lancio di una moneta, ma il coefficiente di questo stato davanti a $|1\\rangle$ ha una fase di $\\phi = \\pi$ che gli conferisce il segno negativo.\n",
"\n",
"\n",
"\n",
"#### Verifica la tua comprensione\n",
"\n",
"Calcolare lo stato risultante dopo l'applicazione del secondo Hadamard. Ovvero, calcolare: $H(\\frac{1}{\\sqrt{2}} |0\\rangle + \\frac{1}{\\sqrt{2}} |1\\rangle)$. Si noti che $H$ è distributivo, quindi possiamo applicarlo a ciascuno dei termini singolarmente.\n",
"\n",
"\n",
" \n",
" $$\n",
" H(\\frac{1}{\\sqrt{2}} |0\\rangle + \\frac{1}{\\sqrt{2}} |1\\rangle) = \\frac{1}{\\sqrt{2}} H|0\\rangle + \\frac{1}{\\sqrt{2}} H|1\\rangle = \\frac{1}{2} [(|0\\rangle + |1\\rangle) + (|0\\rangle - |1\\rangle)] = |0\\rangle\n",
" $$\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "e19dd16b-50b2-435e-b83e-b65af3f642be",
"metadata": {},
"source": [
"Ora verifichiamo la nostra previsione con `Sampler`.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "6390f58c-057a-4ec2-a7ca-4a45410631c0",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"## Transpile\n",
"\n",
"target = backend.target\n",
"pm = generate_preset_pass_manager(target=target, optimization_level=3)\n",
"\n",
"qc_isa = pm.run(qcoin_0)\n",
"\n",
"## Execute\n",
"\n",
"# On real hardware:\n",
"sampler = Sampler(mode=backend)\n",
"pubs = [qc_isa]\n",
"job = sampler.run(pubs, shots=1000)\n",
"res = job.result()\n",
"\n",
"counts = res[0].data.meas.get_counts()\n",
"\n",
"\n",
"# or with Aer simulator with noise model from real backend\n",
"# job = sampler_sim.run([qc_isa])\n",
"# counts=job.result()[0].data.meas.get_counts()\n",
"\n",
"## Analyze\n",
"plot_histogram(counts)"
]
},
{
"cell_type": "markdown",
"id": "b5ff1950-9401-4461-bb07-0e8e5a44cb13",
"metadata": {},
"source": [
"Il secondo Hadamard ha annullato il primo e siamo tornati allo stato 0 di partenza! Questo perché la trasformazione di Hadamard trasforma gli stati $|0\\rangle$ e $|1\\rangle$ in stati simili, ma con fasi opposte. Dopo il secondo Hadamard, vediamo che i termini di $|0\\rangle$ interferiscono in modo costruttivo, mentre i termini di $|1\\rangle$ interferiscono in modo distruttivo e si annullano a vicenda.\n",
"\n",
"Esploriamo ulteriormente: possiamo cambiare la fase utilizzando un gate \"PHASE\". Ora applichiamo un Hadamard per creare la sovrapposizione, applichiamo uno sfasamento di $\\pi$ radianti, quindi applichiamo il secondo Hadamard:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "ad819e8b-bc89-41d6-b375-428da51220be",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qcoin_pi = QuantumCircuit(1)\n",
"qcoin_pi.h(0)\n",
"qcoin_pi.p(np.pi, 0)\n",
"qcoin_pi.h(0)\n",
"qcoin_pi.measure_all()\n",
"\n",
"qcoin_pi.draw(\"mpl\")"
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "06e21f78-e3e2-4fbf-b636-460f3ce5b3c7",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"## Transpile\n",
"\n",
"target = backend.target\n",
"pm = generate_preset_pass_manager(target=target, optimization_level=3)\n",
"\n",
"qc_isa = pm.run(qcoin_pi)\n",
"\n",
"## Execute\n",
"\n",
"# On real hardware:\n",
"sampler = Sampler(mode=backend)\n",
"pubs = [qc_isa]\n",
"job = sampler.run(pubs, shots=1000)\n",
"res = job.result()\n",
"\n",
"counts = res[0].data.meas.get_counts()\n",
"\n",
"\n",
"# or with Aer simulator with noise model from real backend\n",
"# job = sampler_sim.run([qc_isa])\n",
"# counts=job.result()[0].data.meas.get_counts()\n",
"\n",
"## Analyze\n",
"plot_histogram(counts)"
]
},
{
"cell_type": "markdown",
"id": "35078634-0d0a-43bc-a220-50c927d4c088",
"metadata": {},
"source": [
"Ora si misura che il qubit si trova nello stato 1 invece che 0.\n",
"\n",
"Quindi, anche da questi pochi e semplici esperimenti, si può già vedere la drastica differenza che questa fase può fare su un circuito quantistico. Può essere sottile e difficile da vedere all'inizio. Nel nostro primo esperimento, in cui abbiamo semplicemente lanciato la nostra moneta quantistica con un gate di Hadamard e abbiamo misurato il risultato del lancio, non abbiamo rivelato nulla dell'effetto della fase. Solo quando abbiamo scavato più a fondo abbiamo scoperto la differenza che può fare una fase. Può far sì che lo stesso gate quantistico abbia letteralmente l'effetto opposto su un qubit.\n",
"\n",
"\n",
"\n",
"#### Provalo tu stesso:\n",
"\n",
"Modificare la cella di codice sottostante per cambiare la fase in modo che il secondo Hadamard crei uno stato di sovrapposizione con probabilità del 25% e 75% di trovare lo stato in $|0\\rangle$ e $|1\\rangle$, rispettivamente. Verificate la vostra risposta con la matematica.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 17,
"id": "fef281ef",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qcoin_phase = QuantumCircuit(1)\n",
"qcoin_phase.h(0)\n",
"# replace \"x\" below with a phase from 0 to 2*np.pi (this cell won't run if you leave x)\n",
"# qcoin_phase.rz(x, 0)\n",
"qcoin_phase.h(0)\n",
"qcoin_phase.measure_all()\n",
"\n",
"\n",
"## Transpile\n",
"\n",
"target = backend.target\n",
"pm = generate_preset_pass_manager(target=target, optimization_level=3)\n",
"\n",
"qc_isa = pm.run(qcoin_phase)\n",
"\n",
"## Execute\n",
"\n",
"# On real hardware:\n",
"sampler = Sampler(mode=backend)\n",
"pubs = [qc_isa]\n",
"job = sampler.run(pubs, shots=1000)\n",
"res = job.result()\n",
"\n",
"counts = res[0].data.meas.get_counts()\n",
"\n",
"\n",
"# or with Aer simulator with noise model from real backend\n",
"# job = sampler_sim.run([qc_isa])\n",
"# counts=job.result()[0].data.meas.get_counts()\n",
"\n",
"## Analyze\n",
"plot_histogram(counts)"
]
},
{
"cell_type": "markdown",
"id": "3cd238cb-6346-40f4-af87-fdbd1b806106",
"metadata": {},
"source": [
"\n",
"\n",
"## Un'altra (migliore) analogia con le monete utilizzando il gate \" $\\sqrt{\\text{NOT}}$ \"\n",
"\n",
"Ormai abbiamo imparato che l'atto di lanciare una moneta è molto diverso dal creare uno stato di sovrapposizione. Esiste un'analogia migliore con una moneta che catturi maggiormente i fenomeni di sovrapposizione? Sì. Sì, c'è.\n",
"\n",
"Faremo un altro esperimento mentale con una moneta. Immaginate la moneta seduta sul tavolo, a testa in su. Per far sì che la testa sia rivolta verso il basso, è sufficiente capovolgerla. È l'equivalente computazionale di una porta \"NOT\".\n",
"\n",
"Supponiamo di voler costruire un'operazione che, se applicata due volte, sia equivalente alla porta NOT. In altre parole, vogliamo un \"radicale quadrato di NOT\", o $\\sqrt{\\text{NOT}}$. Possiamo farlo considerando come la porta NOT è fisicamente implementata sulla moneta: è solo una rotazione di 180 gradi intorno, ad esempio, all'asse x. Quindi, se ruotassimo la moneta di soli 90 gradi intorno all'asse x, sarebbe equivalente a un gate $\\sqrt{\\text{NOT}}$.\n",
"\n",
"Immaginiamo che, dopo aver applicato il gate $\\sqrt{\\text{NOT}}$, vogliamo chiedere se la moneta è testa in su o testa in giù. Non è né l'uno né l'altro: è in piedi sul suo bordo rispetto all'asse verticale. Ma ora ridefiniamo la nostra \"misurazione\" della moneta in modo che, in primo luogo, la faccia collassare lungo l'asse di misurazione (schiacciandola con la mano in modo che sia distesa) e, in secondo luogo, verifichi se è testa in su o in giù.\n",
"\n",
"Se eseguiamo questa \"misurazione\" sulla moneta in piedi sul bordo, allora la moneta \"crollerà\" a testa in su e a testa in giù con uguale probabilità. Come nel caso del lancio di una moneta, in linea di principio è possibile prevedere la direzione di caduta della moneta in base alle condizioni iniziali della stessa e al modo in cui la forza della nostra mano viene applicata alla moneta per farla \"crollare\". In pratica, però, dovrebbe essere difficile prevedere quale lato finirà in alto, quindi è essenzialmente casuale.\n",
"\n",
"In realtà possiamo misurare questa moneta lungo tre assi diversi: $x$, $y$, e $z$. Vediamo che il bordo della moneta punta lungo $x$ e $z$, quindi la misurazione in queste direzioni richiede il \"collasso\" della moneta - quindi, lungo questi assi, ci sarà una probabilità casuale del 50:50 di misurare teste in alto e in basso. Ma lungo l'asse $y$ è già piatto, con la testa rivolta verso la direzione -y. Possiamo chiamarlo \"testa avanti\"\n",
"\n",
"Quindi, mentre le misure x e z hanno dato risultati casuali, la misura y darà sempre lo stesso risultato! Se ricordate l'esperimento del \"lancio della moneta quantistica\" della sezione precedente, questo ricorda il comportamento della moneta quantistica. È stato misurato come 0 o 1 con probabilità 50/50 nella direzione z, ma sempre $|+\\rangle$ e mai $|-\\rangle$ lungo X. **Questo suggerisce che forse una moneta ferma, sul suo bordo, è un modo migliore per visualizzare lo stato di sovrapposizione di un qubit rispetto a una moneta che gira selvaggiamente nell'aria.**\n",
"\n",
"Usiamo Qiskit per vedere se la nostra \"moneta quantistica\" si comporta come la nostra moneta classica quando viene applicato un gate $\\sqrt{\\text{NOT}}$. Applicheremo $\\sqrt{\\text{NOT}}$ a un qubit a partire da $|0\\rangle$, quindi utilizzeremo `Estimator` per verificare il valore di aspettativa delle tre osservabili, X, Y e Z.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 18,
"id": "ab97d4c5-285c-4efd-bc54-efda675e35fa",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qcoin_sx = QuantumCircuit(1)\n",
"qcoin_sx.sx(0)\n",
"\n",
"qcoin_sx.draw(\"mpl\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "28b2db66-c9d3-43a8-bfba-d90f6fd310e6",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[-0.01234492]\n",
" [-1.00388865]\n",
" [ 0.00740695]]\n"
]
}
],
"source": [
"obs1 = Pauli(\"X\")\n",
"obs2 = Pauli(\"Y\")\n",
"obs3 = Pauli(\"Z\")\n",
"\n",
"\n",
"# Step 2: Transpile the circuit\n",
"\n",
"pm = generate_preset_pass_manager(target=target, optimization_level=3)\n",
"qc_isa = pm.run(qcoin_sx)\n",
"obs1_isa = obs1.apply_layout(layout=qc_isa.layout)\n",
"obs2_isa = obs2.apply_layout(layout=qc_isa.layout)\n",
"obs3_isa = obs3.apply_layout(layout=qc_isa.layout)\n",
"\n",
"\n",
"# Step 3: Run the circuit on a real quantum computer\n",
"\n",
"estimator = Estimator(mode=backend)\n",
"pubs = [(qc_isa, [[obs1_isa], [obs2_isa], [obs3_isa]])]\n",
"job = estimator.run(pubs)\n",
"res = job.result()\n",
"\n",
"# Run the job on the Aer simulator with noise model from real backend\n",
"# pubs = [(qc_isa, [[obs1_isa], [obs2_isa], [obs3_isa]])]\n",
"# job = estimator_sim.run(pubs)\n",
"# res=job.result()\n",
"\n",
"# Step 4: Return the result in classical form, and analyze.\n",
"\n",
"print(res[0].data.evs)"
]
},
{
"cell_type": "markdown",
"id": "f14bd04e-255c-4bdd-a1fa-34c71273a369",
"metadata": {},
"source": [
"I valori di aspettativa sono 0, -1, e 0 per X, Y e Z, rispettivamente.\n",
"\n",
"\n",
"\n",
"#### Verifica la tua comprensione\n",
"\n",
"Dati i valori di aspettativa, quali sono le probabilità di misurare la moneta quantistica come testa in su/giù (o sinistra/destra o avanti/indietro) per ciascuno dei 3 assi di misura?\n",
"\n",
"\n",
" \n",
" C'è una probabilità del 50/50 di misurare uno dei due stati lungo X e Z, e lo stato è sempre misurato nella direzione -y lungo Y.\n",
" \n",
"\n",
"\n",
"Questo è lo stesso risultato che abbiamo ottenuto con il nostro esperimento di pensiero applicando una \" $\\sqrt{\\text{NOT}}$ \" rotazione di 90 gradi sulla moneta classica. In effetti, ora esiste una precisa analogia tra la moneta e lo stato del qubit. Possiamo visualizzare lo stato del qubit come un vettore che punta in direzione della testa di una moneta, normale alla superficie della moneta stessa. Quindi, testa in su, o lo stato $|0\\rangle$ di una moneta quantistica, equivale a un vettore che punta dritto verso l'alto; testa in giù, o $|1\\rangle$, punta dritto verso il basso. Qualsiasi sovrapposizione uguale di $|0\\rangle$ e $|1\\rangle$ punti orizzontali. La fase dello stato determina l'esatta direzione orizzontale: la direzione in cui punta lungo l'equatore è uguale alla direzione in cui punta il coefficiente $c_2$ nel piano complesso.\n",
"\n",
"Ora, *ogni* porta che abbiamo visto in questo quaderno può essere visualizzata come una rotazione (o una serie di rotazioni) della moneta/vettore.\n",
"\n",
"* NON: 180 gradi intorno all'asse x\n",
"\n",
"* $\\sqrt{\\text{NOT}}$ : 90 gradi intorno all'asse x\n",
"\n",
"* FASE: rotazione di $\\phi$ intorno all'asse z\n",
"\n",
"* Hadamard: Questo è un po' più difficile. Inizialmente lo abbiamo paragonato al lancio di una moneta, che fa girare la moneta in modo incontrollato nell'aria. Ma l'Hadamard è in realtà una rotazione controllata e deterministica della moneta, come le altre porte. L'Hadamard viene eseguito ruotando di 90 gradi intorno all'asse y, quindi di 180 gradi intorno all'asse x.\n",
"\n",
"Quindi, non c'è nulla di casuale in uno stato di sovrapposizione quantistica o in una qualsiasi delle operazioni standard che eseguiamo sul qubit. Ogni operazione è deterministica e reversibile. L'unico momento in cui la casualità entra in gioco è quando decidiamo di *misurare* lo stato quantistico.\n",
"\n",
"\n",
"\n",
"### Lo stato del qubit come vettore di Bloch\n",
"\n",
"Questo vettore che punta in direzione della \"testa\" della moneta è noto come \"vettore di Bloch\" Formalmente, uno stato arbitrario (isolato) di un qubit può essere rappresentato da un vettore che giace sulla superficie di una sfera di raggio 1 con coordinate $(r, \\theta, \\phi)$. Scritto in termini di queste coordinate, lo stato del qubit è:\n",
"\n",
"$|\\psi\\rangle = \\cos{\\frac{\\theta}{2}} |0\\rangle + e^{i \\phi} \\sin{\\frac{\\theta}{2}} |1\\rangle$\n",
"\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "a9e7efad-9561-4613-b2e2-d5201d3cef72",
"metadata": {},
"source": [
"Verifichiamo ora con Qiskit come cambia il vettore Bloch quando applichiamo vari gate al nostro qubit partendo dallo stato $|0\\rangle$.\n",
"\n",
"\n",
"\n",
"#### NON\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 20,
"id": "d33d6191-c455-4cac-8947-0d68030278e9",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 20,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit.visualization import plot_bloch_multivector\n",
"\n",
"qnot = QuantumCircuit(1)\n",
"qnot.x(0)\n",
"\n",
"plot_bloch_multivector(qnot)"
]
},
{
"cell_type": "markdown",
"id": "69f06a6c-1a33-48a7-84de-30c49fc11f97",
"metadata": {},
"source": [
"\n",
"\n",
"#### $\\sqrt{\\text{NOT}}$\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 21,
"id": "8648c4b8-edd1-4e40-9c74-50219c84c928",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qsqrtnot = QuantumCircuit(1)\n",
"qsqrtnot.sx(0)\n",
"\n",
"plot_bloch_multivector(qsqrtnot)"
]
},
{
"cell_type": "markdown",
"id": "f0145781-8534-4f94-bea4-11111dfffdfb",
"metadata": {},
"source": [
"\n",
"\n",
"#### PHASE ( $\\phi = \\pi$ )\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 22,
"id": "f2b33aa1-2460-4e66-aa48-cbceef02729e",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 22,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qphase = QuantumCircuit(1)\n",
"qphase.p(np.pi, 0)\n",
"\n",
"plot_bloch_multivector(qphase)"
]
},
{
"cell_type": "markdown",
"id": "9ca1c439-055e-4c11-a730-2dfa1f6141e4",
"metadata": {},
"source": [
"\n",
"\n",
"#### Hadamard\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 23,
"id": "1371f0a1-8279-4dff-987b-050511ba629b",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 23,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qhadamard = QuantumCircuit(1)\n",
"qhadamard.h(0)\n",
"\n",
"plot_bloch_multivector(qhadamard)"
]
},
{
"cell_type": "markdown",
"id": "f66be32d-6452-4ba0-8dcf-5e248ce37605",
"metadata": {},
"source": [
"\n",
"\n",
"## Conclusione: *cos'è* uno stato di sovrapposizione?\n",
"\n",
"Abbiamo iniziato questo modulo paragonando la casualità della misurazione di uno stato di sovrapposizione quantistica al lancio di una moneta. Abbiamo paragonato il \"cancello di Hadamard\" che produce una sovrapposizione quantistica all'atto di lanciare una moneta. Ma, attraverso una serie di esperimenti, abbiamo imparato che esistono differenze fondamentali tra il lancio di una moneta classica e una superposizione quantistica.\n",
"\n",
"Abbiamo imparato che non c'è nulla di \"casuale\" in un qubit in uno stato di sovrapposizione. È come una moneta ferma nello spazio tridimensionale. In effetti, una moneta libera di ruotare in 3 dimensioni è un'analogia molto vicina a un modo particolare di visualizzare lo stato quantistico di un qubit, chiamato vettore di Bloch. Le porte quantistiche ruotano questo vettore moneta/Bloch in modo deterministico e reversibile. È solo quando **misuriamo** il qubit che viene introdotta la casualità. Abbiamo paragonato questo processo di misurazione allo schiacciamento della moneta in modo che sia piatta nella direzione dell'asse di misurazione.\n",
"\n",
"Il fatto che uno stato quantistico si trovi o meno in una sovrapposizione è davvero solo nell'occhio di chi guarda. Come probabilmente avete già visto, siamo liberi di scegliere il nostro sistema di coordinate: $x$, $y$ e $z$ possono puntare lungo tre direzioni ortogonali. Quindi, se abbiamo una sovrapposizione di 0 e 1 in un sistema di coordinate, possiamo definire un nuovo sistema di coordinate - o, equivalentemente, una nuova \"base di misura\" - in cui lo stato punta esclusivamente nella direzione $+z$, e quindi non in uno stato di sovrapposizione. Quindi, quando diciamo che un qubit è in sovrapposizione, dobbiamo anche rispondere alla domanda: \"sovrapposizione di *cosa*?\"\n",
"\n",
"Potreste lasciare questo modulo con l'impressione che abbiamo appena eliminato tutto il mistero dalla meccanica quantistica. Dopo tutto, uno degli aspetti presumibilmente più \"strani\", lo stato di sovrapposizione di un qubit, è in realtà semplice come un vettore tridimensionale. Ma tenete presente che la moneta è ancora solo un'analogia e anche il vettore di Bloch è solo uno strumento di visualizzazione per calcolare le probabilità dei risultati delle misure. Non possiamo dire cosa stia facendo *realmente* uno stato quantistico prima di averlo misurato. Perché il controllo richiede una misurazione!\n",
"\n",
"Discuteremo l'enigma di quale sia la \"vera\" natura di uno stato quantistico e come il fenomeno quantistico dell'entanglement possa aiutarci a chiarirlo, nel modulo sulla disuguaglianza di Bell.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "3425eb14-a8fd-4894-83a8-268a93733795",
"metadata": {},
"source": [
"\n",
"\n",
"## Domande\n",
"\n",
"Gli insegnanti possono richiedere le versioni di questi quaderni con le chiavi di risposta e le indicazioni per l'inserimento nei curricula comuni compilando questo [rapido sondaggio](https://ibm.biz/classrooms_instructor_key_request) sull'utilizzo dei quaderni.\n",
"\n",
"\n",
"\n",
"### Concetti fondamentali:\n",
"\n",
"* Mentre la misura di un qubit in superposizione è probabilistica, come il lancio di una moneta, lo stato di superposizione in sé si comporta in modo diverso rispetto al lancio di una moneta.\n",
"* La differenza principale tra una distribuzione di probabilità classica e una superposizione è che la superposizione ha una coerenza *di fase*, che le permette di interferire in modo costruttivo o distruttivo.\n",
"* Lo stato di un singolo qubit isolato può essere visualizzato come un punto della cosiddetta \"sfera di Bloch\", dove le ampiezze relative delle componenti $|0\\rangle$ e $|1\\rangle$ determinano l'angolo polare $\\theta$ e le fasi relative tra le due componenti determinano l'angolo azimutale $\\phi$.\n",
"* Tutte le porte quantistiche a singolo qubit possono essere viste come rotazioni del vettore su questa sfera.\n",
"\n",
"\n",
"\n",
"### Domande vero/falso:\n",
"\n",
"1. T/F Una sovrapposizione quantistica è sostanzialmente uguale a un evento probabilistico della fisica classica, come il lancio di una moneta.\n",
"\n",
"2. T/F La lunghezza del vettore di Bloch che descrive lo stato di un singolo qubit isolato è sempre pari a 1.\n",
"\n",
"3. T/F Le porte quantistiche a singolo qubit non modificano la lunghezza del vettore di Bloch.\n",
"\n",
"\n",
"\n",
"### Domande del moderatore:\n",
"\n",
"1. Selezionare il vettore di Bloch corretto che rappresenta lo stato $|\\Psi\\rangle = \\sqrt{\\frac{1}{3}}|0\\rangle + e^{i \\pi / 4} \\sqrt{\\frac{2}{3}}|1\\rangle$ :\n",
"\n",
"\n",
"\n",
"2. La sfera di Bloch descrive un qubit: (selezionare tutte le opzioni applicabili)\n",
"\n",
" a. ampiezza\n",
"\n",
" b. entanglement con altri qubit\n",
"\n",
" c. fase\n",
"\n",
" d. colore\n",
"\n",
" e. probabilità dei risultati della misurazione\n",
"\n",
"\n",
"\n",
"### Domande di discussione:\n",
"\n",
"1. Perché lo stato di un qubit può essere visualizzato sulla sfera di Bloch, ma la distribuzione di probabilità di un lancio di moneta no?\n",
"\n",
"2. Perché il lancio di una moneta in aria non è la migliore analogia con uno stato di sovrapposizione quantistica? Quale aspetto delle superposizioni non viene colto in questa analogia?\n",
"\n",
"\n",
"\n",
"### Problemi di sfida:\n",
"\n",
"1. Utilizzare Qiskit per creare un circuito che trasformi lo stato $|0\\rangle$ nello stato $\\frac{\\sqrt{3}}{2}|0\\rangle + \\frac{1}{2}e^{i \\frac{5\\pi}{6}}|1\\rangle$\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"id": "a1b8767d",
"source": "© IBM Corp., 2017-2026"
}
],
"metadata": {
"in_page_toc_max_heading_level": 2,
"in_page_toc_min_heading_level": 2,
"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"
},
"widgets": {
"application/vnd.jupyter.widget-state+json": {
"state": {},
"version_major": 2,
"version_minor": 0
}
}
},
"nbformat": 4,
"nbformat_minor": 5
}