Monete quantistiche — un modulo sulla sovrapposizione e l'interferenza

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 superiore
• qiskit-ibm-runtime v0.40.1 o superiore
• qiskit-aer v0.17.0 o superiore
• qiskit.visualization
• numpy
• pylatexenc

Per configurare e installare i pacchetti elencati sopra, consulta la guida Installa Qiskit. Per eseguire job su computer quantistici reali, 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 47 secondi di tempo QPU. Si tratta solo di una stima. L'utilizzo effettivo può variare.

# Added by doQumentation — required packages for this notebook
!pip install -q matplotlib numpy qiskit 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 la panoramica del modulo con la Dr.ssa Katie McCormick qui sotto, oppure clicca qui per guardarlo su YouTube.

---

Introduzione

In questo modulo esploreremo uno dei principi fondamentali al cuore della teoria quantistica: la sovrapposizione. Nella nostra esperienza quotidiana, gli oggetti hanno sempre caratteristiche definite. La loro posizione, dimensione, forma, colore — tutto ciò che li riguarda — è determinato e certo, anche se noi osservatori non li abbiamo ancora misurati. Nel mondo quantistico, questo non è necessariamente il caso. Un oggetto quantistico può trovarsi in quello che viene chiamato uno "stato di sovrapposizione" di molteplici stati classicamente permessi. Quando la sovrapposizione viene misurata, essa "collasserà" casualmente in uno di quegli stati.

In un certo senso, misurare uno stato di sovrapposizione è come lanciare una moneta: non c'è modo di sapere in anticipo come cadrà. Questo indeterminismo fondamentale è un aspetto scomodo della meccanica quantistica con cui anche Einstein ebbe difficoltà. Disse famosamente "Dio non gioca a dadi" riguardo a questa casualità. Ma, come vedremo, Dio in realtà gioca a dadi — e lancia monete.

Penseremo al lancio di una moneta classica come analogia alla misurazione di uno stato di sovrapposizione. E — giocando con una "moneta quantistica" usando Qiskit e un qubit su un processore quantistico IBM® — scopriremo presto i limiti di questa analogia.

Moneta classica

Cominciamo con una moneta classica. Lancia una moneta e cadrà con testa su o testa giù, con una probabilità del 50$~$% per ciascun caso. Anche se in linea di principio si potrebbe calcolare su quale lato cadrà la moneta se si conoscessero le condizioni iniziali precise e la forza/coppia del lancio, in pratica non c'è modo di sapere a priori su quale lato cadrà la moneta. Ecco perché usiamo il lancio della moneta come esempio canonico di stato probabilistico classico, dove l'esito è essenzialmente casuale. Possiamo scrivere lo stato della moneta prima che atterri per riflettere questa probabilità 50/50:

$$S(coin) = \frac{1}{2}|up\rangle + \frac{1}{2}|down\rangle$$

Qui, i due termini rappresentano i due possibili esiti del lancio e i loro coefficienti rappresentano le probabilità di ciascun esito. Nota che tipicamente il "$|\rangle$" (noto come "ket") viene usato per rappresentare uno stato quantistico, ma qui stiamo parlando di uno stato probabilistico classico. Consulta la Lezione 1: Sistemi singoli nel corso Basi dell'informazione quantistica per saperne di più su come rappresentiamo l'informazione classica e quantistica.

Se lanciassimo una moneta 1000 volte e registrassimo il numero di volte che cade testa su e testa giù, otterremmo qualcosa del genere:

# import necessary packages:
import numpy as np
import matplotlib.pyplot as plt
import random

nflips = 1000
fliplist = [random.randint(0, 1) for f in range(nflips)]

# bar plots using get_gaussian_probs function
plt.hist(fliplist)
plt.show()

Moneta quantistica

Possiamo creare uno stato probabilistico simile usando un qubit sul nostro computer quantistico. Come il lancio della moneta, anche un qubit può essere misurato in due stati possibili: $|0\rangle$ e $|1\rangle$. Creiamo lo stato probabilistico di "sovrapposizione" partendo dallo stato $|0\rangle$ e applicando poi quello che viene chiamato un gate di Hadamard al qubit. Questo lo mette in un'uguale sovrapposizione di $|0\rangle$ e $|1\rangle$. Nota che, sebbene questo stato di sovrapposizione possa sembrare e comportarsi come la moneta a prima vista, vedremo presto che c'è molto di più. Lo scopo di questo modulo è mostrarti che una sovrapposizione non è uguale a un lancio di moneta classico.

