Esplorare l'incertezza

Per questo modulo Qiskit in Classrooms, gli studenti devono disporre di un ambiente Python funzionante con i seguenti pacchetti installati:

• qiskit v2.1.0 o successivo
• qiskit-ibm-runtime v0.40.1 o successivo
• qiskit-aer v0.17.0 o successivo
• qiskit.visualization
• numpy
• pylatexenc

Per configurare e installare i pacchetti elencati sopra, consulta la guida Installare Qiskit. Per eseguire job su veri computer quantistici, gli studenti dovranno creare un account IBM Quantum® seguendo i passaggi descritti nella guida Configura il tuo account IBM Cloud.

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 particolarmente dispendiosi in termini di tempo sono segnalati come tali nei commenti dell'intestazione e possono essere eseguiti su simulatori se gli studenti dispongono di poco tempo QPU. Senza di essi, il modulo richiede solo circa 30 secondi di tempo QPU.

# Added by doQumentation — required packages for this notebook
!pip install -q matplotlib numpy qiskit qiskit-aer qiskit-ibm-runtime

# Uncomment and modify this line as needed to install dependencies
#!pip install 'qiskit>=2.1.0' 'qiskit-ibm-runtime>=0.40.1' 'qiskit-aer>=0.17.0' 'numpy' 'pylatexenc'

Guarda il video introduttivo del modulo della Dr.ssa Katie McCormick qui sotto, oppure clicca qui per vederlo su YouTube.

---

Introduzione

Hai probabilmente sentito parlare del principio di indeterminazione, anche al di fuori dei tuoi corsi di fisica. Una riformulazione colloquiale comune dell'incertezza è: "Osservando qualcosa, lo si influenza." Questo è certamente vero. Ma un modo più fisico di descrivere l'incertezza è che esistono alcune osservabili fisiche tra loro incompatibili, che non possono essere entrambe conosciute simultaneamente con precisione arbitraria. Molti studenti incontrano per la prima volta la coppia di variabili incompatibili $x$ e $p_x$, ovvero la posizione lungo un asse chiamato $x$ e la quantità di moto lineare lungo quella direzione, rispettivamente. Per tali variabili, il vincolo sull'incertezza è scritto come $\Delta x \Delta p_x \geq \frac{\hbar}{2}.$ Qui, $\Delta x$ è chiamato "incertezza in $x$", che ha la stessa definizione della deviazione standard in statistica, e può essere definito come $\Delta x = \sqrt{\langle x^2 \rangle - \langle x \rangle^2}.$ $\Delta p_x$ è definito nello stesso modo. Qui non ricaveremo questa relazione di indeterminazione; osserveremo solo che essa è coerente con la nostra comprensione delle onde classiche. Cioè, un'onda con una sola frequenza $f$ e lunghezza d'onda $\lambda$ perfettamente definita si estenderebbe all'infinito come un sinusoide perfetto. In meccanica quantistica, questo corrisponderebbe a conoscere il momento con precisione assoluta secondo l'ipotesi di de Broglie: $\lambda = h/p$. Ma per sapere $dove$ si trova una particella di tipo ondulatorio, l'onda che la descrive deve diventare più concentrata nello spazio, come una gaussiana molto stretta, ad esempio. Sappiamo che possiamo esprimere qualsiasi funzione continua, comprese queste funzioni d'onda molto concentrate, come serie di Fourier di funzioni sinusoidali con diverse lunghezze d'onda. Ma man mano che la funzione d'onda diventa più concentrata (e la posizione è meglio nota), saranno necessari più termini nella serie di Fourier, ovvero una combinazione di più lunghezze d'onda (e quindi, in meccanica quantistica, di più valori di momento).

Detto in modo più semplice: uno stato con momento ben definito (un sinusoide perfetto nello spazio) ha una posizione molto indeterminata. Uno stato con posizione ben definita (come una distribuzione delta di Dirac) ha un momento molto indeterminato.

Esistono altre variabili che mostrano tale incompatibilità. Ad esempio, lo spin di una particella può avere una proiezione ben definita lungo un asse, ma allora 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$ (pari a 1 nel contesto di un qubit, e a $\hbar/2$ nel contesto di una particella spin-1/2). Ma questo stato può essere scritto come sovrapposizione di due stati, ciascuno dei quali ha una proiezione ben definita sull'asse $x$: $|0\rangle = \frac{1}{\sqrt{2}}(|+\rangle_x+|-\rangle_x)$ oppure in modo equivalente $\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 alcune differenze minori quando si discute ciò nel contesto dello spin e dei qubit. In linea generale, però, gli autostati delle matrici di Pauli hanno una relazione interessante che possiamo esplorare. In tutta questa lezione, verificheremo sperimentalmente la nostra intuizione sull'incertezza in queste variabili incompatibili e verificheremo che le relazioni di indeterminazione siano rispettate sui computer quantistici IBM®.

Verifica semplice dell'intuizione

In questo primo esperimento e durante tutto il modulo, utilizzeremo un framework per il quantum computing noto come "Qiskit patterns", che suddivide i flussi di lavoro nei seguenti passi:

• Passo 1: Mappa gli input classici in un problema quantistico
• Passo 2: Ottimizza il problema per l'esecuzione quantistica
• Passo 3: Esegui usando le Primitive di Qiskit Runtime
• Passo 4: Post-elaborazione e analisi classica

Seguiremo generalmente questi passi, anche se non li etichetteremo sempre esplicitamente.

