Specificare gli osservabili nella base di Pauli

Il codice di questa pagina è stato sviluppato in base ai seguenti requisiti. Si consiglia di utilizzare queste versioni o versioni più recenti.
```
qiskit[all]~=2.5.2
```

Nella meccanica quantistica, le osservabili corrispondono a proprietà fisiche che possono essere misurate. Se si considera un sistema di spin, ad esempio, si potrebbe essere interessati a misurare l'energia del sistema o a ottenere informazioni sull'allineamento degli spin, come la magnetizzazione o le correlazioni tra gli spin.

Per misurare un'osservabile $n$ -qubit $O$ su un computer quantistico, è necessario rappresentarla come una somma di prodotti tensoriali di operatori di Pauli, cioè

O = \sum_{k=1}^K \alpha_k P_k,~~ P_k \in \{I, X, Y, Z\}^{\otimes n},~~ \alpha_k \in \mathbb{R},

Dove

I = \begin{pmatrix} 1 & 0 \\ 0 & 1 \end{pmatrix} ~~ X = \begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix} ~~ Y = \begin{pmatrix} 0 & -i \\ i & 0 \end{pmatrix} ~~ Z = \begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix}

e si utilizza il fatto che un'osservabile è ermitiana, come in $O^\dagger = O$ . Se $O$ non è hermitiano, può ancora essere decomposto come una somma di Paulis, ma il coefficiente $\alpha_k$ diventa complesso.

In molti casi, l'osservabile è naturalmente specificata in questa rappresentazione dopo aver mappato il sistema di interesse in qubit. Ad esempio, un sistema spin-1/2 può essere mappato su un'hamiltoniana di Ising

H = \sum_{\langle i, j\rangle} Z_i Z_j - \sum_{i=1}^n X_i,

dove gli indici $\langle i, j\rangle$ si applicano agli spin interagenti e gli spin sono soggetti a un campo trasversale in $X$ . L'indice in apice indica su quale qubit agisce l'operatore di Pauli; in altre parole, $X_i$ applica un operatore $X$ al qubit $i$ e lascia gli altri invariati.

Nell'SDK di Qiskit, questa hamiltoniana può essere costruita con il seguente codice.

from qiskit.quantum_info import SparsePauliOp

# define the number of qubits
n = 12

# define the single Pauli terms as ("Paulis", [indices], coefficient)
interactions = [
    ("ZZ", [i, i + 1], 1) for i in range(n - 1)
]  # we assume spins on a 1D line
field = [("X", [i], -1) for i in range(n)]

# build the operator
hamiltonian = SparsePauliOp.from_sparse_list(
    interactions + field, num_qubits=n
)
print(hamiltonian)

Output:

SparsePauliOp(['IIIIIIIIIIZZ', 'IIIIIIIIIZZI', 'IIIIIIIIZZII', 'IIIIIIIZZIII', 'IIIIIIZZIIII', 'IIIIIZZIIIII', 'IIIIZZIIIIII', 'IIIZZIIIIIII', 'IIZZIIIIIIII', 'IZZIIIIIIIII', 'ZZIIIIIIIIII', 'IIIIIIIIIIIX', 'IIIIIIIIIIXI', 'IIIIIIIIIXII', 'IIIIIIIIXIII', 'IIIIIIIXIIII', 'IIIIIIXIIIII', 'IIIIIXIIIIII', 'IIIIXIIIIIII', 'IIIXIIIIIIII', 'IIXIIIIIIIII', 'IXIIIIIIIIII', 'XIIIIIIIIIII'],
              coeffs=[ 1.+0.j,  1.+0.j,  1.+0.j,  1.+0.j,  1.+0.j,  1.+0.j,  1.+0.j,  1.+0.j,
  1.+0.j,  1.+0.j,  1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j,
 -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j])

Se vogliamo misurare l'energia, l'osservabile è l'hamiltoniana stessa. In alternativa, potremmo essere misurare le proprietà del sistema, come la magnetizzazione media, contando il numero di spins allineati nella direzione $Z$ con l'osservabile

O = \frac{1}{n} \sum_{i=1} Z_i

Per le osservabili che non sono date in termini di operatori di Pauli ma in forma matriciale, dobbiamo prima riformularle in base Pauli per poterle valutare su un computer quantistico nella base di Pauli per poterli valutare su un computer quantistico. Siamo sempre in grado di trovare una rappresentazione di questo tipo, poiché le matrici di Pauli formano una base per le matrici Hermitiane $2^n \times 2^n$ . Espandiamo l'osservabile $O$ come

O = \frac{1}{2^n} \sum_{P \in \{I, X, Y, Z\}^{\otimes n}} \mathrm{Tr}(O P) P,

dove la somma si estende su tutti i possibili termini di Pauli a -qubit di tipo $n$ e $\mathrm{Tr}(\cdot)$ è la traccia di una matrice, che funge da prodotto interno. Il fattore $1/2^n$ descrive la normalizzazione di Hilbert-Schmidt delle stringhe di Pauli a -qubit $n$ . È possibile implementare questa scomposizione da una matrice in termini di Pauli utilizzando il SparsePauliOp.from_operator metodo, in questo modo:

import numpy as np
from qiskit.quantum_info import SparsePauliOp

matrix = np.array(
    [[-1, 0, 0.5, -1], [0, 1, 1, 0.5], [0.5, 1, -1, 0], [-1, 0.5, 0, 1]]
)

observable = SparsePauliOp.from_operator(matrix)
print(observable)

Output:

SparsePauliOp(['IZ', 'XI', 'YY'],
              coeffs=[-1. +0.j,  0.5+0.j,  1. -0.j])

Ciò significa che la matrice può essere scritta in termini di Pauli come $O = -Z_1 + 0.5 X_2 + Y_2 Y_1$ .

Note

Ricordiamo che l'ordine del prodotto tensoriale mappa i qubit come $q_n \otimes q_{n-1} \otimes \cdots \otimes q_1$ .

Note

Se l'osservabile è hermitiana (cioè $O^\dagger = O$ ), i coefficienti di Pauli sono numeri reali. Tuttavia, possiamo anche decomporre qualsiasi altra matrice complessa in termini di Paulis, se ammettiamo coefficienti di valore complesso.

Misura nelle basi di Pauli

Una misura proietta lo stato del qubit nella base computazionale $\{|0\rangle, |1\rangle\}$ . Ciò implica che si possono misurare solo le osservabili che sono diagonali in questa base, come ad esempio la Paulis che consiste solo di termini $I$ e $Z$ . La misurazione di termini di Pauli arbitrari richiede quindi un cambio di base per diagonalizzarli. A tal fine, eseguire le seguenti trasformazioni,

\begin{aligned} X &\rightarrow Z = H X H \\ Y &\rightarrow Z = H S^\dagger Y S H, \end{aligned}

dove $H$ è il gate di Hadamard e $S = \sqrt{Z}$ è talvolta indicato come gate di fase. Se si utilizza un Estimator per calcolare i valori di aspettativa, le trasformazioni di base vengono eseguite automaticamente.

Di seguito è riportato un esempio che dimostra come preparare un circuito quantistico e misurare manualmente il qubit 0 nella base X, il qubit 1 nella base Y e il qubit 2 nella base Z. Applicando le trasformazioni indicate nell'equazione precedente, si ottiene il seguente circuito:

from qiskit.circuit import QuantumCircuit

# create a circuit, where we would like to measure
# q0 in the X basis, q1 in the Y basis and q2 in the Z basis
circuit = QuantumCircuit(3)
circuit.ry(0.8, 0)
circuit.cx(0, 1)
circuit.cx(1, 2)
circuit.barrier()

# diagonalize X with the Hadamard gate
circuit.h(0)

# diagonalize Y with Hadamard as S^\dagger
circuit.sdg(1)
circuit.h(1)

# the Z basis is the default, no action required here

# measure all qubits
circuit.measure_all()
circuit.draw("mpl")

Output:

Passi successivi

Suggerimenti

Leggete il riferimento all' API SparsePauliOp.

Questa pagina è stata utile?

Segnala un bug, un errore di battitura o richiedi contenuti su GitHub.