Quindi, poiché il qubit si trova in un'uguale sovrapposizione di 0 e 1, quando misuriamo il qubit ci sarà una probabilità del 50% di misurare $|0\rangle$ e una probabilità del 50% di misurare $|1\rangle$. Scriviamo questo stato in modo leggermente diverso rispetto al caso probabilistico classico, per ragioni che diventeranno chiare in seguito:

$$|\psi\rangle = \frac{1}{\sqrt{2}} |0\rangle + \frac{1}{\sqrt{2}} |1\rangle$$

Qui, le probabilità di misurare ciascuno dei due stati non sono più uguali ai coefficienti, come nel caso dello stato probabilistico classico sopra. Invece, è il quadrato dei coefficienti che ci dà le probabilità, e ciascuno di questi coefficienti può ora essere complesso, ovvero può avere sia una parte reale che una immaginaria.

Nonostante queste differenze, il risultato della misurazione di questo stato è essenzialmente lo stesso del lancio di una moneta.

from qiskit import QuantumCircuit

qcoin = QuantumCircuit(1)
qcoin.h(0)
qcoin.measure_all()

qcoin.draw("mpl")

In effetti, applicare il gate di Hadamard è l'analogo del lancio di una moneta. E proprio come abbiamo lanciato la moneta 1000 volte per osservare le statistiche della moneta che cade testa su o giù, possiamo fare qualcosa di simile su Qiskit con la nostra "moneta quantistica". Possiamo usare una primitiva Qiskit chiamata Sampler, che ripeterà un circuito più volte per campionare le statistiche dello stato risultante.

Prima di tutto, carichiamo il servizio Qiskit Runtime e le primitive, poi selezioniamo un backend su cui eseguire il circuito.

Di seguito è riportato del codice 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 affidabile per ulteriori indicazioni.

# 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 (
    SamplerV2 as Sampler,
    EstimatorV2 as Estimator,
)

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

ibm_kingston

Se non hai più tempo disponibile sul tuo account, puoi anche scegliere di eseguire il codice su un simulatore. Decommenta il codice ed esegui la cella qui sotto per farlo:

## Use a local simulator

# from qiskit_aer import AerSimulator

## Generate a simulator that mimics the real quantum system

# backend_sim = AerSimulator.from_backend(backend)

## Import an estimator, this time from qiskit (we will import from Runtime for real hardware)

# from qiskit.primitives import BackendSamplerV2
# sampler_sim = BackendSamplerV2(backend = backend_sim)
# from qiskit.primitives import BackendEstimatorV2
# estimator_sim = BackendEstimatorV2(backend = backend_sim)

## 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(qcoin)

## Execute

# On real hardware:
sampler = Sampler(mode=backend)
pubs = [qc_isa]
job = sampler.run(pubs, shots=1000)
res = job.result()

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

# or with Aer simulator with noise model from real backend
# job = sampler_sim.run([qc_isa])
# counts=job.result()[0].data.meas.get_counts()

## Analysis
from qiskit.visualization import plot_histogram

plot_histogram(counts)

Con 1000 campioni del circuito sopra, otteniamo qualcosa che sembra sostanzialmente identico all'istogramma della moneta classica, a meno di alcune fluttuazioni statistiche.

Oltre a campionare le statistiche della moneta quantistica, possiamo anche usare un'altra primitiva Qiskit chiamata Estimator per misurare il cosiddetto valore atteso di un'osservabile dello stato. Per illustrare cosa sia questo valore atteso, usiamo come esempio la moneta classica. Supponiamo di usare la moneta per giocare d'azzardo: ogni volta che lanci la moneta e cade "testa su," vinci un dollaro. Ma ogni volta che cade "testa giù," perdi un dollaro. Se vuoi sapere quanti soldi ti aspetti di ottenere ad ogni lancio (il valore atteso dell'osservabile "denaro"), calcoleresti:

$$E(money) = \frac{1}{2} (+ \text{1 dollar}) + \frac{1}{2} (- \text{1 dollar}) = \text{0 dollars}$$

Poiché hai le stesse probabilità di vincere un dollaro e di perderne uno, il valore atteso è $0.

Allo stesso modo, con uno stato quantistico, possiamo calcolare il valore atteso dell'osservabile "Z", dove Z è la matrice di Pauli con valori +1 e -1 associati agli stati $|0\rangle$ e $|1\rangle$, rispettivamente.

$$\langle \psi|Z|\psi \rangle = \frac{1}{2} \langle 0 | Z | 0 \rangle + \frac{1}{2} \langle 1 | Z | 1 \rangle = \frac{1}{2} (+1) + \frac{1}{2}(-1) = 0$$

from qiskit.quantum_info import Pauli

qcoin = QuantumCircuit(1)
qcoin.h(0)

# for Estimator, we do not apply the measurement to the circuit

<qiskit.circuit.instructionset.InstructionSet at 0x136df1ba0>

## Transpile
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

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

obs = Pauli("Z")

qc_isa = pm.run(qcoin)
obs_isa = obs.apply_layout(layout=qc_isa.layout)

## Execute

# On real hardware:
estimator = Estimator(mode=backend)
pubs = [(qc_isa, obs_isa)]
job = estimator.run([[qc_isa, obs_isa]])
res = job.result()

# On a simulator:
# job = estimator_sim.run([[qc_isa, obs_isa]])
# res=job.result()

print(res[0].data.evs)

-0.014799284701239441

Otteniamo un valore atteso di 0, come previsto (ah ah). Questo è un altro modo per confermare che effettivamente c'è una probabilità uguale di misurare 0 e 1, e che il comportamento sembra quello di un lancio di moneta.

A questo punto, la "moneta quantistica" sembra esattamente uguale alla moneta classica. Ma nella prossima sezione faremo alcuni esperimenti che riveleranno le differenze fondamentali tra le due.

Il quantum svelato: un esperimento in tre dimensioni

Facciamo un esperimento mentale: immagina di lanciare in aria una moneta e, invece di lasciarla cadere a terra, di avere la coordinazione per applaudire mentre passa tra le tue mani, intrappolandola tra i palmi. Invece di essere testa su o testa giù, la moneta sarà testa a sinistra o testa a destra.

Verifica la tua comprensione

Leggi la domanda qui sotto, pensa alla risposta, poi clicca sul triangolo per vedere la soluzione.

Qual è la probabilità di ciascuno di questi risultati, testa a sinistra o testa a destra?

Risposta:

La probabilità sarà ancora 50-50. Non dovrebbe importare lungo quale dimensione scegliamo di misurare il risultato del lancio della moneta.

Sperabilmente hai risposto che la probabilità di trovare testa a sinistra o a destra è ancora 50-50. La dimensione lungo cui si misura il lancio della moneta non dovrebbe influenzare la probabilità dei risultati.

Ma come sarebbero le cose per la nostra moneta quantistica? Vediamolo.

Possiamo creare la nostra sovrapposizione quantistica nello stesso modo in cui l'abbiamo fatto prima, con un gate Hadamard. Per misurare "testa a sinistra o destra" sulla nostra moneta quantistica, possiamo fare come con la moneta classica: misurare lungo un asse diverso. Le nostre misurazioni standard sul computer quantistico sono lungo l'asse verticale, proprio come la solita misurazione "testa su o giù" della moneta classica. Ma possiamo anche chiedere alla nostra moneta quantistica se è testa a sinistra o destra, o equivalentemente, se si trova negli stati $|+\rangle$ o $|-\rangle$, che puntano lungo l'asse $x$. Sampler campiona solo nella base di misurazione Z, ma possiamo usare Estimator per ottenere il valore atteso di X. I valori di X sono +1 e -1 per gli stati $|+\rangle$ o $|-\rangle$, rispettivamente.

Verifica la tua comprensione

Leggi la domanda qui sotto, pensa alla risposta, poi clicca sul triangolo per vedere la soluzione.

Se la moneta quantistica si comportasse come quella classica in questo caso, avremmo una probabilità 50-50 di misurare lo stato in $|+\rangle$ e $|-\rangle$. Quale valore atteso di X ci aspetteremmo da Estimator, in tal caso?

Risposta:

Quando applichiamo X allo stato $|+\rangle$, otteniamo il valore +1 e allo stato $|-\rangle$ otteniamo -1, quindi se avessimo una distribuzione 50-50, otterremmo un valore atteso di 0.

# Step 1: map problem

qcoin_lr = QuantumCircuit(1)
qcoin_lr.h(0)

obs = Pauli("X")

# Step 2: Transpile the circuit

pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qcoin_lr)
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 = estimator_sim.run([[qc_isa,obs_isa]])
# res=job.result()

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

print(res[0].data.evs)

0.9985207100591716

Il valore atteso di X per questo stato è 1. Quindi, non c'è una probabilità 50-50 di misurare $|+\rangle$ e $|-\rangle$.

