Tukuyin ang mga observable sa Pauli basis

Mga bersyon ng package

Ang code sa pahinang ito ay ginawa gamit ang mga sumusunod na requirements. Inirerekomenda naming gamitin ang mga bersyong ito o mas bago.

qiskit[all]~=2.5.2

Sa quantum mechanics, ang mga observable ay tumutugma sa mga pisikal na katangian na maaaring sukatin. Kapag pinag-aaralan ang isang sistema ng mga spin, halimbawa, maaaring interesado ka sa pagsukat ng enerhiya ng sistema o sa pagkuha ng impormasyon tungkol sa pagkakahanay ng mga spin, tulad ng magnetization o ng mga correlation sa pagitan ng mga spin.

Para sukatin ang isang $n$-qubit observable na $O$ sa isang quantum computer, kailangan mong ipahayag ito bilang kabuuan ng mga tensor product ng mga Pauli operator, ibig sabihin

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

kung saan

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

at ginagamit mo ang katotohanang ang observable ay Hermitian, ibig sabihin, $O^\dagger = O$. Kung ang $O$ ay hindi Hermitian, maaari pa rin itong i-decompose bilang kabuuan ng mga Pauli, ngunit ang coefficient na $\alpha_k$ ay magiging complex.

Sa maraming kaso, ang observable ay natural na tinutukoy sa representasyong ito matapos i-map ang sistema ng interes sa mga qubit. Halimbawa, ang isang spin-1/2 na sistema ay maaaring i-map sa isang Ising Hamiltonian

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

kung saan ang mga index na $\langle i, j\rangle$ ay tumatakbo sa mga nakikipag-ugnayan na spin at ang mga spin ay napapailalim sa transverse field sa $X$. Ang subscript index ay nagpapahiwatig kung saang qubit kumikilos ang Pauli operator, ibig sabihin, ang $X_i$ ay nag-aaplay ng $X$ operator sa qubit $i$ at iniiwang hindi nagbabago ang iba pang qubit.

Sa Qiskit SDK, ang Hamiltonian na ito ay maaaring itayo gamit ang sumusunod na code.

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

Kung gusto nating sukatin ang enerhiya, ang observable ay ang Hamiltonian mismo. Bilang alternatibo, maaaring interesado tayong sukatin ang mga katangian ng sistema tulad ng average magnetization sa pamamagitan ng pagbilang ng mga spin na nakahanay sa $Z$-direksyon gamit ang observable

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

Para sa mga observable na hindi ibinibigay sa mga Pauli operator kundi sa matrix form, kailangan muna nating baguhin ang representasyon nito sa Pauli basis para masuri ang mga ito sa isang quantum computer. Palagi tayong makakahanap ng ganitong representasyon dahil ang mga Pauli matrix ay bumubuo ng basis para sa Hermitian $2^n \times 2^n$ na mga matrix. Pinapalawak natin ang observable na $O$ bilang

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

kung saan ang kabuuan ay tumatakbo sa lahat ng posibleng $n$-qubit Pauli term at ang $\mathrm{Tr}(\cdot)$ ay ang trace ng isang matrix, na gumaganap bilang isang inner product. Ang factor na $1/2^n$ ay para sa Hilbert–Schmidt normalization ng $n$-qubit Pauli strings. Maaari mong ipatupad ang decomposition na ito mula sa isang matrix patungong Pauli term gamit ang SparsePauliOp.from_operator na method, ganito:

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

Ibig sabihin nito, ang matrix ay maaaring isulat bilang mga Pauli term na $O = -Z_1 + 0.5 X_2 + Y_2 Y_1$.

tala

Tandaan na ang pagkakasunod-sunod ng tensor product ay tumutugma sa mga qubit bilang $q_n \otimes q_{n-1} \otimes \cdots \otimes q_1$.

tala

Kung ang observable ay Hermitian (ibig sabihin, $O^\dagger = O$), ang mga Pauli coefficient ay mga tunay na numero. Gayunpaman, maaari rin nating i-decompose ang anumang iba pang complex matrix sa mga Pauli, kung papayagan natin ang mga complex-valued na coefficient.

Sukatin sa mga Pauli basis

Ang isang measurement ay nagpro-project ng estado ng qubit sa computational basis na $\{|0\rangle, |1\rangle\}$. Ibig sabihin nito, maaari ka lang sumukat ng mga observable na diagonal sa basis na ito, tulad ng mga Pauli na binubuo lamang ng $I$ at $Z$ na mga term. Kaya nangangailangan ng pagbabago ng basis ang pagsukat ng mga arbitrary na Pauli term para i-diagonalize ang mga ito. Para gawin ito, isagawa ang mga sumusunod na transformasyon,

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

kung saan ang $H$ ay ang Hadamard gate at ang $S = \sqrt{Z}$ ay tinatawag minsan na phase gate. Kung gumagamit ka ng Estimator para sa pagkalkula ng mga expectation value, ang mga basis transformation ay awtomatikong isinasagawa.

Nasa ibaba ang isang halimbawa na nagpapakita kung paano maghanda ng quantum circuit at mano-manong sukatin ang qubit 0 sa X basis, ang qubit 1 sa Y basis, at ang qubit 2 sa Z basis. Inilalapat natin ang mga transformasyong ipinakita sa nakaraang equation at nakukuha natin ang sumusunod na 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")

Mga susunod na hakbang

Mga rekomendasyon

• Basahin ang SparsePauliOp API reference.