Tentukan observabel dalam basis Pauli

Versi paket

Kode di halaman ini dikembangkan menggunakan persyaratan berikut. Kami merekomendasikan menggunakan versi ini atau yang lebih baru.

qiskit[all]~=2.3.0

Dalam mekanika kuantum, observabel merupakan properti fisik yang bisa diukur. Saat mempertimbangkan sistem spin, misalnya, kamu mungkin tertarik mengukur energi sistem atau mendapatkan informasi tentang keselarasan spin, seperti magnetisasi atau korelasi antar spin.

Untuk mengukur observabel $n$-Qubit $O$ pada komputer kuantum, kamu harus merepresentasikannya sebagai jumlah dari perkalian tensor operator Pauli, yaitu

$$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 kamu menggunakan fakta bahwa observabel bersifat Hermitian, artinya $O^\dagger = O$. Jika $O$ tidak Hermitian, ia tetap bisa didekomposisi sebagai jumlah Pauli, tapi koefisien $\alpha_k$ menjadi bilangan kompleks.

Dalam banyak kasus, observabel secara alami ditentukan dalam representasi ini setelah memetakan sistem yang diminati ke Qubit. Misalnya, sistem spin-1/2 bisa dipetakan ke 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 pada spin yang berinteraksi dan spin tunduk pada medan transversal dalam $X$. Indeks subskrip menunjukkan Qubit mana yang dioperasikan oleh operator Pauli, yaitu $X_i$ menerapkan operator $X$ pada Qubit $i$ dan membiarkan sisanya tidak berubah.

Dalam Qiskit SDK, Hamiltonian ini bisa dikonstruksi dengan kode 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 energi, observabelnya adalah Hamiltonian itu sendiri. Alternatifnya, kita mungkin tertarik mengukur properti sistem seperti rata-rata magnetisasi dengan menghitung jumlah spin yang selaras dalam arah $Z$ menggunakan observabel

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

Untuk observabel yang tidak diberikan dalam bentuk operator Pauli tetapi dalam bentuk matriks, kita harus terlebih dahulu merumuskannya ulang dalam basis Pauli agar bisa dievaluasi pada komputer kuantum. Kita selalu bisa menemukan representasi seperti itu karena matriks Pauli membentuk basis untuk matriks Hermitian $2^n \times 2^n$. Kita ekspansi observabel $O$ sebagai

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

di mana jumlahan berjalan pada semua kemungkinan suku Pauli $n$-Qubit dan $\mathrm{Tr}(\cdot)$ adalah jejak matriks, yang berfungsi sebagai hasil kali dalam. Kamu bisa mengimplementasikan dekomposisi dari matriks ke suku Pauli menggunakan metode 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 berarti matriks bisa ditulis sebagai suku Pauli yaitu $O = -Z_1 + 0.5 X_2 + Y_2 Y_1$.

catatan

Ingat bahwa urutan perkalian tensor dipetakan ke Qubit sebagai $q_n \otimes q_{n-1} \otimes \cdots \otimes q_1$.

catatan

Jika observabel bersifat Hermitian (artinya $O^\dagger = O$), koefisien Pauli adalah bilangan real. Namun, kita juga bisa mendekomposisi matriks kompleks lainnya dalam bentuk Pauli, jika kita mengizinkan koefisien bernilai kompleks.

Ukur dalam basis Pauli

Pengukuran memproyeksikan keadaan Qubit ke basis komputasi $\{|0\rangle, |1\rangle\}$. Ini berarti kamu hanya bisa mengukur observabel yang diagonal dalam basis ini, seperti Pauli yang hanya terdiri dari suku $I$ dan $Z$. Mengukur suku Pauli sembarang karena itu memerlukan perubahan basis untuk mendiagonalisasinya. 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$ adalah Gate Hadamard dan $S = \sqrt{Z}$ kadang disebut sebagai Gate fase. Jika kamu menggunakan Estimator untuk menghitung nilai ekspektasi, transformasi basis dilakukan secara otomatis.

Berikut adalah contoh yang menunjukkan cara menyiapkan Circuit kuantum dan mengukur secara manual Qubit 0 dalam basis X, Qubit 1 dalam basis Y, dan Qubit 2 dalam basis Z. Kita terapkan transformasi yang ditunjukkan pada persamaan sebelumnya dan mendapatkan Circuit 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 selanjutnya

Rekomendasi

• Baca referensi SparsePauliOp API.