{
"cells": [
{
"cell_type": "markdown",
"id": "f767af9e-cdd6-41f4-9279-9e92fa2dde06",
"metadata": {},
"source": [
"---\n",
"title: \"Esplorare l'incertezza con Qiskit\"\n",
"description: \"Scopri quali misure fisiche influiscono l'una sull'altra ed esplora l'incertezza fondamentale nella meccanica quantistica utilizzando un vero computer quantistico\"\n",
"---\n",
"\n",
"{/* cspell:ignore prodxz delx delz dely prodxy uparrow downarrow */}\n",
"\n",
"\n",
"\n",
"# Esplorare l'incertezza\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "132cdf03-164e-4334-aab6-206aacacc25b",
"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 8 minuti di tempo QPU. Si tratta solo di una stima. L'utilizzo effettivo può variare. Due calcoli che richiedono molto tempo sono segnalati come tali nei commenti dell'intestazione e possono essere eseguiti su simulatori se gli studenti hanno poco tempo a disposizione per il QPU. Una volta rimossi, il modulo richiede solo 30 secondi di tempo per la QPU.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "dbda80f2-62c5-4f25-95cf-c5495bc171b1",
"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": "4283087e-cc02-467d-b02c-c1c131ad15f3",
"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=3h3pwrECbb8\\&list=PLOFEBzvs-Vvrs2fuvsuT039ariYPsua3d\\&index=5) per guardarla su YouTube.\n",
"\n",
"***\n",
"\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "be385aa2-9080-4c39-aba0-bc35087ced78",
"metadata": {},
"source": [
"\n",
"\n",
"## Introduzione\n",
"\n",
"Probabilmente avete sentito parlare del principio di indeterminazione, anche al di fuori dei corsi di fisica. Un'espressione colloquiale comune dell'incertezza è: \"Guardando qualcosa, la si influenza\" Questo è certamente vero. Ma un modo più fisico di descrivere l'incertezza è che ci sono alcune osservabili fisiche che hanno un'incompatibilità che impedisce loro di essere conosciute simultaneamente con una precisione arbitraria. Molti studenti si imbattono per la prima volta nella coppia di variabili incompatibili $x$ e $p_x$, che indicano rispettivamente la posizione lungo un asse, chiamato asse $x$, e il momento lineare lungo quella direzione. Per queste variabili il vincolo sull'incertezza si scrive $\\Delta x \\Delta p_x \\geq \\frac{\\hbar}{2}.$ Qui, $\\Delta x$ è chiamata \"incertezza in $x$ \", che ha la stessa definizione della deviazione standard in statistica, e può essere definita come $\\Delta x = \\sqrt{\\langle x^2 \\rangle - \\langle x \\rangle^2}.$ $\\Delta p_x$ è definito nello stesso modo.\n",
"In questa sede non ricaveremo questa relazione di incertezza, ma sottolineeremo che è coerente con la nostra comprensione delle onde classiche. Cioè, un'onda con una frequenza davvero perfetta $f$ e una lunghezza d'onda $\\lambda$ continuerebbe all'infinito come una sinusoide perfetta. Dal punto di vista quantomeccanico, ciò corrisponderebbe a conoscere perfettamente la quantità di moto secondo l'ipotesi di de Broglie: $\\lambda = h/p$. Ma per conoscere $where$ la posizione di una particella ondulatoria, l'onda che la descrive deve diventare più netta nello spazio, come una gaussiana molto stretta, ad esempio. Sappiamo che possiamo esprimere qualsiasi funzione continua, comprese le funzioni d'onda a picco, come una serie di Fourier di funzioni sinusoidali con lunghezze d'onda diverse. Ma quando la funzione d'onda diventa più acuta (e la posizione è meglio conosciuta), avremo bisogno di più termini nella serie di Fourier, il che significa una miscela di più lunghezze d'onda (e quindi, quantomeccanicamente, più valori di quantità di moto).\n",
"\n",
"Detto più semplicemente: uno stato con una quantità di moto ben definita (una sinusoide perfetta nello spazio) ha una posizione molto incerta. Uno stato con una posizione ben definita (come una distribuzione delta di Dirac) ha una quantità di moto molto incerta.\n",
"\n",
"Esistono altre variabili che presentano questa incompatibilità. Ad esempio, lo spin di una particella può avere una proiezione ben definita lungo un asse, ma non sappiamo nulla della proiezione su un asse ortogonale. Ad esempio, lo stato $|0\\rangle \\sim |\\uparrow\\rangle$ (per un qubit o una particella spin-1/2 ) ha una proiezione definita lungo l'asse $z$ (di 1 nel contesto di un qubit e di $\\hbar/2$ nel contesto di una particella spin-1/2 ). Ma questo stato può essere scritto come una sovrapposizione di due stati, ognuno dei quali ha una proiezione ben definita sull'asse $x$ : $|0\\rangle = \\frac{1}{\\sqrt{2}}(|+\\rangle_x+|-\\rangle_x)$ o equivalentemente $\\begin{pmatrix} 1 \\\\ 0\\end{pmatrix} = \\frac{1}{\\sqrt{2}}\\left[\\frac{1}{\\sqrt{2}}\\begin{pmatrix} 1 \\\\ 1\\end{pmatrix}+\\frac{1}{\\sqrt{2}}\\begin{pmatrix} 1 \\\\ -1\\end{pmatrix}\\right].$ $|+\\rangle_x$ ha una proiezione ben definita su $x$, così come $|-\\rangle_x$. Quindi, se specifichiamo la proiezione di uno stato lungo l'asse $x$, non conosciamo la proiezione lungo l'asse $z$. E se specifichiamo la proiezione sull'asse $z$, non conosciamo la proiezione lungo $x$. Ci sono piccole differenze quando si parla di spin e di qubit. In generale, però, gli autostati delle matrici di Pauli hanno una relazione interessante che possiamo esplorare.\n",
"Nel corso di questa lezione, verificheremo sperimentalmente la nostra intuizione sull'incertezza di queste variabili incompatibili e verificheremo che le relazioni di incertezza sono valide sui computer quantistici IBM®.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "eb8c7a0c-c962-4efd-ab82-905ba7415284",
"metadata": {},
"source": [
"\n",
"\n",
"## Semplice verifica dell'intuizione\n",
"\n",
"In questo primo esperimento e in tutto il modulo, utilizzeremo un framework per il calcolo quantistico noto come \"Qiskit patterns\", che suddivide i flussi di lavoro nelle seguenti fasi:\n",
"\n",
"* Fase 1: mappare gli input classici in un problema quantistico\n",
"* Fase 2: Ottimizzazione del problema per l'esecuzione quantistica\n",
"* Fase 3: Esecuzione tramite le primitive \" IBM Quantum \"\n",
"* Fase 4: post-elaborazione e analisi classica\n",
"\n",
"In genere seguiamo questi passaggi, anche se non sempre li indichiamo esplicitamente.\n",
"\n",
"Iniziamo caricando alcuni pacchetti necessari, tra cui le primitive di Runtime. Selezioneremo anche il computer quantistico meno impegnato a nostra disposizione.\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": "c26c8f6f-1ed7-4079-ba21-4747d318996f",
"metadata": {},
"outputs": [],
"source": [
"from numpy import pi\n",
"\n",
"# 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": 2,
"id": "7d34071a-6fb1-4a0a-9e66-c9ee40c3767b",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"ibm_sherbrooke\n"
]
}
],
"source": [
"# Load the Runtime primitive and session\n",
"from qiskit_ibm_runtime import (\n",
" Batch,\n",
" SamplerV2 as Sampler,\n",
" EstimatorV2 as Estimator,\n",
")\n",
"\n",
"# Use the least busy backend\n",
"backend = service.least_busy(min_num_qubits=127)\n",
"print(backend.name)"
]
},
{
"cell_type": "markdown",
"id": "fcbf932e-45b7-4a50-90e1-59dcb7577dfc",
"metadata": {},
"source": [
"Se uno studente esaurisce il tempo disponibile per il calcolo quantistico durante la lezione, le righe seguenti possono essere non commentate e utilizzate per impostare un simulatore che imiti in parte il comportamento del rumore del computer quantistico selezionato sopra.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "7265c432-19eb-41ba-940d-a80541fe0218",
"metadata": {},
"outputs": [],
"source": [
"# Import an estimator, this time from qiskit (we will import from Runtime for real hardware)\n",
"from qiskit_aer.primitives import SamplerV2, EstimatorV2\n",
"from qiskit_aer.noise import NoiseModel\n",
"\n",
"# Generate the noise model from the backend properties\n",
"noise_model = NoiseModel.from_backend(backend)\n",
"\n",
"noisy_sampler = SamplerV2(options={\"backend_options\": {\"noise_model\": noise_model}})\n",
"noisy_estimator = EstimatorV2(options={\"backend_options\": {\"noise_model\": noise_model}})"
]
},
{
"cell_type": "markdown",
"id": "5f072c75-efb7-4596-8bc6-ccae553684df",
"metadata": {},
"source": [
"Si ricorda che un autostato di un operatore, Z, non è un autostato di un altro operatore, X. Lo osserveremo ora, sperimentalmente, effettuando misure lungo gli assi $x$ e $z$. Per la misura lungo $z$, usiamo semplicemente ` qc.measure ()`, perché i computer quantistici IBM sono strutturati per misurare lungo $z$. Ma per misurare lungo $x$, dobbiamo ruotare il sistema per spostare effettivamente l'asse $x$ fino all'orientamento lungo il quale misuriamo. Questo si ottiene con un cancello di Hadamard. Un passo simile è richiesto per le misure lungo $y$. I passaggi necessari sono raccolti qui per comodità:\n",
"\n",
"* Per misurare lungo $z$ : `qc.measure()`\n",
"* Per misurare lungo $x$ : `qc.h()` quindi `qc.measure()`\n",
"* Per misurare lungo $y$ : `qc.sdg()`, `qc.h()`, `qc.s`poi `qc.measure()`\n",
"\n",
"\n",
"\n",
"### Fase 1: mappare gli input classici su un problema quantistico\n",
"\n",
"In questo caso, la fase di mappatura consiste semplicemente nell'esprimere le misure e le rotazioni descritte in precedenza in un circuito quantistico:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8baef7f9-78bf-48c8-8359-efd65f943d96",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Step 1: Map\n",
"\n",
"# Import some general packages\n",
"from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister\n",
"\n",
"# Define registers\n",
"qr = QuantumRegister(1, \"q\")\n",
"cr = ClassicalRegister(2, \"c\")\n",
"qc = QuantumCircuit(qr, cr)\n",
"\n",
"# Add a first measurement\n",
"qc.measure(qr, cr[0])\n",
"qc.barrier()\n",
"\n",
"# Change basis so that measurements made on quantum computer which normally tell us about z,\n",
"# now tell us about x.\n",
"qc.h(qr)\n",
"\n",
"# Add a second measurement\n",
"qc.measure(qr, cr[1])\n",
"\n",
"qc.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "4d931ec8-6f8f-405f-a9ce-41724435f3a1",
"metadata": {},
"source": [
"\n",
"\n",
"### Fase 2: Ottimizzazione del problema per l'esecuzione quantistica\n",
"\n",
"Questa fase prende le operazioni che vogliamo eseguire e le esprime in termini di funzionalità di uno specifico computer quantistico. Inoltre, il nostro problema è stato tracciato sul layout del computer quantistico.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "d613ac18-61ff-4e91-9f7d-73887bd2306a",
"metadata": {},
"outputs": [],
"source": [
"# Step 2: 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(qc)"
]
},
{
"cell_type": "markdown",
"id": "2f31c2b1-08be-43c7-8af3-5d9ee8a4dab0",
"metadata": {},
"source": [
"\n",
"\n",
"### Fase 3: Esecuzione tramite le primitive \" IBM Quantum \"\n",
"\n",
"Possiamo utilizzare Sampler per raccogliere dati statistici sulle misurazioni. Realizzeremo la primitiva Sampler in modo che funzioni su un vero computer quantistico utilizzando `mode = backend`. Esistono altre modalità per altri flussi di lavoro, e ne useremo una qui di seguito. Sampler verrà utilizzato richiamando il suo metodo run() con un elenco di \"pubs\" (Primitive Unified Blocs). Ogni voce contiene fino a tre valori che, insieme, definiscono un'unità di lavoro che lo stimatore deve completare: circuiti, grandezze osservabili, parametri. È inoltre possibile fornire un elenco di circuiti, un elenco di grandezze osservabili e un elenco di parametri. Per ulteriori informazioni, consulta la [panoramica sui PUB.](/docs/guides/primitive-input-output#pubs)\n",
"\n",
"Vogliamo eseguire su un vero computer quantistico, in modo da realizzare un vero esperimento di fisica quantistica. Se si esaurisce il tempo a disposizione sui computer quantistici reali, è possibile commentare il codice sottostante per il computer quantistico e decommentare il codice per l'esecuzione su un simulatore.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8996bcf0-1848-4eda-b5a1-47190fede630",
"metadata": {},
"outputs": [],
"source": [
"# Step 3: Run the job on a real quantum computer\n",
"\n",
"\n",
"sampler = Sampler(mode=backend)\n",
"pubs = [qc_isa]\n",
"job = sampler.run(pubs)\n",
"res = job.result()\n",
"\n",
"counts = res[0].data.c.get_counts()\n",
"\n",
"# Run the job on the Aer simulator with noise model from real backend\n",
"\n",
"# job = noisy_sampler.run([qc_isa])\n",
"# res=job.result()\n",
"# counts=res[0].data.c.get_counts()"
]
},
{
"cell_type": "markdown",
"id": "01dedf77-2ea7-45f4-9a84-8cd1caa26c14",
"metadata": {},
"source": [
"\n",
"\n",
"### Fase 4: Post-elaborazione\n",
"\n",
"Si tratta di un caso particolarmente semplice di post-elaborazione, in cui ci si limita a visualizzare i conteggi.\n",
"\n",
"Si noti che Qiskit ordina i qubit, le misure e altre cose elencando l'elemento con il numero più basso per ultimo / a destra, una convenzione definita \"little-endian\". Ciò significa che la colonna sottostante etichettata \"10\" si riferisce ai conteggi in cui la prima misurazione ha prodotto uno \"0\" e la seconda un \"1\".\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "7cfeafbf-6a40-4829-9e1d-6c8dbdab9f23",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Step 4: Post-process\n",
"\n",
"from qiskit.visualization import plot_histogram\n",
"\n",
"plot_histogram(counts)"
]
},
{
"cell_type": "markdown",
"id": "2d21379b-b27f-4448-adb5-91f55e79b0e2",
"metadata": {},
"source": [
"Se questa convenzione non è di vostro gradimento, potete usare `marginal_counts` per visualizzare i risultati di ogni misura separatamente:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "8c94042b-0e52-41f3-8231-ede9fab3ee51",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit.result import marginal_counts\n",
"\n",
"plot_histogram(\n",
" marginal_counts(counts, indices=[0]), title=\"Counts after first measurement\"\n",
")"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "d0ad384b-c2f1-4bc6-8730-ec8a4b593a50",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"plot_histogram(\n",
" marginal_counts(counts, indices=[1]), title=\"Counts after second measurement\"\n",
")"
]
},
{
"cell_type": "markdown",
"id": "258d66a0-ddfc-4c69-8943-37efb7c09b40",
"metadata": {},
"source": [
"Per impostazione predefinita, gli stati in Qiskit sono inizializzati allo stato $|0\\rangle$. Non sorprende quindi che quasi tutte le prime misurazioni abbiano dato come risultato $|0\\rangle$. Si noti, tuttavia, che la seconda misurazione (quella che fornisce informazioni sulle proiezioni dello stato su $x$ ) è stata quasi equamente suddivisa. Sembra che questo stato, che ci dà un risultato molto prevedibile delle misurazioni lungo $z$, ci dia un insieme molto imprevedibile di risultati per le misurazioni lungo $x$. Esploriamo questo aspetto.\n",
"\n",
"Cosa succede se si effettuano le misurazioni nell'ordine opposto? Potremmo iniziare usando il gate di Hadamard per ottenere statistiche sulla probabilità che $|0\\rangle$ sia misurato in $|\\pm\\rangle_x$. Poi, per la seconda misurazione, torneremo alla base $z$ utilizzando un secondo gate di Hadamard.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "4029873f-1260-4fc3-bfd2-e5a3f579a09c",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Step 1:\n",
"\n",
"# Define registers\n",
"qr = QuantumRegister(1, \"q\")\n",
"cr = ClassicalRegister(2, \"c\")\n",
"qc = QuantumCircuit(qr, cr)\n",
"\n",
"# Change basis to measure along x.\n",
"qc.h(qr)\n",
"qc.measure(qr, cr[0])\n",
"qc.barrier()\n",
"\n",
"# Change our basis back to z and make a second measurement\n",
"qc.h(qr)\n",
"qc.measure(qr, cr[1])\n",
"\n",
"qc.draw(\"mpl\")"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "c56d1649-de18-4417-8033-2be2a04a2582",
"metadata": {},
"outputs": [],
"source": [
"# Step 2: Transpile the circuit for running on a quantum computer\n",
"\n",
"pm = generate_preset_pass_manager(target=target, optimization_level=3)\n",
"qc_isa = pm.run(qc)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "782f01c9-f9c2-4e5e-8638-7c9ba3347bfb",
"metadata": {},
"outputs": [],
"source": [
"# Step 3: Run the job on a real quantum computer\n",
"\n",
"sampler = Sampler(mode=backend)\n",
"pubs = [qc_isa]\n",
"job = sampler.run(pubs)\n",
"res = job.result()\n",
"counts = res[0].data.c.get_counts()\n",
"\n",
"# Run the job on the Aer simulator with noise model from real backend\n",
"# job = noisy_sampler.run([qc_isa])\n",
"# res=job.result()\n",
"# counts=res[0].data.c.get_counts()"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "ce3fb0fd-a859-4c91-b2e5-c09343a397c2",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Step 4: Post-process\n",
"from qiskit.visualization import plot_histogram\n",
"\n",
"plot_histogram(counts)"
]
},
{
"cell_type": "markdown",
"id": "d7862ea1-a9fd-4b23-9198-cfbfb05cf3dc",
"metadata": {},
"source": [
"Qui sembra che la prevedibilità sia ancora minore! Prima sapevamo almeno quale sarebbe stato il risultato della prima misurazione, ora abbiamo una distribuzione abbastanza uniforme tra tutti gli stati possibili. Non è difficile capire perché sia successo. Abbiamo iniziato con $|0\\rangle$, che è una miscela al 50-50 di $|+\\rangle_x$ e $|-\\rangle_x$, secondo $|0\\rangle=\\frac{1}{\\sqrt{2}}(|+\\rangle_x+|-\\rangle_x)$ È evidente che la probabilità di ottenere lo stato + o - (mappato a 0 e 1 nel grafico) per la prima misurazione deve essere uguale. La misura lungo $x$ fa collassare lo stato in un autostato $|+\\rangle_x$ o in un autostato $|-\\rangle_x$. Ognuno di questi stati è una miscela 50-50 di $|0\\rangle$ e $|1\\rangle$, in base a $|+\\rangle_x = \\frac{1}{\\sqrt{2}}(|0\\rangle+|1\\rangle)$ $|-\\rangle_x = \\frac{1}{\\sqrt{2}}(|0\\rangle-|1\\rangle)$ Quindi, una volta che il sistema si trova in un autostato di $x$, è chiaro che le misure lungo $z$ produrranno sia $|0\\rangle$ sia $|1\\rangle$, e lo faranno con una probabilità approssimativamente uguale.\n",
"Il primo esempio ci ha mostrato che alcuni Stati avranno risultati molto prevedibili per alcune misure, ma imprevedibili per altre. L'esempio attuale ci dimostra che possiamo fare peggio di così. Ci sono stati che possono dare risultati imprevedibili per entrambe le misurazioni, anche se tutto ciò che facciamo è scambiare l'ordine delle misurazioni. Cerchiamo di capire quanto sia certa o incerta una quantità per un determinato stato.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "292b878f-1792-4f55-8991-49e37c7db58b",
"metadata": {},
"source": [
"\n",
"\n",
"## Calcolo dell'incertezza\n",
"\n",
"Possiamo quantificare questo aspetto utilizzando l'incertezza, o varianza. L'\"incertezza\" è spesso definita come la radice quadrata della \"varianza\" di una distribuzione. Cioè, l'incertezza per una certa osservabile $S$ è indicata con $\\Delta S$ ed è data da\n",
"\n",
"$$\n",
"\\begin{aligned}\n",
"(\\Delta S)^2 & \\equiv \\langle (S - \\langle S \\rangle)^2 \\rangle\\\\\n",
"\n",
"(\\Delta S)^2 & = \\langle S^2 - 2 S \\langle S \\rangle +\\langle S \\rangle^2 \\rangle\\\\\n",
"\n",
"(\\Delta S)^2 & = \\langle S^2 \\rangle - \\langle S \\rangle^2\n",
"\\end{aligned}\n",
"$$\n",
"\n",
"Per il caso delle matrici di Pauli, per le quali $S^2 = I$, questo diventa\n",
"\n",
"$$\n",
"(\\Delta S)^2 = 1 - \\langle S \\rangle^2\n",
"$$\n",
"\n",
"Applichiamo questo principio a un esempio concreto. Partiamo dallo stato $|\\psi\\rangle = |+\\rangle_y = \\frac{1}{\\sqrt{2}}\\begin{pmatrix} 1 \\\\ i \\end{pmatrix},$ e determiniamo l'incertezza dell'osservabile $X$ in quello stato.\n",
"\n",
"\n",
"\n",
"#### Verifica la tua comprensione\n",
"\n",
"Calcolare l'incertezza di $X$ nello stato $|+\\rangle_y = |+i\\rangle$, a mano.\n",
"\n",
"\n",
" \n",
" $$\n",
" \\Delta X =\\sqrt{\\langle+i| X^2 |+i\\rangle - \\langle+i| X |+i\\rangle^2}\n",
" $$\n",
"\n",
" Nello stato dato, si ottiene:\n",
"\n",
" $$\n",
" \\begin{aligned}\n",
" \\Delta X & =\\sqrt{\\frac{1}{\\sqrt{2}}\\begin{pmatrix}1 & -i\\end{pmatrix} \\begin{pmatrix}0 & 1 \\\\ 1 & 0\\end{pmatrix} \\begin{pmatrix}0 & 1 \\\\ 1 & 0\\end{pmatrix} \\frac{1}{\\sqrt{2}}\\begin{pmatrix}1 \\\\ i\\end{pmatrix} - \\left(\\frac{1}{\\sqrt{2}}\\begin{pmatrix}1 & -i\\end{pmatrix} \\begin{pmatrix}0 & 1 \\\\ 1 & 0\\end{pmatrix} \\frac{1}{\\sqrt{2}}\\begin{pmatrix}1 \\\\ i\\end{pmatrix}\\right)^2}\\\\\n",
"\n",
" \\Delta X & =\\sqrt{\\frac{1}{2}\\begin{pmatrix}1 & -i\\end{pmatrix} \\begin{pmatrix}1 & 0 \\\\ 0 & 1\\end{pmatrix} \\begin{pmatrix}1 \\\\ i\\end{pmatrix} - \\left(\\frac{1}{2}\\begin{pmatrix}1 & -i\\end{pmatrix} \\begin{pmatrix}i \\\\ 1\\end{pmatrix}\\right)^2}\\\\\n",
"\n",
" \\Delta X & =\\sqrt{\\frac{1}{2}\\begin{pmatrix}1 & -i\\end{pmatrix} \\begin{pmatrix}1 \\\\ i\\end{pmatrix} - \\left(\\frac{1}{2}(0))\\right)^2}\\\\\n",
"\n",
" \\Delta X & =\\sqrt{\\frac{1}{2}(2)} = 1\n",
" \\end{aligned}\n",
" $$\n",
" \n",
"\n",
"\n",
"Possiamo creare uno stato iniziale arbitrario usando `qc.initialize()`. Si noti che la sintassi per l'unità immaginaria è $1j$.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "bf16b90b-d77a-477b-b432-963f8b81feed",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"-0.02408454165642664\n"
]
}
],
"source": [
"# Step 1: Map the problem into a quantum circuit\n",
"\n",
"from qiskit.quantum_info import SparsePauliOp\n",
"import numpy as np\n",
"\n",
"obs = SparsePauliOp(\"X\")\n",
"\n",
"# Define registers\n",
"qr = QuantumRegister(1, \"q\")\n",
"cr = ClassicalRegister(1, \"c\")\n",
"qc = QuantumCircuit(qr, cr)\n",
"\n",
"# Initialize the state\n",
"qc.initialize([1, 1j] / np.sqrt(2))\n",
"\n",
"# Step 2: Transpile the circuit\n",
"\n",
"pm = generate_preset_pass_manager(target=target, optimization_level=3)\n",
"qc_isa = pm.run(qc)\n",
"obs_isa = obs.apply_layout(layout=qc_isa.layout)\n",
"\n",
"# Step 3: Run the circuit on a real quantum computer\n",
"\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 = noisy_estimator.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": "e162abde-f346-4f2c-8358-d95c818a1021",
"metadata": {},
"source": [
"Secondo l'equazione di cui sopra, $(\\Delta X)^2 = 1 - \\langle X \\rangle^2 = 1-(0.0015...)^2 \\rightarrow \\Delta X = 0.999...$ Manteniamo lo stesso stato, ma troviamo il valore di aspettativa di $Z$, ora:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c1918196-a26e-4419-8a25-488a3d1d4cc1",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.04958271968581247\n"
]
}
],
"source": [
"# Step 1: Map the problem into a quantum circuit\n",
"\n",
"obs = SparsePauliOp(\"Z\")\n",
"\n",
"# Define registers\n",
"qr = QuantumRegister(1, \"q\")\n",
"cr = ClassicalRegister(1, \"c\")\n",
"qc = QuantumCircuit(qr, cr)\n",
"\n",
"# Initialize the state to |+>_y\n",
"qc.initialize([1, 1j] / np.sqrt(2))\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(qc)\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(pubs)\n",
"res = job.result()\n",
"\n",
"# Run the job on the Aer simulator with noise model from real backend\n",
"# job = noisy_estimator.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": "8ba18eed-5982-45ca-b0ed-5708b7d4aa17",
"metadata": {},
"source": [
"Potremmo fare gli stessi calcoli di prima, ma vedremmo che la varianza è di nuovo molto vicina a 1.0. Potremmo concludere che $\\Delta X \\Delta Z \\approx 1.0$. In effetti questo è approssimativamente corretto per lo stato che abbiamo scelto. Ma possiamo fare di meglio? O peggio?\n",
"\n",
"Ricordiamo che esiste una relazione di incertezza tra la posizione lungo una direzione, $x,$ e la quantità di moto lungo la stessa direzione, $p_x.$. Per queste variabili, ma la forma più familiare è probabilmente $\\Delta x \\Delta p_x \\geq \\hbar/2$ Se ricordiamo solo questo, potremmo essere tentati di pensare che anche $\\Delta X$ e $\\Delta Z$ possano avere un limite fondamentale di incertezza. Forse è impossibile che il prodotto $\\Delta X \\Delta Z$ raggiunga lo zero? Proviamo con un altro stato e vediamo se questo regge. Questa volta useremo $|\\psi\\rangle = \\frac{1}{\\sqrt{2}}\\begin{pmatrix} 1 \\\\ 1 \\end{pmatrix}.$ Vediamo cosa succede. Si noti che nel codice sottostante, lo stimatore può accettare due serie di circuiti e osservabili nello stesso invio di lavoro.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ef107fd6-03c2-42f2-a51d-e52957cfb82e",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The expectation value of the first observable is: 1.0011036174126302\n",
"The expectation value of the second observable is: 0.0029429797670141016\n"
]
}
],
"source": [
"# Step 1: Map the problem into a quantum circuit\n",
"\n",
"obs1 = SparsePauliOp(\"X\")\n",
"obs2 = SparsePauliOp(\"Z\")\n",
"\n",
"# Define registers\n",
"\n",
"qr = QuantumRegister(1, \"q\")\n",
"cr = ClassicalRegister(1, \"c\")\n",
"qc = QuantumCircuit(qr, cr)\n",
"\n",
"# Initialize the state\n",
"qc.initialize([1, 1] / np.sqrt(2))\n",
"\n",
"# Step 2: Transpile the circuit\n",
"\n",
"pm = generate_preset_pass_manager(target=target, optimization_level=3)\n",
"qc_isa = pm.run(qc)\n",
"obs1_isa = obs1.apply_layout(layout=qc_isa.layout)\n",
"obs2_isa = obs2.apply_layout(layout=qc_isa.layout)\n",
"\n",
"# Step 3: Run the circuit on a real quantum computer\n",
"\n",
"with Batch(backend=backend) as batch:\n",
" estimator = Estimator(mode=batch)\n",
" pubs = [(qc_isa, obs1_isa), (qc_isa, obs2_isa)]\n",
" job = estimator.run(pubs)\n",
" res = job.result()\n",
"batch.close()\n",
"\n",
"# Run the job on the Aer simulator with noise model from real backend\n",
"\n",
"# job = noisy_estimator.run([[qc,obs1],[qc,obs2]])\n",
"# res=job.result()\n",
"\n",
"# Step 4: Return the result in classical form, and analyze.\n",
"\n",
"print(\"The expectation value of the first observable is: \", res[0].data.evs)\n",
"print(\"The expectation value of the second observable is: \", res[1].data.evs)"
]
},
{
"cell_type": "markdown",
"id": "489472e8-eefc-4740-aa7e-eba8e71d0d72",
"metadata": {},
"source": [
"Il valore atteso di $X$ dovrebbe essere vicino a 1.0, ma non dovrebbe superare 1.0. Non preoccupatevi se supera di pochissimo 1.0. Ciò può essere attribuito a fattori quali il rumore e/o l'errore di lettura. Sebbene si tratti di un argomento molto importante, per ora possiamo ignorarlo.\n",
"\n",
"Abbiamo ottenuto un valore di aspettativa di $X$ molto vicino a 1.0 (corrispondente a una varianza molto bassa per $X$ ). Ciò rende il prodotto delle due varianze piuttosto basso:\n",
"\n",
"$$\n",
"\\Delta X \\Delta Z = \\sqrt{1-(0.9853)^2} \\times \\sqrt{1-(-0.00195)^2} = 0.171.\n",
"$$\n",
"\n",
"Anche se non è esattamente zero, questo valore diventa piccolo rispetto agli autovalori degli operatori di Pauli ( $\\pm 1$ ). Si può ricordare che la relazione di incertezza tra posizione e quantità di moto lineare può essere scritta in modo diverso, utilizzando esplicitamente la relazione di commutazione tra gli operatori $x$ e $p_x$ :\n",
"\n",
"$$\n",
"\\Delta x \\Delta p_x \\geq \\frac{1}{2}|\\langle [x,p_x] \\rangle|\n",
"$$\n",
"\n",
"Dove\n",
"\n",
"$$\n",
"[x,p_x] = xp_x-p_xx\n",
"$$\n",
"\n",
"è il commutatore di $x$ e $p_x$.\n",
"\n",
"Questa è la forma che può essere più facilmente estesa agli operatori di Pauli. In generale, per due operatori $A$ e $B$,\n",
"\n",
"$$\n",
"\\Delta A \\Delta B \\geq \\frac{1}{2}|\\langle [A,B] \\rangle|.\n",
"$$\n",
"\n",
"E nel caso delle matrici di Pauli $X$ e $Z$, abbiamo bisogno di $[X,Z]$ per calcolare\n",
"\n",
"$$\n",
"\\Delta X \\Delta Z \\geq \\frac{1}{2}|\\langle [X,Z] \\rangle|.\n",
"$$\n",
"\n",
"Lo mostriamo qui e lasciamo al lettore calcoli simili come esercizio:\n",
"\n",
"$$\n",
"[X,Z] = XZ-ZX = \\begin{pmatrix}0 & 1 \\\\ 1 & 0\\end{pmatrix}\\begin{pmatrix}1 & 0 \\\\ 0 & -1\\end{pmatrix}-\\begin{pmatrix}1 & 0 \\\\ 0 & -1\\end{pmatrix}\\begin{pmatrix}0 & 1 \\\\ 1 & 0\\end{pmatrix}\n",
"$$\n",
"\n",
"$$\n",
"[X,Z] = \\begin{pmatrix}0 & -1 \\\\ 1 & 0\\end{pmatrix}-\\begin{pmatrix}0 & 1 \\\\ -1 & 0\\end{pmatrix} = 2\\begin{pmatrix}0 & -1 \\\\ 1 & 0\\end{pmatrix}\n",
"$$\n",
"\n",
"Si tratta di una risposta perfettamente accettabile, ma con un ulteriore passaggio, vediamo che\n",
"\n",
"$$\n",
"[X,Z] = -2i\\begin{pmatrix}0 & -i \\\\ i & 0\\end{pmatrix}=-2iY\n",
"$$\n",
"\n",
"La nostra relazione di incertezza diventa quindi\n",
"\n",
"$$\n",
"\\Delta X \\Delta Z \\geq |\\langle Y \\rangle|.\n",
"$$\n",
"\n",
"\n",
"\n",
"#### Verifica la tua comprensione\n",
"\n",
"Determinare $[X,Y]$ e $[Y,Z]$. Utilizzare questo dato per scrivere le relazioni di incertezza tra $X$ e $Y$, e $Y$ e $Z$.\n",
"\n",
"\n",
" \n",
" $$\n",
" [X,Y] = XY-YX = \\begin{pmatrix}0 & 1 \\\\ 1 & 0\\end{pmatrix}\\begin{pmatrix}0 & -i \\\\ i & 0\\end{pmatrix}-\\begin{pmatrix}0 & -i \\\\ i & 0\\end{pmatrix}\\begin{pmatrix}0 & 1 \\\\ 1 & 0\\end{pmatrix} = 2 \\begin{pmatrix}i & 0 \\\\ 0 & -i\\end{pmatrix}=2iZ\n",
" $$\n",
"\n",
" $$\n",
" [Y,Z] = YZ-ZY = \\begin{pmatrix}0 & -i \\\\ i & 0\\end{pmatrix}\\begin{pmatrix}1 & 0 \\\\ 0 & -1\\end{pmatrix}-\\begin{pmatrix}1 & 0 \\\\ 0 & -1\\end{pmatrix}\\begin{pmatrix}0 & -i \\\\ i & 0\\end{pmatrix} = 2 \\begin{pmatrix}0 & i \\\\ i & 0\\end{pmatrix}=2iX\n",
" $$\n",
"\n",
" Combinando con la relazione di incertezza generale, abbiamo\n",
"\n",
" $$\n",
" \\Delta X \\Delta Y \\geq |\\langle Z \\rangle|,\n",
" $$\n",
"\n",
" $$\n",
" \\Delta Y \\Delta Z \\geq |\\langle X \\rangle|.\n",
" $$\n",
" \n",
"\n",
"\n",
"\n",
"\n",
"### Verifica la coerenza\n",
"\n",
"Prima di proseguire, verifichiamo la coerenza con il risultato precedente. Abbiamo usato lo stato $|\\psi\\rangle = \\frac{1}{\\sqrt{2}}\\begin{pmatrix} 1 \\\\ 1 \\end{pmatrix}.$ e abbiamo trovato che $\\Delta X \\Delta Z = 0.171.$ Ora sappiamo che questo prodotto deve essere maggiore o uguale a\n",
"\n",
"$$\n",
"|\\langle Y \\rangle|=\\frac{1}{\\sqrt{2}}\\begin{pmatrix} 1 & 1 \\end{pmatrix}\\begin{pmatrix}0 & -i \\\\ i & 0\\end{pmatrix}\\frac{1}{\\sqrt{2}}\\begin{pmatrix} 1 \\\\ 1 \\end{pmatrix}\n",
"$$\n",
"\n",
"$$\n",
"|\\langle Y \\rangle| = \\frac{1}{2}\\begin{pmatrix} 1 & 1 \\end{pmatrix}\\begin{pmatrix} -i \\\\ i \\end{pmatrix} = \\frac{1}{2}(-i+i) = 0.\n",
"$$\n",
"\n",
"Così, in effetti, è, $\\Delta X \\Delta Z = 0.171 \\geq |\\langle Y \\rangle|=0$\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "0ea50490-36e9-4ab6-b9e1-6840f6dedfec",
"metadata": {},
"source": [
"Utilizzate le domande che seguono per costruire un'intuizione su questi risultati:\n",
"\n",
"\n",
"\n",
"#### Verifica la tua comprensione\n",
"\n",
"Rispondere ai seguenti elementi insieme come un set:\n",
"\n",
"(a) Quali stati vi aspettereste che abbiano un'incertezza pari a zero in $X$?\n",
"\n",
"(b) Quali stati vi aspettereste che abbiano un'incertezza pari a zero in $Z$?\n",
"\n",
"(c) In quali stati si otterrebbe un valore di aspettativa nullo $\\langle Y \\rangle$?\n",
"\n",
"(d) Le risposte alle domande precedenti sono coerenti con il caso $\\Delta X \\Delta Z \\geq |\\langle Y \\rangle|$?\n",
"\n",
"(e) Scrivere il codice per verificare esplicitamente questo dato utilizzando lo stimatore.\n",
"\n",
"\n",
" \n",
" (a) Potremmo aspettarci che gli autostati dell'operatore $X$ producano un'incertezza pari a zero in $X$. Infatti, usando $|\\psi\\rangle = |+\\rangle_x,$ abbiamo $\\Delta X = \\sqrt{1-\\langle X \\rangle^2} = \\sqrt{1-1^2} = 0.$\n",
"\n",
" (b) Potremmo aspettarci che gli autostati dell'operatore $Z$ producano un'incertezza nulla in $Z$. Infatti, usando $|\\psi\\rangle = |1\\rangle,$ abbiamo $\\Delta Z = \\sqrt{1-\\langle Z \\rangle^2} = \\sqrt{1-(-1)^2} = 0.$\n",
"\n",
" (c) Ci aspettiamo di trovare $\\langle Y \\rangle=0$ per tutti gli stati che, quando vengono misurati, producono una proiezione positiva sull'asse $y$ con la stessa frequenza di una proiezione negativa. Questi includono gli autostati di $X$ e $Z$.\n",
"\n",
" (d) Sì. Ci si aspetterebbe un valore molto piccolo per il prodotto delle incertezze $\\Delta X \\Delta Z $ per gli autostati di $X$ o $Z$ : $\\Delta X \\Delta Z \\approx 0.$ Questo può valere perché ci aspetteremmo anche $\\langle Y \\rangle=0$ per questi stessi stati. Quindi la relazione di incertezza potrebbe essere soddisfatta.\n",
"\n",
" (e) Un codice come il seguente potrebbe verificarlo:\n",
"\n",
" ```python\n",
" obs1 = SparsePauliOp.from_list(\n",
" [(\"X\", 1.000)]\n",
" )\n",
" obs2 = SparsePauliOp.from_list(\n",
" [(\"Y\", 1.000)]\n",
" )\n",
" obs3 = SparsePauliOp.from_list(\n",
" [(\"Z\", 1.000)]\n",
" )\n",
" qc = QuantumCircuit(1,1)\n",
" qc.ry(pi/2,0)\n",
"\n",
" job = estimator.run([(qc, [[obs1], [obs2], [obs3]])], precision=0.001)\n",
" res=job.result()\n",
" ```\n",
"\n",
" Dove i risultati restituiscono tutti i valori di aspettativa. Per recuperare tutti i valori di aspettativa e calcolare le incertezze, si può utilizzare:\n",
"\n",
" ```python\n",
" xs=res[0].data.evs[0]\n",
" ys=abs(res[0].data.evs[1])\n",
" zs=res[0].data.evs[2]\n",
"\n",
" import math\n",
" prodxz=((1-xs[i]*xs[i])**0.5)*(1-zs[i]*zs[i])**0.5\n",
"\n",
" ```\n",
" \n",
"\n",
"\n",
"Rispondere ai seguenti elementi insieme come un set:\n",
"\n",
"(a) Si può pensare a uno stato in cui si avrebbe un grande valore di aspettativa $\\langle Y \\rangle$?\n",
"\n",
"(b) Vi aspettereste che lo stesso stato abbia una grande o piccola incertezza in $X$?\n",
"\n",
"(c) Vi aspettereste che lo stesso stato abbia una grande o piccola incertezza in $Z$?\n",
"\n",
"(d) Le risposte alle domande precedenti sono coerenti con il caso $\\Delta X \\Delta Z \\geq |\\langle Y \\rangle|$?\n",
"\n",
"(e) Scrivere il codice per verificare esplicitamente questo dato utilizzando lo stimatore.\n",
"\n",
"\n",
" \n",
" (a) Ci aspettiamo di trovare $\\langle Y \\rangle\\approx 1$ per l'autostato di $Y$ : $|+\\rangle_y$.\n",
"\n",
" (b) Potremmo aspettarci che $X$ abbia una grande incertezza nello stato $|+\\rangle_y,$ poiché la misurazione di $X$ in quello stato darebbe un risultato positivo e negativo con uguale frequenza/probabilità.\n",
"\n",
" (c) Potremmo aspettarci che $Z$ abbia una grande incertezza nello stato $|+\\rangle_y,$, poiché la misurazione di $Z$ in quello stato darebbe un risultato positivo e negativo con uguale frequenza/probabilità.\n",
"\n",
" (d) Sì. Ci si aspetterebbe un valore elevato per il prodotto delle incertezze $\\Delta X \\Delta Z $ per gli autostati di $Y,$ e per $|+\\rangle_y,$ in particolare. Ci aspetteremmo anche $\\langle Y \\rangle\\approx 1$ per lo stesso stato. Quindi sia $\\langle Y \\rangle$ che $\\Delta X \\Delta Z $ sono entrambi abbastanza grandi in questo stato, ed è plausibile che la relazione di incertezza possa essere nuovamente soddisfatta.\n",
"\n",
" (e) Un codice come il seguente potrebbe verificarlo:\n",
"\n",
" ```python\n",
" obs1 = SparsePauliOp.from_list(\n",
" [(\"X\", 1.000)]\n",
" )\n",
" obs2 = SparsePauliOp.from_list(\n",
" [(\"Y\", 1.000)]\n",
" )\n",
" obs3 = SparsePauliOp.from_list(\n",
" [(\"Z\", 1.000)]\n",
" )\n",
" qc = QuantumCircuit(1,1)\n",
" qc.rx(-pi/2,0)\n",
"\n",
" job = estimator.run([(qc, [[obs1], [obs2], [obs3]])], precision=0.001)\n",
" res=job.result()\n",
" ```\n",
"\n",
" Dove i risultati restituiscono tutti i valori di aspettativa. Per recuperare tutti i valori di aspettativa e calcolare le incertezze, si può utilizzare:\n",
"\n",
" ```python\n",
" xs=res[0].data.evs[0]\n",
" ys=abs(res[0].data.evs[1])\n",
" zs=res[0].data.evs[2]\n",
"\n",
" import math\n",
" prodxz=((1-xs[i]*xs[i])**0.5)*(1-zs[i]*zs[i])**0.5\n",
"\n",
" ```\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "26f11700-d6be-4ce1-9f97-b2d47ea933ec",
"metadata": {},
"source": [
"\n",
"\n",
"## Relazioni di incertezza nei test\n",
"\n",
"Il test precedente ha dimostrato la validità della relazione di incertezza solo per una singola scelta del vettore di stato $|\\psi\\rangle = |+\\rangle_x$. Per convincerci che questa relazione è generalmente coerente con l'esperimento, dovremmo eseguire calcoli simili utilizzando lo stimatore per molte scelte del vettore di stato. Cominciamo a ruotare il nostro vettore di stato lontano dall'asse $z$, usando un gate `RY` per produrre diversi stati iniziali usando un parametro $\\theta$.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c434a14d-c0ce-40bd-8f5e-7d35722e97bb",
"metadata": {},
"outputs": [],
"source": [
"# The calculation below uses approximately 3-4 minutes of QPU time.\n",
"# Step 1: Map the problem into a quantum circuit\n",
"\n",
"from qiskit.circuit import Parameter\n",
"import numpy as np\n",
"\n",
"# Specify observables\n",
"obs1 = SparsePauliOp(\"X\")\n",
"obs2 = SparsePauliOp(\"Y\")\n",
"obs3 = SparsePauliOp(\"Z\")\n",
"\n",
"# Define registers\n",
"qr = QuantumRegister(1, \"q\")\n",
"cr = ClassicalRegister(1, \"c\")\n",
"qc = QuantumCircuit(qr, cr)\n",
"\n",
"# Rotate away from |0>\n",
"theta = Parameter(\"θ\")\n",
"qc.ry(theta, 0)\n",
"\n",
"params = np.linspace(0, 2, num=21)\n",
"\n",
"# Step 2: Transpile the circuit\n",
"\n",
"pm = generate_preset_pass_manager(target=target, optimization_level=3)\n",
"qc_isa = pm.run(qc)\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",
"# Step 3: Run the circuit on a real quantum computer\n",
"\n",
"with Batch(backend=backend) as batch:\n",
" estimator = Estimator(mode=batch)\n",
" pubs = [(qc_isa, [[obs1_isa], [obs2_isa], [obs3_isa]], [params])]\n",
" job = estimator.run(pubs, precision=0.01)\n",
" res = job.result()\n",
"\n",
"batch.close()\n",
"\n",
"# Run the job on the Aer simulator with noise model from real backend\n",
"\n",
"# job = noisy_estimator.run([(qc, [[obs1], [obs2], [obs3]], [params])])\n",
"# res=job.result()"
]
},
{
"cell_type": "code",
"execution_count": 18,
"id": "41d974bb-da9e-459e-8145-294f71cab4c7",
"metadata": {},
"outputs": [],
"source": [
"# Step 4: Post-processing and classical analysis.\n",
"xs = res[0].data.evs[0]\n",
"ys = abs(res[0].data.evs[1])\n",
"zs = res[0].data.evs[2]\n",
"\n",
"# Calculate uncertainties\n",
"\n",
"delx = []\n",
"delz = []\n",
"prodxz = []\n",
"for i in range(len(xs)):\n",
" delx.append(abs((1 - xs[i] * xs[i])) ** 0.5)\n",
" delz.append(abs((1 - zs[i] * zs[i])) ** 0.5)\n",
" prodxz.append(delx[i] * delz[i])"
]
},
{
"cell_type": "code",
"execution_count": 19,
"id": "1599d4df-38f8-4171-95ae-6c3c61409201",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# Here we can plot the results from this simulation.\n",
"import matplotlib.pyplot as plt\n",
"\n",
"plt.plot(params, delx, label=r\"$\\Delta$ X\")\n",
"plt.plot(params, ys, label=r\"$\\langle$ Y $\\rangle$\")\n",
"plt.plot(params, delz, label=r\"$\\Delta$ Z\")\n",
"plt.plot(params, prodxz, label=r\"$\\Delta$X $\\Delta$Z\")\n",
"plt.xlabel(r\"$\\theta$\")\n",
"plt.ylabel(\"Expectation/Uncertainty Values\")\n",
"plt.legend()\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "1694ab4f-b5e2-46be-b453-2599f73c582d",
"metadata": {},
"source": [
"Si noti che la curva rossa $(\\Delta X \\Delta Z)$ è sempre maggiore della curva arancione $\\langle Y \\rangle.$ A volte il prodotto dell'incertezza si abbassa e si avvicina al limite, altre volte si alza e si allontana dal limite, ma obbedisce sempre alla relazione di incertezza.\n",
"\n",
"Naturalmente, questo potrebbe non essere il miglior test della relazione di incertezza, poiché il nostro limite $\\langle Y \\rangle$ è sempre molto vicino a zero. Utilizziamo uno stato quantico che abbia una proiezione maggiore sugli autostati di $Y$. In particolare, ruoteremo ancora $|0\\rangle$ verso il basso rispetto all'asse $z$ di vari angoli, ma ora ruoteremo anche lo stato risultante intorno a $z$ di un certo angolo, forse $\\pi/4$, e vedremo cosa succede.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c9700dd1-d116-4f94-8c81-70383ce38671",
"metadata": {},
"outputs": [],
"source": [
"# The calculation below uses approximately 3-4 minutes of QPU time.\n",
"from qiskit.circuit import Parameter\n",
"import numpy as np\n",
"\n",
"# Step 1: Map the problem to a quantum circuit\n",
"\n",
"# Specify observables\n",
"obs1 = SparsePauliOp(\"X\")\n",
"obs2 = SparsePauliOp(\"Y\")\n",
"obs3 = SparsePauliOp(\"Z\")\n",
"\n",
"# Define registers\n",
"qr = QuantumRegister(1, \"q\")\n",
"cr = ClassicalRegister(1, \"c\")\n",
"qc = QuantumCircuit(qr, cr)\n",
"\n",
"# Rotate away from |0> along one plane, and then along a transverse direction.\n",
"theta = Parameter(\"θ\")\n",
"qc.ry(theta, 0)\n",
"qc.rz(pi / 4, 0)\n",
"\n",
"params = np.linspace(0, 2, num=21)\n",
"\n",
"# Step 2: Transpile the circuit\n",
"\n",
"pm = generate_preset_pass_manager(target=target, optimization_level=3)\n",
"qc_isa = pm.run(qc)\n",
"\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",
"# Step 3: Run the circuit on a real quantum computer\n",
"\n",
"with Batch(backend=backend) as batch:\n",
" estimator = Estimator(mode=batch)\n",
" pubs = [(qc_isa, [[obs1_isa], [obs2_isa], [obs3_isa]], [params])]\n",
" job = estimator.run(pubs, precision=0.01)\n",
" res = job.result()\n",
"\n",
"batch.close()\n",
"\n",
"# Run the job on the Aer simulator with noise model from real backend\n",
"\n",
"# job = noisy_estimator.run([(qc, [[obs1], [obs2], [obs3]], [params])])\n",
"# res=job.result()"
]
},
{
"cell_type": "code",
"execution_count": 21,
"id": "7e85e759-33a7-4539-80f7-05c769c46144",
"metadata": {},
"outputs": [],
"source": [
"# Step 4: Post-processing and classical analysis.\n",
"xs = res[0].data.evs[0]\n",
"ys = abs(res[0].data.evs[1])\n",
"zs = res[0].data.evs[2]\n",
"\n",
"# Calculate uncertainties\n",
"\n",
"delx = []\n",
"delz = []\n",
"prodxz = []\n",
"for i in range(len(xs)):\n",
" delx.append(abs((1 - xs[i] * xs[i])) ** 0.5)\n",
" delz.append(abs((1 - zs[i] * zs[i])) ** 0.5)\n",
" prodxz.append(delx[i] * delz[i])"
]
},
{
"cell_type": "code",
"execution_count": 22,
"id": "6f129a2d-e029-45b7-bb77-bfa83babd8c9",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# Here we can plot the results from this simulation.\n",
"import matplotlib.pyplot as plt\n",
"\n",
"plt.plot(params, delx, label=r\"$\\Delta$ X\")\n",
"plt.plot(params, ys, label=r\"$\\langle$ Y $\\rangle$\")\n",
"plt.plot(params, delz, label=r\"$\\Delta$ Z\")\n",
"plt.plot(params, prodxz, label=r\"$\\Delta$X $\\Delta$Z\")\n",
"plt.xlabel(r\"$\\theta$\")\n",
"plt.ylabel(\"Expectation/Uncertainty Values\")\n",
"plt.legend()\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "7b90bcd5-f561-4f7f-a5a3-7882b3ddb464",
"metadata": {},
"source": [
"Ora vediamo che il limite dell'incertezza $(\\Delta X \\Delta Z)$ viene messo alla prova! La curva rossa si avvicina molto di più alla curva arancione rispetto a prima. Infatti, in assenza di rumore, la relazione di indeterminazione sarebbe esattamente saturata ( $(\\Delta X \\Delta Z) = \\langle Y \\rangle$ ) un punto. In presenza di rumore ed errore di lettura, non dovrebbe sorprendere se occasionalmente una corsa produca $(\\Delta X \\Delta Z)$ un risultato leggermente superiore a $\\langle Y \\rangle.$ Questo non è un vero e proprio caso di violazione dell'incertezza, ma solo un artefatto dell'errore diverso da zero.\n",
"\n",
"\n",
"\n",
"#### Verifica la tua comprensione\n",
"\n",
"Spiega come porteresti questo concetto al limite estremo, rendendo l’ $\\langle Y \\rangle$ e il più ampio possibile.\n",
"\n",
"\n",
" \n",
" Il codice attualmente contiene linee che ruotano lo stato iniziale predefinito $|0\\rangle$, verso il basso rispetto all'asse $z$ di un angolo parametrizzato $\\theta$ e poi anche intorno all'asse $z$ di un angolo $\\pi/4,$ che ruota il vettore di stato per una parte del percorso verso l'asse $y$.\n",
"\n",
" `qc.ry(theta,0)`\n",
"\n",
" `qc.rz(pi/4,0)`\n",
"\n",
" Potremmo cambiare la rotazione intorno a $z$ da $\\pi/4$ a $\\pi/2$, ruotando fino a un autostato di $Y$ :\n",
"\n",
" `qc.ry(theta,0)`\n",
"\n",
" `qc.rz(pi/2,0)`\n",
"\n",
" Non sono necessarie altre modifiche.\n",
" \n",
"\n",
"\n",
"Modificare il codice o copiarlo e implementare il controllo della relazione di incertezza con il valore di aspettativa di Y massimizzato. La relazione di incertezza è valida?\n",
"\n",
"\n",
" \n",
" Si utilizzerà esattamente il codice dell'esempio precedente, con\n",
"\n",
" `qc.rz(pi/2,0)`\n",
"\n",
" sostituita da un'altra per sostituire\n",
"\n",
" `qc.rz(pi/4,0).`\n",
"\n",
" La figura risultante dovrebbe assomigliare a quella qui sotto, e sì, il principio di indeterminazione dovrebbe essere ancora valido.\n",
"\n",
" \n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "6dd8c749-00d6-4a08-8d3c-2f5b5f3a0902",
"metadata": {},
"source": [
"Modificate il codice precedente per realizzare un'immagine simile, dimostrando che dalle misure sul computer quantistico il prodotto $\\Delta X \\Delta Y$ si comporta come dovrebbe. Scegliere una serie di stati a piacere.\n",
"\n",
"\n",
" \n",
" Utilizzeremmo esattamente il codice dell'esempio precedente e, in effetti, potremmo usare gli stessi risultati di prima, solo utilizzando i valori di aspettativa per calcolare le diverse incertezze. Ad esempio, si può usare\n",
"\n",
" ```python\n",
" xs=res[0].data.evs[0]\n",
" ys=res[0].data.evs[1]\n",
" zs=abs(res[0].data.evs[2])\n",
" import math\n",
" delx = []\n",
" dely = []\n",
" prodxy=[]\n",
" for i in range(len(xs)):\n",
" delx.append((1-xs[i]*xs[i])**0.5)\n",
" dely.append((1-ys[i]*ys[i])**0.5)\n",
" prodxy.append(((1-xs[i]*xs[i])**0.5)*(1-ys[i]*ys[i])**0.5)\n",
" ```\n",
"\n",
" e potremmo tracciare\n",
"\n",
" ```python\n",
" import matplotlib.pyplot as plt\n",
" plt.plot(params, delx, label=r'$\\Delta$ X')\n",
" plt.plot(params, dely, label=r'$\\langle$ Y $\\rangle$')\n",
" plt.plot(params, zs, label=r'$\\Delta$ Z')\n",
" plt.plot(params, prodxy, label=r'$\\Delta$X $\\Delta$Z')\n",
" plt.xlabel(r'$\\theta$')\n",
" plt.ylabel('Expectation/Uncertainty Values')\n",
" plt.legend()\n",
" plt.show()\n",
" ```\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "571a0120-a9d3-44c5-9dce-1b021090f9d1",
"metadata": {},
"source": [
"Sfida: Scrivere un codice per analizzare molti valori di $\\phi$, così come abbiamo analizzato molti valori di $\\theta$, e creare un grafico 3D che mostri che la relazione di incertezza non viene mai violata. Scegliere gli osservabili desiderati.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "b89eaae3-6ea9-486c-b93c-55431839d5f1",
"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",
"* Esistono relazioni di incertezza tra molti insiemi di osservabili fisici, tra cui la posizione, la quantità di moto lineare e le componenti dello spin.\n",
"* Le matrici di Pauli non commutano. Questo è un riflesso matematico del fatto che non tutte le componenti dello spin possono essere conosciute/determinate simultaneamente.\n",
"* L'informatica quantistica fa un uso massiccio degli operatori/matrici di Pauli, quindi è utile conoscere la relazione di incertezza per gli operatori di Pauli e per gli operatori di spin strettamente correlati.\n",
"* Una formula generale per l'incertezza di due operatori $A$ e $B$ è $\\Delta A \\Delta B \\geq \\frac{1}{2}|\\langle [A,B] \\rangle|.$\n",
"* Uno stato proprio $|a\\rangle$ di un operatore $A$ comporta un'incertezza pari a zero nell'osservabile fisico associato a tale operatore. Anche a livello sperimentale, $\\Delta A \\approx 0.$\n",
"* Un autostato $|a\\rangle$ di un qualche operatore $A$ produrrà un'incertezza maggiore per un operatore $B$ che non commuta con $A$.\n",
"* I risultati sperimentali ottenuti con un computer quantistico reale confermano l'intuizione che si ottiene dalle rappresentazioni matriciali degli operatori fisici.\n",
"\n",
"\n",
"\n",
"### Domande vero/falso:\n",
"\n",
"1. T/F Si possono misurare contemporaneamente $X$ e $Y$, ma non $Z$.\n",
"2. T/F Si possono misurare contemporaneamente $X$ e $Z$, ma non $Y$.\n",
"3. T/F Gli operatori di posizione lineare e di quantità di moto lineare non si commutano.\n",
"4. T/F IBM computer quantistici misurano per default lungo $Z$, quindi è necessario eseguire una rotazione per misurare lungo qualsiasi altra direzione.\n",
"5. T/F Il circuito sottostante misura effettivamente $Z$ e poi $X$.\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"### Domande dell'MC:\n",
"\n",
"1. Il diagramma seguente dimostra quale delle seguenti relazioni di incertezza?\n",
"\n",
" * a. $\\Delta X \\Delta Y \\geq |\\langle Z \\rangle|$\n",
" * b. $\\Delta Y \\Delta Z \\geq |\\langle X \\rangle|$\n",
" * c. $\\Delta Z \\Delta X \\geq |\\langle Y \\rangle|$\n",
" * d. Nessuna delle precedenti\n",
"\n",
"\n",
"\n",
"2. Quale delle seguenti è la sequenza standard per eseguire una misura lungo $x$?\n",
" * a. Solo `qc.measure()`\n",
" * b. `qc.h()` allora `qc.measure()`\n",
" * c. `qc.h()`, `qc.h()` allora `qc.measure()`\n",
" * d. `qc.h()`, `qc.s`, `qc.h()`allora `qc.measure()`\n",
" * e. `qc.sdg()`, `qc.h()`, `qc.s` allora `qc.measure()`\n",
" * f. `qc.sdg()`, `qc.h()`, `qc.s`, `qc.h()` poi `qc.measure()`\n",
"\n",
"3. Quale dei seguenti stati produce il più grande valore di aspettativa $\\langle X \\rangle$?\n",
" * a. $|+\\rangle_x$\n",
" * b. $|-\\rangle_x$\n",
" * c. $|+\\rangle_y$ chiamato anche $|+i\\rangle$\n",
" * d. $|-\\rangle_y$ chiamato anche $|-i\\rangle$\n",
" * e. $|0\\rangle$ chiamato anche $|\\uparrow\\rangle$\n",
" * f. $|1\\rangle$ chiamato anche $|\\downarrow\\rangle$\n",
"\n",
"4. Quale dei seguenti stati produce la maggiore incertezza $\\Delta X$?\n",
" * a. $|+\\rangle_x$\n",
" * b. $|+\\rangle_y$ chiamato anche $|+i\\rangle$\n",
" * c. $|0\\rangle$ chiamato anche $|\\uparrow\\rangle$\n",
" * d. a e b sono in parità\n",
" * e. b e c sono in parità\n",
" * f. a, b e c sono in parità\n",
"\n",
"\n",
"\n",
"### Domande di discussione:\n",
"\n",
"1. Questo concetto di incertezza è in qualche modo in conflitto con la nozione di spin come freccia vettoriale nello spazio cartesiano? E sulla sfera di Bloch?\n",
"\n",
"2. Supponiamo di orientare un dispositivo di misura lungo una direzione a metà strada tra gli assi $x$ e $y$. Cosa succede? È possibile effettuare una misurazione in questa direzione? In che modo questo si collega all'incertezza di $X$ e $Y$?\n",
"\n",
"3. Quali altri esperimenti vorreste fare per convincervi dei risultati ottenuti?\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": 4
}