Iniziamo caricando alcuni pacchetti necessari, incluse le primitive di Runtime. Selezioneremo anche il computer quantistico meno occupato disponibile.

Il codice sottostante contiene le istruzioni per salvare le tue credenziali al primo utilizzo. Assicurati di eliminare queste informazioni dal notebook dopo averle salvate nel tuo ambiente, in modo che le tue credenziali non vengano condivise accidentalmente quando condividi il notebook. Consulta Configura il tuo account IBM Cloud e Inizializza il servizio in un ambiente non attendibile per ulteriori indicazioni.

from numpy import pi

# Load the Qiskit Runtime service
from qiskit_ibm_runtime import QiskitRuntimeService

# Syntax for first saving your token.  Delete these lines after saving your credentials.
# QiskitRuntimeService.save_account(channel='ibm_quantum_platform', instance = '<YOUR_IBM_INSTANCE_CRN>', token='<YOUR-API_KEY>', overwrite=True, set_as_default=True)
# service = QiskitRuntimeService(channel='ibm_quantum_platform')

# Load saved credentials
service = QiskitRuntimeService()

# Load the Runtime primitive and session
from qiskit_ibm_runtime import (
    Batch,
    SamplerV2 as Sampler,
    EstimatorV2 as Estimator,
)

# Use the least busy backend
backend = service.least_busy(min_num_qubits=127)
print(backend.name)

ibm_sherbrooke

Se uno studente esaurisce il tempo di quantum computing disponibile durante la lezione, le righe sottostanti possono essere decommentate e utilizzate per configurare un simulatore che riproduce in parte il comportamento rumoroso del computer quantistico selezionato sopra.

# Import an estimator, this time from qiskit (we will import from Runtime for real hardware)
from qiskit_aer.primitives import SamplerV2, EstimatorV2
from qiskit_aer.noise import NoiseModel

# Generate the noise model from the backend properties
noise_model = NoiseModel.from_backend(backend)

noisy_sampler = SamplerV2(options={"backend_options": {"noise_model": noise_model}})
noisy_estimator = EstimatorV2(options={"backend_options": {"noise_model": noise_model}})

Ricorderai che un autostato di un operatore, Z, non è un autostato di un altro operatore X. Lo osserveremo ora sperimentalmente, effettuando misurazioni lungo gli assi $x$ e $z$. Per la misurazione lungo $z$, usiamo semplicemente qc.measure(), poiché i computer quantistici IBM sono strutturati per misurare lungo $z$. Ma per misurare lungo $x$, dobbiamo ruotare il sistema in modo da portare effettivamente l'asse $x$ nella direzione di misurazione. Questo si ottiene con un gate di Hadamard. Un passaggio simile è necessario per le misurazioni lungo $y$. I passaggi necessari sono raccolti qui per comodità:

• Per misurare lungo $z$: qc.measure()
• Per misurare lungo $x$: qc.h() poi qc.measure()
• Per misurare lungo $y$: qc.sdg(), qc.h(), qc.s poi qc.measure()

Passo 1: Mappa gli input classici in un problema quantistico

In questo caso, il passo di mappatura consiste semplicemente nell'esprimere le misurazioni e le rotazioni descritte sopra in un circuito quantistico:

# Step 1: Map

# Import some general packages
from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister

# Define registers
qr = QuantumRegister(1, "q")
cr = ClassicalRegister(2, "c")
qc = QuantumCircuit(qr, cr)

# Add a first measurement
qc.measure(qr, cr[0])
qc.barrier()

# Change basis so that measurements made on quantum computer which normally tell us about z, now tell us about x.
qc.h(qr)

# Add a second measurement
qc.measure(qr, cr[1])

qc.draw("mpl")

Passo 2: Ottimizza il problema per l'esecuzione quantistica

Questo passo prende le operazioni che vogliamo eseguire e le esprime in termini delle funzionalità di uno specifico computer quantistico. Mappa inoltre il nostro problema sulla topologia del computer quantistico.

# Step 2: Transpile
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)

qc_isa = pm.run(qc)

Passo 3: Esegui usando le primitive di Qiskit Runtime

Possiamo usare il Sampler per raccogliere statistiche sulle misurazioni. Costruiremo la primitiva Sampler per l'esecuzione su un vero computer quantistico usando mode = backend. Esistono altre modalità per altri flussi di lavoro, e ne utilizzeremo una in seguito. Il Sampler verrà usato chiamando il suo metodo run() con una lista di "pub" (Primitive Unified Blocs). Ogni pub contiene fino a tre valori che, insieme, definiscono un'unità di lavoro computazionale che l'estimator deve completare: circuit, osservabili, parametri. È anche possibile fornire una lista di circuit, una lista di osservabili e una lista di parametri. Per ulteriori informazioni, leggi la Panoramica dei PUB.

Vogliamo eseguire su un vero computer quantistico, in modo da effettuare un vero esperimento di fisica quantistica. Se esaurisci il tempo disponibile sui computer quantistici reali, puoi commentare il codice sottostante per il computer quantistico e decommentare il codice per l'esecuzione su un simulatore.

# Step 3: Run the job on a real quantum computer

sampler = Sampler(mode=backend)
pubs = [qc_isa]
job = sampler.run(pubs)
res = job.result()

counts = res[0].data.c.get_counts()

# Run the job on the Aer simulator with noise model from real backend

# job = noisy_sampler.run([qc_isa])
# res=job.result()
# counts=res[0].data.c.get_counts()

Passo 4: Post-elaborazione

