Observablen in der Pauli-Basis angeben

Paketversionen

Der Code auf dieser Seite wurde mit den folgenden Anforderungen entwickelt. Wir empfehlen, diese Versionen oder neuere zu verwenden.

qiskit[all]~=2.3.0

In der Quantenmechanik entsprechen Observablen physikalischen Eigenschaften, die gemessen werden können. Wenn du ein System von Spins betrachtest, könntest du zum Beispiel daran interessiert sein, die Energie des Systems zu messen oder Informationen über die Ausrichtung der Spins zu erhalten, wie etwa die Magnetisierung oder die Korrelationen zwischen Spins.

Um eine $n$-Qubit-Observable $O$ auf einem Quantencomputer zu messen, musst du sie als Summe von Tensorprodukten von Pauli-Operatoren darstellen, das heißt

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

wobei

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

und du die Tatsache nutzt, dass eine Observable hermitesch ist, also $O^\dagger = O$. Wenn $O$ nicht hermitesch ist, kann sie trotzdem als Summe von Paulis zerlegt werden, aber der Koeffizient $\alpha_k$ wird komplex.

In vielen Fällen ist die Observable nach der Abbildung des betrachteten Systems auf Qubits natürlicherweise in dieser Darstellung angegeben. Ein Spin-1/2-System kann beispielsweise auf einen Ising-Hamiltonian abgebildet werden:

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

wobei die Indizes $\langle i, j\rangle$ über wechselwirkende Spins laufen und die Spins einem transversalen Feld in $X$ ausgesetzt sind. Der tiefgestellte Index gibt an, auf welches Qubit der Pauli-Operator wirkt, d. h. $X_i$ wendet einen $X$-Operator auf Qubit $i$ an und lässt die übrigen unverändert.

Im Qiskit SDK kann dieser Hamiltonian mit dem folgenden Code konstruiert werden.

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

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)

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])

Wenn wir die Energie messen möchten, ist die Observable der Hamiltonian selbst. Alternativ könnten wir auch Systemeigenschaften wie die mittlere Magnetisierung messen, indem wir die Anzahl der in $Z$-Richtung ausgerichteten Spins mit der Observable zählen:

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

Für Observablen, die nicht in Form von Pauli-Operatoren, sondern in Matrixform gegeben sind, müssen wir sie zunächst in der Pauli-Basis umformulieren, um sie auf einem Quantencomputer auswerten zu können. Eine solche Darstellung ist immer möglich, da die Pauli-Matrizen eine Basis für die hermiteschen $2^n \times 2^n$-Matrizen bilden. Wir entwickeln die Observable $O$ als

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

wobei die Summe über alle möglichen $n$-Qubit-Pauli-Terme läuft und $\mathrm{Tr}(\cdot)$ die Spur einer Matrix ist, die als inneres Produkt wirkt. Du kannst diese Zerlegung von einer Matrix in Pauli-Terme mit der Methode SparsePauliOp.from_operator implementieren, etwa so:

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)

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

Das bedeutet, die Matrix kann als Pauli-Terme geschrieben werden: $O = -Z_1 + 0.5 X_2 + Y_2 Y_1$.

hinweis

Beachte, dass die Reihenfolge des Tensorprodukts auf Qubits abgebildet wird als $q_n \otimes q_{n-1} \otimes \cdots \otimes q_1$.

hinweis

Wenn die Observable hermitesch ist (d. h. $O^\dagger = O$), sind die Pauli-Koeffizienten reelle Zahlen. Wir können jedoch auch jede andere komplexe Matrix in Paulis zerlegen, wenn wir komplexwertige Koeffizienten zulassen.

In Pauli-Basen messen

Eine Messung projiziert den Qubit-Zustand auf die Rechenbasis $\{|0\rangle, |1\rangle\}$. Das bedeutet, du kannst nur Observablen messen, die in dieser Basis diagonal sind, also Paulis, die ausschließlich aus $I$- und $Z$-Termen bestehen. Das Messen beliebiger Pauli-Terme erfordert daher einen Basiswechsel zur Diagonalisierung. Dazu führst du folgende Transformationen durch:

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

wobei $H$ das Hadamard-Gate und $S = \sqrt{Z}$ manchmal als Phasen-Gate bezeichnet wird. Wenn du einen Estimator zur Berechnung von Erwartungswerten verwendest, werden die Basistransformationen automatisch durchgeführt.

Im Folgenden wird ein Beispiel gezeigt, das demonstriert, wie du einen Quantum Circuit vorbereitest und Qubit 0 manuell in der X-Basis, Qubit 1 in der Y-Basis und Qubit 2 in der Z-Basis misst. Wir wenden die in der vorherigen Gleichung gezeigten Transformationen an und erhalten den folgenden Circuit:

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")

Nächste Schritte

Empfehlungen

• Lies die SparsePauliOp-API-Referenz.