Verifica la tua comprensione

Leggi la domanda qui sotto, pensa alla risposta, poi clicca sul triangolo per vedere la soluzione.

Cosa ci dice questo valore atteso sullo stato $|\psi\rangle$? Quali sono le probabilità di misurare $|+\rangle$ e $|-\rangle$ in questa base X?

Risposta:

Poiché il valore atteso è uguale al valore di X per lo stato $|+\rangle$, significa che abbiamo il 100% di probabilità di misurare lo stato $|+\rangle$ quando misuriamo lungo X.

Cosa sta succedendo? Sembra che la nostra moneta quantistica possa avere risultati casuali e probabilistici lungo una dimensione, ma risultati perfettamente prevedibili lungo un'altra. Sarebbe come lanciare una moneta e avere la garanzia che ogni volta che viene intrappolata tra le due mani, la testa finisca rivolta a destra.

La fase quantistica

La differenza fondamentale della moneta quantistica è che ha un'altra qualità che la moneta classica non possiede. Ricorda che in uno stato probabilistico classico,

$$S(coin) = c_1|up\rangle + c_2|down\rangle$$

ogni coefficiente è semplicemente un numero reale positivo che rappresenta la probabilità di misurare un particolare stato. In uno stato quantistico,

$$|\psi\rangle = c_1 |0\rangle + c_2 |1\rangle$$

i coefficienti sono complessi, quindi contengono una parte reale e una parte immaginaria. Ogni coefficiente $c_i$ può essere espresso come un vettore bidimensionale nel piano complesso, con modulo $|c_i|$ e angolo $\phi_i$ che forma con l'asse reale:

$$c_i = |c_i| e^{i \phi_i}.$$

Chiamiamo $\phi_i$ la fase. La fase ci dice come due termini di uno stato quantistico interferiranno, ovvero come si combineranno o si annulleranno come onde. Se due onde sono in fase tra loro, così che le creste e i ventri coincidono, si combineranno formando un'onda doppiamente alta. Questo si chiama interferenza costruttiva. Se sono sfasate, nel senso che la cresta di una coincide con il ventre dell'altra, e viceversa, interferiscono in modo distruttivo e si annullano completamente.

Come le onde, gli stati quantistici possono anch'essi combinarsi in modo costruttivo o distruttivo. Può essere più difficile da vedere perché spesso non si tratta di un'onda reale nello spazio fisico. Nel caso dei nostri qubit, l'interferenza avviene nello spazio astratto e informazionale dei qubit. Nota inoltre che poiché solo la fase relativa tra le due onde conta per come interferiranno — cioè, la differenza nelle fasi $\Delta \phi = \phi_2 - \phi_1$ dei due coefficienti — di solito applichiamo una fase globale di $-\phi_1$ all'intero stato in modo che $c_1$ sia puramente reale e la fase relativa sia interamente catturata in $c_2$.

Per vedere come la fase può causare interferenza nella nostra moneta quantistica, proviamo ad applicare l'Hadamard due volte invece di una sola. Classicamente, questo non avrebbe senso — se applicare l'Hadamard equivale a lanciare una moneta, non puoi lanciare una moneta che sta già girando. Ma vediamo cosa succede alla moneta quantistica:

qcoin_0 = QuantumCircuit(1)
qcoin_0.h(0)
qcoin_0.h(0)
qcoin_0.measure_all()

qcoin_0.draw("mpl")

Ora, prima di usare Sampler per misurare lo stato risultante, pensiamo a come questo qubit verrà trasformato da ciascun gate. Parte, come al solito, da $|0\rangle$. Poi, il primo Hadamard trasforma lo stato in sovrapposizione, come abbiamo già visto:

$$H|0\rangle = \frac{1}{\sqrt{2}} |0\rangle + \frac{1}{\sqrt{2}} |1\rangle.$$

In questo caso, entrambi i coefficienti sono completamente reali e positivi, il che significa che la fase è $\phi=0$.

Il secondo Hadamard viene poi applicato separatamente a ciascuna parte dello stato di sovrapposizione. Sappiamo già come l'Hadamard trasforma lo stato $|0\rangle$. Ma cosa succede con $|1\rangle$?

$$H|1\rangle = \frac{1}{\sqrt{2}} |0\rangle - \frac{1}{\sqrt{2}} |1\rangle$$

Anche questo è una sovrapposizione uguale di 0 e 1, analogo al lancio di una moneta, ma il coefficiente di questo stato davanti a $|1\rangle$ ha una fase di $\phi = \pi$ che gli conferisce il segno negativo.

Verifica la tua comprensione

Leggi la domanda qui sotto, pensa alla risposta, poi clicca sul triangolo per vedere la soluzione.

Calcola lo stato risultante dopo aver applicato il secondo Hadamard. Cioè, calcola: $H(\frac{1}{\sqrt{2}} |0\rangle + \frac{1}{\sqrt{2}} |1\rangle)$. Nota che $H$ è distributivo, quindi possiamo applicarlo a ciascun termine individualmente.

Risposta:

$$H(\frac{1}{\sqrt{2}} |0\rangle + \frac{1}{\sqrt{2}} |1\rangle) = \frac{1}{\sqrt{2}} H|0\rangle + \frac{1}{\sqrt{2}} H|1\rangle = \frac{1}{2} [(|0\rangle + |1\rangle) + (|0\rangle - |1\rangle)] = |0\rangle$$

Ora verifichiamo la nostra previsione con Sampler.

## Transpile

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

qc_isa = pm.run(qcoin_0)

## Execute

# On real hardware:
sampler = Sampler(mode=backend)
pubs = [qc_isa]
job = sampler.run(pubs, shots=1000)
res = job.result()

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

# or with Aer simulator with noise model from real backend
# job = sampler_sim.run([qc_isa])
# counts=job.result()[0].data.meas.get_counts()

## Analyze
plot_histogram(counts)

Il secondo Hadamard ha annullato il primo, e siamo tornati allo stato 0 da cui eravamo partiti! Questo perché l'Hadamard trasforma sia gli stati $|0\rangle$ che $|1\rangle$ in stati simili, ma con fasi opposte. Dopo il secondo Hadamard, vediamo che i termini $|0\rangle$ interferiscono costruttivamente, ma i termini $|1\rangle$ interferiscono in modo distruttivo e si annullano.

Esploriamo ulteriormente: possiamo cambiare la fase usando un gate "PHASE". Quindi ora applichiamo un Hadamard per creare la sovrapposizione, un cambiamento di fase di $\pi$ radianti, poi il secondo Hadamard:

qcoin_pi = QuantumCircuit(1)
qcoin_pi.h(0)
qcoin_pi.p(np.pi, 0)
qcoin_pi.h(0)
qcoin_pi.measure_all()

qcoin_pi.draw("mpl")

## Transpile

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

qc_isa = pm.run(qcoin_pi)

## Execute

# On real hardware:
sampler = Sampler(mode=backend)
pubs = [qc_isa]
job = sampler.run(pubs, shots=1000)
res = job.result()

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

# or with Aer simulator with noise model from real backend
# job = sampler_sim.run([qc_isa])
# counts=job.result()[0].data.meas.get_counts()

## Analyze
plot_histogram(counts)

E ora il qubit viene misurato nello stato 1 invece di 0.

Dunque, anche da questi pochi semplici esperimenti, puoi già vedere la differenza drastica che questa fase può fare su un circuito quantistico. Può essere sottile e difficile da vedere all'inizio. Nel nostro primo esperimento, dove abbiamo semplicemente lanciato la nostra moneta quantistica con un gate Hadamard e misurato il risultato del lancio, nulla rivela l'effetto della fase. Solo andando più in profondità abbiamo scoperto la differenza che una fase può fare. Può causare che lo stesso gate quantistico abbia letteralmente l'effetto opposto su un qubit.

Provalo tu stesso:

Modifica la cella di codice qui sotto per cambiare la fase in modo tale che il secondo Hadamard crei uno stato di sovrapposizione con probabilità del 25% e 75% di trovare lo stato in $|0\rangle$ e $|1\rangle$, rispettivamente. Verifica la tua risposta con la matematica.

qcoin_phase = QuantumCircuit(1)
qcoin_phase.h(0)
# replace "x" below with a phase from 0 to 2*np.pi (this cell won't run if you leave x)
# qcoin_phase.rz(x, 0)
qcoin_phase.h(0)
qcoin_phase.measure_all()

## Transpile

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

qc_isa = pm.run(qcoin_phase)

## Execute

# On real hardware:
sampler = Sampler(mode=backend)
pubs = [qc_isa]
job = sampler.run(pubs, shots=1000)
res = job.result()

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

# or with Aer simulator with noise model from real backend
# job = sampler_sim.run([qc_isa])
# counts=job.result()[0].data.meas.get_counts()

## Analyze
plot_histogram(counts)

Un'altra analogia (migliore) con la moneta usando il gate $\sqrt{\text{NOT}}$

A questo punto abbiamo imparato che l'atto di lanciare una moneta è piuttosto diverso dal creare uno stato di sovrapposizione. Esiste un'analogia migliore con una moneta che cattura meglio i fenomeni di sovrapposizione? Sì. Sì che esiste.

Faremo un altro esperimento mentale con una moneta. Immagina la moneta sul tavolo, testa in su. Per metterla testa in giù, possiamo semplicemente girarla. Questo è l'equivalente computazionale di un gate "NOT".

Supponiamo di voler costruire un'operazione che, se applicata due volte, sia equivalente al gate NOT. Cioè, vogliamo una "radice quadrata di NOT," o $\sqrt{\text{NOT}}$. Possiamo farlo considerando come il gate NOT viene fisicamente implementato sulla moneta: è solo una rotazione di 180 gradi attorno, ad esempio, all'asse x. Quindi, se ruotassimo la moneta di soli 90 gradi attorno all'asse x, sarebbe equivalente a un gate $\sqrt{\text{NOT}}$.

Immagina che dopo aver applicato il gate $\sqrt{\text{NOT}}$, vogliamo chiedere se la moneta è testa in su o testa in giù. Non è né l'una né l'altra — è in piedi sul bordo rispetto all'asse verticale. Ma ora, ridefinissimo la nostra "misurazione" della moneta come: primo, far collassare la moneta lungo l'asse di misurazione (schiacciandola con la mano in modo che giaccia piatta), e secondo, verificare se è testa in su o testa in giù.

Se eseguiamo questa "misurazione" sulla moneta in piedi sul bordo, allora la moneta "collasserà" testa in su o testa in giù con uguale probabilità. Come nel lancio di una moneta, in linea di principio la direzione in cui cade la moneta può essere prevista in base alle condizioni iniziali e a come esattamente la forza della nostra mano viene applicata per "farla collassare". Ma in pratica, dovrebbe essere difficile prevedere quale lato finirà su, quindi è essenzialmente casuale.

Possiamo effettivamente misurare questa moneta lungo tre assi diversi: $x$, $y$ e $z$. Vediamo che il bordo della moneta punta lungo $x$ e $z$, quindi la misurazione in quelle direzioni richiede un "collasso" della moneta — di conseguenza, lungo quegli assi, ci sarà casualità con probabilità 50:50 di misurare testa in su o testa in giù. Ma lungo l'asse $y$, è già piatta, con la testa rivolta nella direzione -y. Possiamo chiamare quello "testa in avanti."

Quindi, mentre le misurazioni x e z hanno prodotto risultati casuali, la misurazione y produrrà sempre lo stesso risultato! Se ricordi l'esperimento della "moneta quantistica" dalla sezione precedente, questo ricorda il comportamento della moneta quantistica. Veniva misurata come 0 o 1 con probabilità 50/50 nella direzione z, ma sempre $|+\rangle$ e mai $|-\rangle$ lungo X. Questo suggerisce che forse una moneta ferma, in piedi sul bordo, è un modo migliore per visualizzare uno stato di sovrapposizione di un qubit rispetto a una moneta che gira selvaggiamente in aria.

Usiamo Qiskit per vedere se la nostra "moneta quantistica" si comporta allo stesso modo della moneta classica quando viene applicato un gate $\sqrt{\text{NOT}}$. Applicheremo $\sqrt{\text{NOT}}$ a un qubit che parte da $|0\rangle$, poi useremo Estimator per controllare il valore atteso delle tre osservabili X, Y e Z.

qcoin_sx = QuantumCircuit(1)
qcoin_sx.sx(0)

qcoin_sx.draw("mpl")

obs1 = Pauli("X")
obs2 = Pauli("Y")
obs3 = Pauli("Z")

# Step 2: Transpile the circuit

pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qcoin_sx)
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

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

# Run the job on the Aer simulator with noise model from real backend
# pubs = [(qc_isa, [[obs1_isa], [obs2_isa], [obs3_isa]])]
# job = estimator_sim.run(pubs)
# res=job.result()

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

print(res[0].data.evs)

[[-0.01234492]
 [-1.00388865]
 [ 0.00740695]]

I valori attesi sono 0, -1 e 0 per X, Y e Z, rispettivamente.

Verifica la tua comprensione

Leggi la domanda qui sotto, pensa alla risposta, poi clicca sul triangolo per vedere la soluzione.

