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.3.0

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 didekomposisikan 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,$$

di mana indeks $\langle i, j\rangle$ berjalan ke atas spin yang berinteraksi dan spin tertakluk kepada medan melintang dalam $X$. Indeks subskrip menunjukkan Qubit mana yang operator Pauli bertindak ke atasnya, 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 — 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])

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 = \sum_{P \in \{I, X, Y, Z\}^{\otimes n}} \mathrm{Tr}(O P) P,$$

di mana jumlah berjalan ke atas semua sebutan Pauli $n$-Qubit yang mungkin dan $\mathrm{Tr}(\cdot)$ ialah jejak matriks, yang bertindak sebagai hasil darab dalam. 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, mengukur sebutan Pauli sewenang-wenangnya memerlukan perubahan asas untuk menjadikannya pepenjuru. Untuk melakukan ini, lakukan 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.