Questo è un caso di post-elaborazione particolarmente semplice, in cui visualizziamo semplicemente i conteggi.

Nota che Qiskit ordina i qubit, le misurazioni e altri elementi elencando il numero più basso per ultimo / a destra, una convenzione denominata "little-endian". Ciò significa che la colonna etichettata "10" di seguito si riferisce ai conteggi in cui la prima misurazione ha restituito "0" e la seconda misurazione ha restituito "1".

# Step 4: Post-process

from qiskit.visualization import plot_histogram

plot_histogram(counts)

Se questa convenzione non ti piace, puoi usare marginal_counts per visualizzare i risultati di ogni misurazione separatamente:

from qiskit.result import marginal_counts

plot_histogram(
    marginal_counts(counts, indices=[0]), title="Counts after first measurement"
)

plot_histogram(
    marginal_counts(counts, indices=[1]), title="Counts after second measurement"
)

Per impostazione predefinita, gli stati in Qiskit vengono inizializzati allo stato $|0\rangle$. Non sorprende quindi che quasi tutte le prime misurazioni abbiano restituito $|0\rangle$. Nota però che nella seconda misurazione (quella che fornisce informazioni sulle proiezioni dello stato su $x$) c'è stato quasi un pareggio. Sembra che questo stato, che ci dà un risultato molto prevedibile per le misurazioni lungo $z$, ci dia un insieme di risultati molto imprevedibile per le misurazioni lungo $x$. Esploriamo questo aspetto.

Cosa succede se effettuiamo le misurazioni nell'ordine inverso? Potremmo iniziare usando il gate di Hadamard per ottenere statistiche sulla probabilità di misurare $|0\rangle$ in $|\pm\rangle_x$. Poi, per la seconda misurazione, torneremo alla base $z$ usando un secondo gate di Hadamard.

# Step 1:

# Define registers
qr = QuantumRegister(1, "q")
cr = ClassicalRegister(2, "c")
qc = QuantumCircuit(qr, cr)

# Change basis to measure along x.
qc.h(qr)
qc.measure(qr, cr[0])
qc.barrier()

# Change our basis back to z and make a second measurement
qc.h(qr)
qc.measure(qr, cr[1])

qc.draw("mpl")

# Step 2: Transpile the circuit for running on a quantum computer

pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)

# Step 3: Run the job on a real quantum computer

sampler = Sampler(mode=backend)
pubs = [qc_isa]
job = sampler.run(pubs)
res = job.result()
counts = res[0].data.c.get_counts()

# Run the job on the Aer simulator with noise model from real backend
# job = noisy_sampler.run([qc_isa])
# res=job.result()
# counts=res[0].data.c.get_counts()

# Step 4: Post-process
from qiskit.visualization import plot_histogram

plot_histogram(counts)

Qui sembriamo avere ancora meno prevedibilità! In precedenza, almeno sapevamo quale sarebbe stato l'esito della prima misurazione; ora abbiamo una distribuzione piuttosto uniforme su tutti i possibili stati. Non è difficile capire perché sia successo. Siamo partiti da $|0\rangle$, che è una miscela 50-50 di $|+\rangle_x$ e $|-\rangle_x$, secondo $|0\rangle=\frac{1}{\sqrt{2}}(|+\rangle_x+|-\rangle_x)$ Quindi, chiaramente, la probabilità di ottenere lo stato + o - (mappato rispettivamente a 0 e 1 nel grafico) per la prima misurazione deve essere uguale. La misurazione lungo $x$ collassa lo stato in uno degli autostati $|+\rangle_x$ oppure $|-\rangle_x$. Ciascuno di questi stati è una miscela 50-50 di $|0\rangle$ e $|1\rangle$, secondo $|+\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$, le misurazioni lungo $z$ daranno ovviamente sia $|0\rangle$ che $|1\rangle$, e lo faranno con probabilità approssimativamente uguali. Il nostro primo esempio ci ha mostrato che alcuni stati hanno risultati molto prevedibili per alcune misurazioni, ma imprevedibili per altre. L'esempio attuale ci mostra che si può fare peggio: ci sono stati che possono darci risultati imprevedibili per entrambe le misurazioni, anche se ci limitiamo a scambiare l'ordine delle misurazioni. Indaghiamo quanto una grandezza sia certa o incerta per un dato stato.

Calcolare l'incertezza

Possiamo quantificare tutto ciò usando l'incertezza, o varianza. L'"incertezza" è spesso definita come la radice quadrata della "varianza" di una distribuzione. Ovvero, l'incertezza per un'osservabile $S$ si denota $\Delta S$ ed è data da

$$\begin{aligned} (\Delta S)^2 & \equiv \langle (S - \langle S \rangle)^2 \rangle\\ (\Delta S)^2 & = \langle S^2 - 2 S \langle S \rangle +\langle S \rangle^2 \rangle\\ (\Delta S)^2 & = \langle S^2 \rangle - \langle S \rangle^2 \end{aligned}$$

Nel caso delle matrici di Pauli, per cui $S^2 = I$, questa diventa

$$(\Delta S)^2 = 1 - \langle S \rangle^2$$

Applichiamo questo 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.

Verifica la comprensione

Leggi la domanda qui sotto, rifletti sulla risposta, poi clicca il triangolo per vedere la soluzione.

Calcola a mano l'incertezza di $X$ nello stato $|+\rangle_y = |+i\rangle$.

Risposta:

$$\Delta X =\sqrt{\langle+i| X^2 |+i\rangle - \langle+i| X |+i\rangle^2}$$