Dati i valori attesi, quali sono le probabilità di misurare la moneta quantistica come testa in su/giù (o sinistra/destra o avanti/indietro) per ciascuno dei 3 assi di misurazione?

Risposta:

C'è una probabilità 50/50 di misurare entrambi gli stati lungo X e Z, e lo stato viene sempre misurato nella direzione -y lungo Y.

Questo è lo stesso risultato ottenuto con il nostro esperimento mentale applicando una rotazione di 90 gradi "$\sqrt{\text{NOT}}$" sulla moneta classica. In realtà, esiste ora un'analogia precisa tra la moneta e lo stato del qubit. Possiamo visualizzare lo stato del qubit come un vettore che punta nella direzione della testa su una moneta, perpendicolare alla superficie della moneta. Quindi, testa in su, ovvero lo stato $|0\rangle$ su una moneta quantistica, equivale a un vettore che punta direttamente verso l'alto; testa in giù, ovvero $|1\rangle$, punta direttamente verso il basso. Qualsiasi sovrapposizione uguale di $|0\rangle$ e $|1\rangle$ punta orizzontalmente. La fase dello stato determina l'esatta direzione orizzontale — la direzione lungo l'equatore è uguale alla direzione che il coefficiente $c_2$ indica nel piano complesso.

Ora, ogni gate che abbiamo visto in questo notebook può essere visualizzato come una rotazione (o una serie di rotazioni) della moneta/vettore.

• NOT: 180 gradi attorno all'asse x

• $\sqrt{\text{NOT}}$: 90 gradi attorno all'asse x

• PHASE: rotazione di $\phi$ attorno all'asse z

• Hadamard: questo è un po' più complicato. Inizialmente lo abbiamo paragonato al lancio di una moneta, che fa girare la moneta in modo incontrollabile in aria. Ma l'Hadamard è in realtà una rotazione controllata e deterministica della moneta, come gli altri gate. L'Hadamard si esegue ruotando di 90 gradi attorno all'asse y, poi di 180 gradi attorno all'asse x.

Quindi, non c'è nulla di casuale in uno stato di sovrapposizione quantistica o in nessuna delle operazioni standard che eseguiamo sul qubit. Ogni operazione è deterministica e reversibile. L'unica volta in cui la casualità entra in gioco è quando decidiamo di misurare lo stato quantistico.

Lo stato del qubit come vettore di Bloch

Questo vettore che punta nella direzione della "testa" della moneta è noto come "vettore di Bloch". Formalmente, uno stato arbitrario di qubit (isolato) può essere rappresentato da un vettore che giace sulla superficie di una sfera di raggio 1 con coordinate $(r, \theta, \phi)$. Scritto in termini di queste coordinate, lo stato del qubit è:

$|\psi\rangle = \cos{\frac{\theta}{2}} |0\rangle + e^{i \phi} \sin{\frac{\theta}{2}} |1\rangle$

Ora verifichiamo con Qiskit come cambia il vettore di Bloch quando applichiamo vari gate al nostro qubit partendo dallo stato $|0\rangle$.

NOT

from qiskit.visualization import plot_bloch_multivector

qnot = QuantumCircuit(1)
qnot.x(0)

plot_bloch_multivector(qnot)

$\sqrt{\text{NOT}}$

qsqrtnot = QuantumCircuit(1)
qsqrtnot.sx(0)

plot_bloch_multivector(qsqrtnot)

PHASE ($\phi = \pi$)

qphase = QuantumCircuit(1)
qphase.p(np.pi, 0)

plot_bloch_multivector(qphase)

Hadamard

qhadamard = QuantumCircuit(1)
qhadamard.h(0)

plot_bloch_multivector(qhadamard)

Conclusione — cos'è davvero uno stato di sovrapposizione?

Abbiamo iniziato questo modulo paragonando la casualità della misurazione di uno stato di sovrapposizione quantistica a un lancio di moneta. Abbiamo assimilato il "gate Hadamard" che produce una sovrapposizione quantistica all'atto di lanciare una moneta. Ma, attraverso una serie di esperimenti, abbiamo imparato che esistono differenze fondamentali tra il lancio di una moneta classica e una sovrapposizione quantistica.

