Tentukan observable dalam asas Pauli

Versi pakej

Kod pada halaman ini dibangunkan menggunakan keperluan berikut. Kami mengesyorkan menggunakan versi ini atau yang lebih baharu.

qiskit[all]~=2.5.2

Dalam mekanik kuantum, observable bersesuaian dengan sifat fizikal yang boleh diukur. Apabila mempertimbangkan sistem spin, contohnya, anda mungkin berminat untuk mengukur tenaga sistem atau mendapatkan maklumat tentang penjajaran spin, seperti magnetisasi atau korelasi antara spin.

Untuk mengukur observable $n$-Qubit $O$ pada komputer kuantum, anda mesti mewakilinya sebagai jumlah hasil darab tensor operator Pauli, iaitu

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

di mana

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

dan anda menggunakan fakta bahawa observable adalah Hermitian, iaitu $O^\dagger = O$. Jika $O$ bukan Hermitian, ia masih boleh diuraikan sebagai jumlah Pauli, tetapi pekali $\alpha_k$ menjadi kompleks.

Dalam banyak kes, observable secara semula jadinya ditentukan dalam perwakilan ini selepas memetakan sistem yang diminati kepada qubit. Contohnya, sistem spin-1/2 boleh dipetakan kepada Hamiltonian Ising

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

dengan indeks $\langle i, j\rangle$ merangkumi semua pasangan spin yang berinteraksi dan spin tertakluk kepada medan melintang dalam $X$. Indeks subskrip menunjukkan qubit yang ditindak oleh operator Pauli, iaitu $X_i$ menggunakan operator $X$ pada qubit $i$ dan membiarkan yang lain tidak berubah.

Dalam Qiskit SDK, Hamiltonian ini boleh dibina dengan kod berikut.

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"numpy": "numpy", "qiskit": "qiskit"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

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

Jika kita ingin mengukur tenaga, observable-nya ialah Hamiltonian itu sendiri. Sebagai alternatif, kita mungkin berminat untuk mengukur sifat sistem seperti purata magnetisasi dengan mengira bilangan spin yang disejajarkan dalam arah $Z$ dengan observable

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

Untuk observable yang tidak diberikan dalam bentuk operator Pauli tetapi dalam bentuk matriks, kita perlu terlebih dahulu memformulasikannya semula dalam asas Pauli agar dapat menilainya pada komputer kuantum. Kita sentiasa boleh menemui perwakilan sedemikian kerana matriks Pauli membentuk asas bagi matriks Hermitian $2^n \times 2^n$. Kita kembangkan observable $O$ sebagai

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

dengan jumlah merangkumi semua sebutan Pauli $n$-Qubit yang mungkin dan $\mathrm{Tr}(\cdot)$ ialah surih matriks, yang bertindak sebagai hasil darab dalam. Faktor $1/2^n$ mengambil kira normalisasi Hilbert--Schmidt bagi rentetan Pauli $n$-Qubit. Anda boleh melaksanakan penguraian daripada matriks kepada sebutan Pauli ini menggunakan kaedah SparsePauliOp.from_operator, seperti ini:

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

Ini bermakna matriks boleh ditulis sebagai sebutan Pauli sebagai $O = -Z_1 + 0.5 X_2 + Y_2 Y_1$.

nota

Ingat bahawa susunan hasil darab tensor dipetakan kepada qubit sebagai $q_n \otimes q_{n-1} \otimes \cdots \otimes q_1$.

nota

Jika observable adalah Hermitian (bermakna $O^\dagger = O$), pekali Pauli adalah nombor nyata. Namun, kita juga boleh menguraikan mana-mana matriks kompleks lain dalam bentuk Pauli, jika kita membenarkan pekali bernilai kompleks.

Ukur dalam asas Pauli

Pengukuran mengunjurkan keadaan qubit kepada asas pengiraan $\{|0\rangle, |1\rangle\}$. Ini bermakna anda hanya boleh mengukur observable yang pepenjuru dalam asas ini, seperti Pauli yang hanya terdiri daripada sebutan $I$ dan $Z$. Oleh itu, untuk mengukur sebarang sebutan Pauli, asas perlu ditukar supaya sebutan itu menjadi pepenjuru. Untuk itu, gunakan transformasi berikut,

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

di mana $H$ ialah gate Hadamard dan $S = \sqrt{Z}$ kadangkala dirujuk sebagai gate fasa. Jika anda menggunakan Estimator untuk mengira nilai jangkaan, transformasi asas dilakukan secara automatik.

Di bawah adalah contoh yang menunjukkan cara menyediakan litar kuantum dan mengukur qubit 0 secara manual dalam asas X, Qubit 1 dalam asas Y dan qubit 2 dalam asas Z. Kita gunakan transformasi yang ditunjukkan dalam persamaan sebelumnya dan mendapat litar berikut:

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

Langkah seterusnya

Cadangan

• Baca rujukan SparsePauliOp API.