Nello stato dato, questo produce:

$$\begin{aligned} \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}\\ \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}\\ \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}\\ \Delta X & =\sqrt{\frac{1}{2}(2)} = 1 \end{aligned}$$

Possiamo creare uno stato iniziale arbitrario usando qc.initialize(). Nota che la sintassi per l'unità immaginaria qui è $1j$.

# Step 1: Map the problem into a quantum circuit

from qiskit.quantum_info import SparsePauliOp
import numpy as np

obs = SparsePauliOp("X")

# Define registers
qr = QuantumRegister(1, "q")
cr = ClassicalRegister(1, "c")
qc = QuantumCircuit(qr, cr)

# Initialize the state
qc.initialize([1, 1j] / np.sqrt(2))

# Step 2: Transpile the circuit

pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)
obs_isa = obs.apply_layout(layout=qc_isa.layout)

# Step 3: Run the circuit on a real quantum computer

estimator = Estimator(mode=backend)
pubs = [(qc_isa, obs_isa)]
job = estimator.run([[qc_isa, obs_isa]])
res = job.result()

# Run the job on the Aer simulator with noise model from real backend
# job = noisy_estimator.run([[qc_isa,obs_isa]])
# res=job.result()

# Step 4: Return the result in classical form, and analyze.

print(res[0].data.evs)

-0.02408454165642664

Secondo la nostra equazione precedente, $(\Delta X)^2 = 1 - \langle X \rangle^2 = 1-(0.0015...)^2 \rightarrow \Delta X = 0.999...$ Rimaniamo con lo stesso stato, ma troviamo ora il valore di aspettazione di $Z$:

# Step 1: Map the problem into a quantum circuit

obs = SparsePauliOp("Z")

# Define registers
qr = QuantumRegister(1, "q")
cr = ClassicalRegister(1, "c")
qc = QuantumCircuit(qr, cr)

# Initialize the state to |+>_y
qc.initialize([1, 1j] / np.sqrt(2))

# Step 2: Transpile the circuit

pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)
obs_isa = obs.apply_layout(layout=qc_isa.layout)

# Step 3: Run the circuit on a real quantum computer

estimator = Estimator(mode=backend)
pubs = [(qc_isa, obs_isa)]
job = estimator.run(pubs)
res = job.result()

# Run the job on the Aer simulator with noise model from real backend
# job = noisy_estimator.run([[qc_isa,obs_isa]])
# res=job.result()

# Step 4: Return the result in classical form, and analyze.

print(res[0].data.evs)

0.04958271968581247

Potremmo fare la stessa matematica di prima, ma vedremmo che la varianza è di nuovo molto vicina a 1,0. Potremmo concludere che $\Delta X \Delta Z \approx 1.0$. Questo è effettivamente approssimativamente corretto per lo stato che abbiamo scelto. Ma possiamo fare meglio? O peggio?

Ricorda che esiste una relazione di indeterminazione tra la posizione lungo una certa direzione, $x,$ e la quantità di moto lungo la stessa direzione, $p_x.$ Per quelle variabili, la forma più familiare è probabilmente $\Delta x \Delta p_x \geq \hbar/2$ Se questo è tutto ciò che ricordiamo, potremmo essere tentati di pensare che anche $\Delta X$ e $\Delta Z$ abbiano un limite fondamentale simile sull'incertezza. Forse è impossibile che il prodotto $\Delta X \Delta Z$ raggiunga zero? Proviamo un altro stato e vediamo se questo vale. Questa volta useremo $|\psi\rangle = \frac{1}{\sqrt{2}}\begin{pmatrix} 1 \\ 1 \end{pmatrix}.$ Vediamo cosa succede. Nota che nel codice seguente, l'estimator può accettare due serie di circuiti e osservabili nella stessa esecuzione del job.

# Step 1: Map the problem into a quantum circuit

obs1 = SparsePauliOp("X")
obs2 = SparsePauliOp("Z")

# Define registers

qr = QuantumRegister(1, "q")
cr = ClassicalRegister(1, "c")
qc = QuantumCircuit(qr, cr)

# Initialize the state
qc.initialize([1, 1] / np.sqrt(2))

# Step 2: Transpile the circuit

pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)
obs1_isa = obs1.apply_layout(layout=qc_isa.layout)
obs2_isa = obs2.apply_layout(layout=qc_isa.layout)

# Step 3: Run the circuit on a real quantum computer

with Batch(backend=backend) as batch:
    estimator = Estimator(mode=batch)
    pubs = [(qc_isa, obs1_isa), (qc_isa, obs2_isa)]
    job = estimator.run(pubs)
    res = job.result()
batch.close()

# Run the job on the Aer simulator with noise model from real backend

# job = noisy_estimator.run([[qc,obs1],[qc,obs2]])
# res=job.result()

# Step 4: Return the result in classical form, and analyze.

print("The expectation value of the first observable is: ", res[0].data.evs)
print("The expectation value of the second observable is: ", res[1].data.evs)

The expectation value of the first observable is:  1.0011036174126302
The expectation value of the second observable is:  0.0029429797670141016

Il valore di aspettazione di $X$ dovrebbe essere vicino a 1,0, ma non dovrebbe superarlo. Non preoccuparti se lo supera di un importo molto piccolo. Questo può essere attribuito a fattori come il rumore e/o l'errore di readout. Sebbene questo sia un argomento molto importante, possiamo ignorarlo per ora.

Abbiamo ottenuto un valore di aspettazione di $X$ molto vicino a 1,0 (corrispondente a una varianza molto bassa per $X$). Questo rende il prodotto delle due varianze piuttosto basso:

$$\Delta X \Delta Z = \sqrt{1-(0.9853)^2} \times \sqrt{1-(-0.00195)^2} = 0.171.$$

Anche se non è esattamente zero, questo valore si sta riducendo rispetto agli autovalori degli operatori di Pauli ($\pm 1$). Potresti ricordare che la relazione di indeterminazione tra posizione lineare e quantità di moto poteva essere scritta diversamente, usando esplicitamente la relazione di commutazione tra gli operatori $x$ e $p_x$:

$$\Delta x \Delta p_x \geq \frac{1}{2}|\langle [x,p_x] \rangle|$$

dove

$$[x,p_x] = xp_x-p_xx$$

è il commutatore di $x$ e $p_x$.

Questa è la forma che può essere estesa più facilmente agli operatori di Pauli. In generale, per due operatori $A$ e $B$,

$$\Delta A \Delta B \geq \frac{1}{2}|\langle [A,B] \rangle|.$$

E nel caso delle matrici di Pauli $X$ e $Z$, abbiamo bisogno di $[X,Z]$ per calcolare

$$\Delta X \Delta Z \geq \frac{1}{2}|\langle [X,Z] \rangle|.$$

Lo mostriamo qui, e lasciamo i calcoli analoghi al lettore come esercizio:

$$[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}$$ $$[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}$$

Questa è una risposta perfettamente accettabile, ma con un passaggio in più vediamo che

$$[X,Z] = -2i\begin{pmatrix}0 & -i \\ i & 0\end{pmatrix}=-2iY$$

La nostra relazione di indeterminazione diventa quindi

$$\Delta X \Delta Z \geq |\langle Y \rangle|.$$

Verifica la comprensione

Leggi la domanda qui sotto, rifletti sulla risposta, poi clicca il triangolo per vedere la soluzione.

Determina $[X,Y]$ e $[Y,Z]$. Usa questo risultato per scrivere le relazioni di indeterminazione tra $X$ e $Y$, e tra $Y$ e $Z$.

Risposta:

$$[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$$$$[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$$

Combinando con la relazione di indeterminazione generale, otteniamo

$$\Delta X \Delta Y \geq |\langle Z \rangle|,$$$$\Delta Y \Delta Z \geq |\langle X \rangle|.$$

Verifica della consistenza

Prima di procedere, verifichiamo che questo fosse consistente 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

$$|\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}$$ $$|\langle Y \rangle| = \frac{1}{2}\begin{pmatrix} 1 & 1 \end{pmatrix}\begin{pmatrix} -i \\ i \end{pmatrix} = \frac{1}{2}(-i+i) = 0.$$

Quindi effettivamente, $\Delta X \Delta Z = 0.171 \geq |\langle Y \rangle|=0$. Usa le domande seguenti per sviluppare intuizione su questi risultati:

Verifica la comprensione

Leggi le domande qui sotto, rifletti sulle risposte, poi clicca i triangoli per vedere le soluzioni.

Rispondi alle seguenti voci insieme come un insieme:

(a) Per quali stati ti aspetti di avere incertezza zero in $X$?

(b) Per quali stati ti aspetti di avere incertezza zero in $Z$?

(c) In quali stati otterresti un valore di aspettazione nullo $\langle Y \rangle$?

(d) Le risposte alle domande precedenti sono consistenti con il caso $\Delta X \Delta Z \geq |\langle Y \rangle|$?

(e) Scrivi del codice per verificare questo esplicitamente usando estimator.

Risposte:

(a) Ci aspettiamo che gli autostati dell'operatore $X$ producano incertezza zero in $X$. Infatti, usando $|\psi\rangle = |+\rangle_x,$ abbiamo $\Delta X = \sqrt{1-\langle X \rangle^2} = \sqrt{1-1^2} = 0.$

(b) Ci aspettiamo che gli autostati dell'operatore $Z$ producano incertezza zero in $Z$. Infatti, usando $|\psi\rangle = |1\rangle,$ abbiamo $\Delta Z = \sqrt{1-\langle Z \rangle^2} = \sqrt{1-(-1)^2} = 0.$

(c) Ci aspettiamo di trovare $\langle Y \rangle=0$ per tutti gli stati che, quando misurati, producono una proiezione positiva sull'asse $y$ con la stessa frequenza di una proiezione negativa. Questi includono gli autostati di $X$ e $Z$.

(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 quegli stessi stati. Quindi la relazione di indeterminazione potrebbe essere soddisfatta.

(e) Un codice come il seguente lo verificherebbe:

obs1 = SparsePauliOp.from_list(
    [("X", 1.000)]
)
obs2 = SparsePauliOp.from_list(
    [("Y", 1.000)]
)
obs3 = SparsePauliOp.from_list(
    [("Z", 1.000)]
)
qc = QuantumCircuit(1,1)
qc.ry(pi/2,0)

job = estimator.run([(qc, [[obs1], [obs2], [obs3]])], precision=0.001)
res=job.result()

Dove i risultati restituiscono tutti i valori di aspettazione. Per recuperare tutti i valori di aspettazione e calcolare le incertezze, potremmo usare:

xs=res[0].data.evs[0]
ys=abs(res[0].data.evs[1])
zs=res[0].data.evs[2]

import math
prodxz=((1-xs[i]*xs[i])**0.5)*(1-zs[i]*zs[i])**0.5

Rispondi alle seguenti voci insieme come un insieme:

(a) Riesci a pensare a uno stato in cui avresti un grande valore di aspettazione $\langle Y \rangle$?

(b) Ti aspetteresti che quello stesso stato abbia un'incertezza grande o piccola in $X$?

(c) Ti aspetteresti che quello stesso stato abbia un'incertezza grande o piccola in $Z$?

(d) Le risposte alle domande precedenti sono consistenti con il caso $\Delta X \Delta Z \geq |\langle Y \rangle|$?

(e) Scrivi del codice per verificare questo esplicitamente usando estimator.

Risposte:

(a) Ci aspettiamo di trovare $\langle Y \rangle\approx 1$ per l'autostato di $Y$: $|+\rangle_y$.

(b) Ci aspetteremmo che $X$ abbia una grande incertezza nello stato $|+\rangle_y,$ poiché misurare $X$ in quello stato produrrebbe un risultato positivo e negativo con uguale frequenza/probabilità.

(c) Ci aspetteremmo che $Z$ abbia una grande incertezza nello stato $|+\rangle_y,$ poiché misurare $Z$ in quello stato produrrebbe un risultato positivo e negativo con uguale frequenza/probabilità.

(d) Sì. Ci si aspetterebbe un grande valore per il prodotto delle incertezze $\Delta X \Delta Z$ per gli autostati di $Y,$ e in particolare per $|+\rangle_y$. Ci aspetteremmo anche $\langle Y \rangle\approx 1$ per quello 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 indeterminazione possa essere di nuovo soddisfatta.

(e) Un codice come il seguente lo verificherebbe:

obs1 = SparsePauliOp.from_list(
    [("X", 1.000)]
)
obs2 = SparsePauliOp.from_list(
    [("Y", 1.000)]
)
obs3 = SparsePauliOp.from_list(
    [("Z", 1.000)]
)
qc = QuantumCircuit(1,1)
qc.rx(-pi/2,0)

job = estimator.run([(qc, [[obs1], [obs2], [obs3]])], precision=0.001)
res=job.result()

Dove i risultati restituiscono tutti i valori di aspettazione. Per recuperare tutti i valori di aspettazione e calcolare le incertezze, potremmo usare:

xs=res[0].data.evs[0]
ys=abs(res[0].data.evs[1])
zs=res[0].data.evs[2]

import math
prodxz=((1-xs[i]*xs[i])**0.5)*(1-zs[i]*zs[i])**0.5

Verifica delle relazioni di indeterminazione

Il test precedente ha dimostrato la validità della relazione di indeterminazione solo per una singola scelta del vettore di stato $|\psi\rangle = |+\rangle_x$. Per convincerci che questa sia in generale coerente con l'esperimento, dovremmo eseguire calcoli simili usando l'estimatore per molte scelte del vettore di stato. Partiamo ruotando il nostro vettore di stato lontano dall'asse $z$, usando un gate RY per produrre diversi stati iniziali tramite un parametro $\theta$.

# The calculation below uses approximately 3-4 minutes of QPU time.
# Step 1: Map the problem into a quantum circuit

from qiskit.circuit import Parameter
import numpy as np

# Specify observables
obs1 = SparsePauliOp("X")
obs2 = SparsePauliOp("Y")
obs3 = SparsePauliOp("Z")

# Define registers
qr = QuantumRegister(1, "q")
cr = ClassicalRegister(1, "c")
qc = QuantumCircuit(qr, cr)

# Rotate away from |0>
theta = Parameter("θ")
qc.ry(theta, 0)

params = np.linspace(0, 2, num=21)

# Step 2: Transpile the circuit

pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)
obs1_isa = obs1.apply_layout(layout=qc_isa.layout)
obs2_isa = obs2.apply_layout(layout=qc_isa.layout)
obs3_isa = obs3.apply_layout(layout=qc_isa.layout)

# Step 3: Run the circuit on a real quantum computer

with Batch(backend=backend) as batch:
    estimator = Estimator(mode=batch)
    pubs = [(qc_isa, [[obs1_isa], [obs2_isa], [obs3_isa]], [params])]
    job = estimator.run(pubs, precision=0.01)
    res = job.result()

batch.close()

# Run the job on the Aer simulator with noise model from real backend

# job = noisy_estimator.run([(qc, [[obs1], [obs2], [obs3]], [params])])
# res=job.result()

# Step 4: Post-processing and classical analysis.
xs = res[0].data.evs[0]
ys = abs(res[0].data.evs[1])
zs = res[0].data.evs[2]

# Calculate uncertainties

delx = []
delz = []
prodxz = []
for i in range(len(xs)):
    delx.append(abs((1 - xs[i] * xs[i])) ** 0.5)
    delz.append(abs((1 - zs[i] * zs[i])) ** 0.5)
    prodxz.append(delx[i] * delz[i])

# Here we can plot the results from this simulation.
import matplotlib.pyplot as plt

plt.plot(params, delx, label=r"$\Delta$ X")
plt.plot(params, ys, label=r"$\langle$ Y $\rangle$")
plt.plot(params, delz, label=r"$\Delta$ Z")
plt.plot(params, prodxz, label=r"$\Delta$X $\Delta$Z")
plt.xlabel(r"$\theta$")
plt.ylabel("Expectation/Uncertainty Values")
plt.legend()
plt.show()

Nota che la curva rossa $(\Delta X \Delta Z)$ è sempre maggiore della curva arancione $\langle Y \rangle.$ A volte il prodotto delle indeterminazioni scende ed è piuttosto vicino al limite, altre volte sale ed è più lontano dal limite, ma obbedisce sempre alla relazione di indeterminazione.

Naturalmente, questo potrebbe non essere il test migliore della relazione di indeterminazione, dato che il nostro limite $\langle Y \rangle$ è sempre molto vicino a zero. Usiamo uno stato quantistico che abbia una proiezione maggiore sugli autostati di $Y$. In particolare, ruoteremo comunque $|0\rangle$ verso il basso dall'asse $z$ di angoli variabili, ma ora ruoteremo anche lo stato risultante attorno a $z$ di un certo angolo, forse $\pi/4$, e vedremo cosa succede.

# The calculation below uses approximately 3-4 minutes of QPU time.
from qiskit.circuit import Parameter
import numpy as np

# Step 1: Map the problem to a quantum circuit

# Specify observables
obs1 = SparsePauliOp("X")
obs2 = SparsePauliOp("Y")
obs3 = SparsePauliOp("Z")

# Define registers
qr = QuantumRegister(1, "q")
cr = ClassicalRegister(1, "c")
qc = QuantumCircuit(qr, cr)

# Rotate away from |0> along one plane, and then along a transverse direction.
theta = Parameter("θ")
qc.ry(theta, 0)
qc.rz(pi / 4, 0)

params = np.linspace(0, 2, num=21)

# Step 2: Transpile the circuit

pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)