Abbiamo scoperto che non c'è nulla di "casuale" in un qubit in uno stato di sovrapposizione. È come una moneta ferma nello spazio tridimensionale. In effetti, una moneta libera di ruotare in 3 dimensioni è un'analogia molto vicina a un particolare modo di visualizzare lo stato quantistico di un qubit, chiamato vettore di Bloch. I gate quantistici ruotano questa moneta/vettore di Bloch in modo deterministico e reversibile. È solo quando misuriamo il qubit che viene introdotta qualsiasi casualità. Abbiamo paragonato questo processo di misurazione allo schiacciare la moneta in modo che giaccia piatta nella direzione dell'asse di misurazione.

Se uno stato quantistico sia anche in sovrapposizione dipende davvero dall'occhio di chi guarda. Come avrai probabilmente già incontrato, siamo liberi di scegliere il nostro sistema di coordinate — $x$, $y$ e $z$ possono puntare in qualsiasi tre direzioni ortogonali. Quindi, se abbiamo una sovrapposizione di 0 e 1 in un sistema di coordinate, possiamo definire un nuovo sistema di coordinate — o equivalentemente, una nuova "base di misurazione" — in cui lo stato punta puramente nella direzione $+z$, e quindi non si trova in uno stato di sovrapposizione. Quindi, quando diciamo che un qubit è in sovrapposizione, dobbiamo anche rispondere alla domanda: "sovrapposizione di cosa?"

Potresti concludere questo modulo con l'impressione di aver appena rimosso tutto il mistero dalla meccanica quantistica. Dopotutto, uno degli aspetti apparentemente "più strani", lo stato di sovrapposizione di un qubit, è in realtà semplice come un vettore tridimensionale. Ma tieni presente che la moneta è ancora solo un'analogia, e anche il vettore di Bloch è solo uno strumento di visualizzazione per calcolare le probabilità dei risultati di misurazione. Non possiamo dire cosa stia davvero facendo uno stato quantistico prima di essere misurato. Perché, verificarlo richiede una misurazione!

Discuteremo questo dilemma di qual è la "vera" natura di uno stato quantistico, e di come il fenomeno quantistico dell'entanglement possa aiutarci a chiarirlo, nel modulo sull'Ineguaglianza di Bell.

Domande

Gli istruttori possono richiedere versioni di questi notebook con le chiavi delle risposte e indicazioni sul loro inserimento nei curricula comuni compilando questo breve sondaggio su come vengono utilizzati i notebook.

Concetti fondamentali:

• Mentre la misurazione di un qubit in sovrapposizione è probabilistica, come il lancio di una moneta, lo stato di sovrapposizione si comporta diversamente da una moneta che gira in aria.
• Una differenza principale tra una distribuzione di probabilità classica e una sovrapposizione è che la sovrapposizione ha coerenza di fase, che le consente di interferire in modo costruttivo o distruttivo.
• Lo stato di un singolo qubit isolato può essere visualizzato come un punto sulla cosiddetta "sfera di Bloch," dove le ampiezze relative dei componenti $|0\rangle$ e $|1\rangle$ determinano l'angolo polare $\theta$ e le fasi relative tra i due componenti determinano l'angolo azimutale $\phi$.
• Tutti i gate quantistici a singolo qubit possono essere visti come rotazioni del vettore su questa sfera.

Domande V/F:

1. V/F Una sovrapposizione quantistica è fondamentalmente uguale a un evento probabilistico nella fisica classica, come il lancio di una moneta.

2. V/F La lunghezza del vettore di Bloch che descrive lo stato di un singolo qubit isolato è sempre 1.

3. V/F I gate quantistici a singolo qubit non cambiano la lunghezza del vettore di Bloch.

Domande a scelta multipla:

1. Seleziona il vettore di Bloch corretto che rappresenta lo stato $|\Psi\rangle = \sqrt{\frac{1}{3}}|0\rangle + e^{i \pi / 4} \sqrt{\frac{2}{3}}|1\rangle$:

2. La sfera di Bloch descrive: (seleziona tutte le risposte corrette)

   a. ampiezza

   b. entanglement con altri qubit

   c. fase

   d. colore

   e. probabilità dei risultati di misurazione

Domande di discussione:

1. Perché lo stato di un qubit può essere visualizzato sulla sfera di Bloch, ma la distribuzione di probabilità del lancio di una moneta non può?

2. Perché una moneta che gira in aria non è la migliore analogia per uno stato di sovrapposizione quantistica? Quale aspetto delle sovrapposizioni non viene catturato da questa analogia?

Problemi avanzati:

1. Usa Qiskit per creare un circuito che trasformi lo stato $|0\rangle$ nello stato $\frac{\sqrt{3}}{2}|0\rangle + \frac{1}{2}e^{i \frac{5\pi}{6}}|1\rangle$