דלג לתוכן הראשי

ציון אובזרבבלים בבסיס פאולי

גרסאות חבילות

הקוד בדף זה פותח תוך שימוש בדרישות הבאות. אנו ממליצים להשתמש בגרסאות אלו או בגרסאות חדשות יותר.

qiskit[all]~=2.3.0

במכניקת הקוונטים, אובזרבבלים מתאימים לתכונות פיזיקליות שניתן למדוד. כשבוחנים מערכת של ספינים, למשל, אפשר להתעניין במדידת האנרגיה של המערכת או בקבלת מידע על יישור הספינים, כמו המגנטיזציה או הקורלציות בין ספינים.

כדי למדוד אובזרבבל nn-Qubit OO על מחשב קוונטי, יש לייצג אותו כסכום של מכפלות טנסוריות של אופרטורי פאולי, כלומר

O=∑k=1KαkPk,  Pk∈{I,X,Y,Z}⊗n,  αk∈R,O = \sum_{k=1}^K \alpha_k P_k,~~ P_k \in \{I, X, Y, Z\}^{\otimes n},~~ \alpha_k \in \mathbb{R},

כאשר

I=(1001)  X=(0110)  Y=(0−ii0)  Z=(100−1)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}

ומשתמשים בעובדה שאובזרבבל הוא הרמיטי, כלומר O†=OO^\dagger = O. אם OO אינו הרמיטי, עדיין ניתן לפרק אותו כסכום של פאולים, אך המקדם αk\alpha_k הופך מרוכב.

במקרים רבים, האובזרבבל מוגדר באופן טבעי בייצוג זה לאחר מיפוי המערכת המעניינת ל-Qubits. לדוגמה, מערכת ספין-1/2 ניתנת למיפוי להמילטוניאן איזינג

H=∑⟨i,j⟩ZiZj−∑i=1nXi,H = \sum_{\langle i, j\rangle} Z_i Z_j - \sum_{i=1}^n X_i,

כאשר האינדקסים ⟨i,j⟩\langle i, j\rangle רצים על ספינים מקיימי אינטראקציה, והספינים כפופים לשדה רוחבי ב-XX. אינדקס המשנה מציין על איזה Qubit פועל אופרטור פאולי, כלומר XiX_i מפעיל אופרטור XX על Qubit ii ומשאיר את השאר ללא שינוי.

ב-Qiskit SDK, ניתן לבנות את ההמילטוניאן הזה עם הקוד הבא.

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

אם נרצה למדוד את האנרגיה, האובזרבבל הוא ההמילטוניאן עצמו. לחלופין, אפשר להתעניין במדידת תכונות המערכת כמו המגנטיזציה הממוצעת על ידי ספירת מספר הספינים המיושרים בכיוון ZZ עם האובזרבבל

O=1n∑i=1ZiO = \frac{1}{n} \sum_{i=1} Z_i

עבור אובזרבבלים שאינם נתונים במונחי אופרטורי פאולי אלא בצורת מטריצה, יש קודם לנסח אותם מחדש בבסיס פאולי כדי לחשב אותם על מחשב קוונטי. תמיד ניתן למצוא ייצוג כזה שכן מטריצות פאולי מהוות בסיס למטריצות ההרמיטיות 2n×2n2^n \times 2^n. מפרקים את האובזרבבל OO כ-

O=∑P∈{I,X,Y,Z}⊗nTr(OP)P,O = \sum_{P \in \{I, X, Y, Z\}^{\otimes n}} \mathrm{Tr}(O P) P,

כאשר הסכום רץ על כל איברי פאולי nn-Qubit האפשריים ו-Tr(⋅)\mathrm{Tr}(\cdot) הוא העקבה של מטריצה, הפועלת כמכפלה פנימית. ניתן לממש פירוק זה ממטריצה לאיברי פאולי באמצעות מתודת SparsePauliOp.from_operator, כך:

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

משמעות הדבר היא שניתן לכתוב את המטריצה כאיברי פאולי: O=−Z1+0.5X2+Y2Y1O = -Z_1 + 0.5 X_2 + Y_2 Y_1.

הערה

זכור שסדר המכפלה הטנסורית ממפה ל-Qubits כ-qn⊗qn−1⊗⋯⊗q1q_n \otimes q_{n-1} \otimes \cdots \otimes q_1.

הערה

אם האובזרבבל הרמיטי (כלומר O†=OO^\dagger = O), מקדמי פאולי הם מספרים ממשיים. עם זאת, ניתן גם לפרק כל מטריצה מרוכבת אחרת במונחי פאולים, אם מאפשרים מקדמים עם ערכים מרוכבים.

מדידה בבסיסי פאולי​

מדידה מקרינה את מצב ה-Qubit לבסיס החישובי {∣0⟩,∣1⟩}\{|0\rangle, |1\rangle\}. משמעות הדבר היא שניתן למדוד רק אובזרבבלים שהם אלכסוניים בבסיס זה, כמו פאולים המורכבים רק מאיברי II ו-ZZ. מדידת איברי פאולי שרירותיים מחייבת לכן שינוי בסיס לאלכסון שלהם. לשם כך, מבצעים את הטרנספורמציות הבאות,

X→Z=HXHY→Z=HS†YSH,\begin{aligned} X &\rightarrow Z = H X H \\ Y &\rightarrow Z = H S^\dagger Y S H, \end{aligned}

כאשר HH הוא Gate הדמארד ו-S=ZS = \sqrt{Z} מכונה לפעמים gate הפאזה. אם משתמשים ב-Estimator לחישוב ערכי ציפייה, טרנספורמציות הבסיס מתבצעות אוטומטית.

להלן דוגמה המדגימה כיצד להכין Circuit קוונטי ולמדוד ידנית את Qubit 0 בבסיס X, Qubit 1 בבסיס Y ו-Qubit 2 בבסיס Z. מיישמים את הטרנספורמציות שהוצגו במשוואה הקודמת ומקבלים את ה-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")

Output of the previous code cell

הצעדים הבאים​

המלצות