obs1_isa = obs1.apply_layout(layout=qc_isa.layout)
obs2_isa = obs2.apply_layout(layout=qc_isa.layout)
obs3_isa = obs3.apply_layout(layout=qc_isa.layout)

# Step 3: Run the circuit on a real quantum computer

with Batch(backend=backend) as batch:
    estimator = Estimator(mode=batch)
    pubs = [(qc_isa, [[obs1_isa], [obs2_isa], [obs3_isa]], [params])]
    job = estimator.run(pubs, precision=0.01)
    res = job.result()

batch.close()

# Run the job on the Aer simulator with noise model from real backend

# job = noisy_estimator.run([(qc, [[obs1], [obs2], [obs3]], [params])])
# res=job.result()

# Step 4: Post-processing and classical analysis.
xs = res[0].data.evs[0]
ys = abs(res[0].data.evs[1])
zs = res[0].data.evs[2]

# Calculate uncertainties

delx = []
delz = []
prodxz = []
for i in range(len(xs)):
    delx.append(abs((1 - xs[i] * xs[i])) ** 0.5)
    delz.append(abs((1 - zs[i] * zs[i])) ** 0.5)
    prodxz.append(delx[i] * delz[i])

# Here we can plot the results from this simulation.
import matplotlib.pyplot as plt

plt.plot(params, delx, label=r"$\Delta$ X")
plt.plot(params, ys, label=r"$\langle$ Y $\rangle$")
plt.plot(params, delz, label=r"$\Delta$ Z")
plt.plot(params, prodxz, label=r"$\Delta$X $\Delta$Z")
plt.xlabel(r"$\theta$")
plt.ylabel("Expectation/Uncertainty Values")
plt.legend()
plt.show()

Ora vediamo che il limite sull'indeterminazione $(\Delta X \Delta Z)$ viene messo alla prova! La curva rossa si avvicina molto di più alla curva arancione rispetto a prima. In realtà, in assenza di rumore, la relazione di indeterminazione sarebbe esattamente saturata ($(\Delta X \Delta Z) = \langle Y \rangle$) in un punto. In presenza di rumore ed errori di readout, non dovrebbe sorprendere se un'esecuzione produce occasionalmente $(\Delta X \Delta Z)$ di poco superiore a $\langle Y \rangle.$ Questa non è una vera violazione dell'indeterminazione; è semplicemente un artefatto dell'errore non nullo.

Verifica la tua comprensione

Leggi le domande seguenti, pensa alle tue risposte, poi clicca sui triangoli per scoprire le soluzioni.

Spiega come potresti portare questo al limite assoluto, rendendo $\langle Y \rangle$ il più grande possibile?

Risposta:

Il codice attualmente ha delle righe che ruotano lo stato iniziale predefinito $|0\rangle$ verso il basso dall'asse $z$ di un angolo parametrizzato $\theta$ e poi anche attorno all'asse $z$ di un angolo $\pi/4,$ che ruota il vettore di stato parzialmente verso l'asse $y$.

qc.ry(theta,0)

qc.rz(pi/4,0)

Potremmo cambiare la rotazione attorno a $z$ da $\pi/4$ a $\pi/2$, ruotando completamente verso un autostato di $Y$:

qc.ry(theta,0)

qc.rz(pi/2,0)

Non sarebbero necessarie altre modifiche.

Modifica il codice o copialo e implementa quella verifica della relazione di indeterminazione con il valore di aspettazione di Y massimizzato. La relazione di indeterminazione regge?

Risposta:

Useremmo esattamente il codice dell'esempio precedente, con

qc.rz(pi/2,0)

sostituito al posto di

qc.rz(pi/4,0).

La figura risultante dovrebbe assomigliare a quella qui sotto, e sì, il principio di indeterminazione dovrebbe ancora essere valido.

Modifica il codice precedente per produrre un'immagine simile, dimostrando che dalle misurazioni sul computer quantistico il prodotto $\Delta X \Delta Y$ si comporta come previsto. Scegli qualsiasi insieme di stati.

Risposta:

