Specifică observabile în baza Pauli

Versiuni de pachete

Codul de pe această pagină a fost dezvoltat folosind următoarele cerințe. Recomandăm utilizarea acestor versiuni sau a unora mai noi.

qiskit[all]~=2.6.1

În mecanica cuantică, observabilele corespund proprietăților fizice care pot fi măsurate. Când consideri un sistem de spinuri, de exemplu, ai putea fi interesat să măsori energia sistemului sau să obții informații despre alinierea spinurilor, cum ar fi magnetizarea sau corelațiile dintre spinuri.

Pentru a măsura un observabil $n$-Qubit $O$ pe un calculator cuantic, trebuie să îl reprezinți ca o sumă de produse tensoriale ale operatorilor Pauli, adică

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

unde

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

și folosești faptul că un observabil este hermitian, adică $O^\dagger = O$. Dacă $O$ nu este hermitian, poate fi totuși descompus ca o sumă de Pauli, dar coeficientul $\alpha_k$ devine complex.

În multe cazuri, observabilul este specificat în mod natural în această reprezentare după maparea sistemului de interes la Qubiți. De exemplu, un sistem de spin-1/2 poate fi mapat la un Hamiltonian Ising

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

unde indicii $\langle i, j\rangle$ parcurg spinurile care interacționează, iar spinurile sunt supuse unui câmp transvers în $X$. Indicele subscris indică pe ce qubit acționează operatorul Pauli, adică $X_i$ aplică un operator $X$ pe qubit-ul $i$ și lasă restul neschimbat.

În Qiskit SDK, acest Hamiltonian poate fi construit cu următorul cod.

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

Dacă dorim să măsurăm energia, observabilul este chiar Hamiltonianul. Alternativ, am putea fi interesați să măsurăm proprietăți ale sistemului, cum ar fi magnetizarea medie, numărând spinurile aliniate în direcția $Z$ cu observabilul

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

Pentru observabilele care nu sunt date în termeni de operatori Pauli, ci sub formă de matrice, trebuie mai întâi să le reformulăm în baza Pauli pentru a le evalua pe un calculator cuantic. Putem întotdeauna găsi o astfel de reprezentare, deoarece matricele Pauli formează o bază pentru matricele hermitiene $2^n \times 2^n$. Expandăm observabilul $O$ astfel:

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

unde suma parcurge toți termenii Pauli posibili cu $n$ Qubiți, iar $\mathrm{Tr}(\cdot)$ este urma unei matrice, care acționează ca un produs interior. Factorul $1/2^n$ ține cont de normalizarea Hilbert–Schmidt a șirurilor Pauli cu $n$ Qubiți. Poți implementa această descompunere de la o matrice la termeni Pauli folosind metoda SparsePauliOp.from_operator, astfel:

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

Aceasta înseamnă că matricea poate fi scrisă ca termeni Pauli astfel: $O = -Z_1 + 0.5 X_2 + Y_2 Y_1$.

notă

Reține că ordinea produsului tensorial se mapează la Qubiți astfel: $q_n \otimes q_{n-1} \otimes \cdots \otimes q_1$.

notă

Dacă observabilul este hermitian (adică $O^\dagger = O$), coeficienții Pauli sunt numere reale. Putem însă descompune și orice altă matrice complexă în termeni de Pauli, dacă permitem coeficienți cu valori complexe.

Măsoară în baze Pauli

O măsurătoare proiectează starea qubit-ului pe baza computațională $\{|0\rangle, |1\rangle\}$. Aceasta implică faptul că poți măsura doar observabile care sunt diagonale în această bază, cum ar fi Paulii compuși doar din termeni $I$ și $Z$. Măsurarea termenilor Pauli arbitrari necesită, prin urmare, o schimbare de bază pentru a-i diagonaliza. Pentru aceasta, efectuează următoarele transformări:

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

unde $H$ este poarta Hadamard, iar $S = \sqrt{Z}$ este uneori numită poarta de fază. Dacă folosești un Estimator pentru a calcula valorile de așteptare, transformările de bază sunt efectuate automat.

Mai jos este un exemplu care demonstrează cum să pregătești un circuit cuantic și să măsori manual qubit-ul 0 în baza X, Qubit-ul 1 în baza Y și qubit-ul 2 în baza Z. Aplicăm transformările prezentate în ecuația anterioară și obținem următorul 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")

Pași următori

Recomandări

• Citește referința SparsePauliOp API.