Useremmo esattamente il codice dell'esempio precedente, e anzi potremmo usare gli stessi risultati di prima, calcolando semplicemente indeterminazioni diverse dai valori di aspettazione. Per esempio, potremmo usare

xs=res[0].data.evs[0]
ys=res[0].data.evs[1]
zs=abs(res[0].data.evs[2])
import math
delx = []
dely = []
prodxy=[]
for i in range(len(xs)):
    delx.append((1-xs[i]*xs[i])**0.5)
    dely.append((1-ys[i]*ys[i])**0.5)
    prodxy.append(((1-xs[i]*xs[i])**0.5)*(1-ys[i]*ys[i])**0.5)

e potremmo tracciare

import matplotlib.pyplot as plt
plt.plot(params, delx, label=r'$\Delta$ X')
plt.plot(params, dely, label=r'$\langle$ Y $\rangle$')
plt.plot(params, zs, label=r'$\Delta$ Z')
plt.plot(params, prodxy, label=r'$\Delta$X $\Delta$Z')
plt.xlabel(r'$\theta$')
plt.ylabel('Expectation/Uncertainty Values')
plt.legend()
plt.show()

Sfida: Scrivi del codice per scorrere molti valori di $\phi$, proprio come abbiamo scorso molti valori di $\theta$, e realizza un grafico 3D che mostri che la relazione di indeterminazione non viene mai violata. Scegli qualsiasi osservabile tu voglia.

Domande

I docenti possono richiedere versioni di questi notebook con le soluzioni e indicazioni sul loro utilizzo in programmi didattici comuni compilando questo breve sondaggio su come vengono usati i notebook.

Concetti fondamentali:

• Esistono relazioni di indeterminazione tra molti insiemi di osservabili fisici, tra cui posizione e quantità di moto lineare, e componenti dello spin.
• Le matrici di Pauli non commutano. Questa è una riflessione matematica del fatto che non tutte le componenti dello spin possono essere contemporaneamente note/determinate.
• Il calcolo quantistico fa largo uso degli operatori/matrici di Pauli, per cui è utile conoscere la relazione di indeterminazione per gli operatori di Pauli, così come per gli operatori di spin strettamente correlati.
• Una formula generale per l'indeterminazione di due operatori $A$ e $B$ è $\Delta A \Delta B \geq \frac{1}{2}|\langle [A,B] \rangle|.$
• Un autostato $|a\rangle$ di qualche operatore $A$ produce indeterminazione zero nell'osservabile fisico associato a quell'operatore. Anche sperimentalmente, $\langle a|A|a\rangle \approx 0.$
• Un autostato $|a\rangle$ di qualche operatore $A$ produrrà un'indeterminazione maggiore per un operatore $B$ che non commuta con $A$.
• I risultati sperimentali ottenuti con un computer quantistico reale confermano l'intuizione che acquisiamo dalle rappresentazioni matriciali degli operatori fisici.

Domande V/F:

1. V/F Si possono misurare contemporaneamente $X$ e $Y$, ma non $Z$.
2. V/F Si possono misurare contemporaneamente $X$ e $Z$, ma non $Y$.
3. V/F Gli operatori di posizione lineare e quantità di moto lineare non commutano.
4. V/F I computer quantistici IBM misurano lungo $Z$ per impostazione predefinita, quindi bisogna eseguire una rotazione per misurare lungo qualsiasi altra direzione.
5. V/F Il circuito seguente misura effettivamente $Z$ e poi $X$.

Domande a scelta multipla:

1. Il diagramma seguente illustra quale delle seguenti relazioni di indeterminazione?

   • a. $\Delta X \Delta Y \geq |\langle Z \rangle|$
   • b. $\Delta Y \Delta Z \geq |\langle X \rangle|$
   • c. $\Delta Z \Delta X \geq |\langle Y \rangle|$
   • d. Nessuna delle precedenti

2. Qual è la sequenza standard per eseguire una misurazione lungo $x$?

   • a. Solo qc.measure()
   • b. qc.h() poi qc.measure()
   • c. qc.h(), qc.h() poi qc.measure()
   • d. qc.h(), qc.s, qc.h() poi qc.measure()
   • e. qc.sdg(), qc.h(), qc.s poi qc.measure()
   • f. qc.sdg(), qc.h(), qc.s, qc.h() poi qc.measure()

3. Quale dei seguenti stati produce il valore di aspettazione $\langle X \rangle$ più grande?

   • a. $|+\rangle_x$
   • b. $|-\rangle_x$
   • c. $|+\rangle_y$ detto anche $|+i\rangle$
   • d. $|-\rangle_y$ detto anche $|-i\rangle$
   • e. $|0\rangle$ detto anche $|\uparrow\rangle$
   • f. $|1\rangle$ detto anche $|\downarrow\rangle$

4. Quale dei seguenti stati produce la maggiore indeterminazione $\Delta X$?

   • a. $|+\rangle_x$
   • b. $|+\rangle_y$ detto anche $|+i\rangle$
   • c. $|0\rangle$ detto anche $|\uparrow\rangle$
   • d. a e b sono pari
   • e. b e c sono pari
   • f. a, b e c sono pari

Domande di discussione:

1. Questo concetto di indeterminazione contraddice in qualche modo la nozione di spin come una freccia vettoriale nello spazio cartesiano? E sulla sfera di Bloch?

2. Supponi di orientare un dispositivo di misurazione lungo una direzione a metà tra gli assi $x$ e $y$. Cosa succede? Puoi effettuare una misurazione lungo questa direzione? Come si rapporta questo all'indeterminazione in $X$ e $Y$?