סדר הביטים ב-Qiskit SDK

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

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

qiskit[all]~=2.5.2

אם יש לכם קבוצה של $n$ ביטים (או קיוביטים), בדרך כלל תסמנו כל ביט $0 \rightarrow n-1$. תוכנות ומשאבים שונים חייבים לבחור כיצד לסדר את הביטים הללו הן בזיכרון המחשב והן כאשר הם מוצגים על המסך.

מוסכמות Qiskit

כך ה-Qiskit SDK מסדר ביטים בתרחישים שונים.

פרימיטיבים

כברירת מחדל, Qiskit פועל לפי מוסכמת סידור הביטים little-endian. עם זאת, ברירת המחדל של BitArray היא big (endian), מה שגורם להבדלים מסוימים בפלט הפרימיטיבים, בהתאם לשאלה אם הפרימיטיב משנה הגדרה זו. לדוגמה, הפרימיטיבים Sampler ו-Estimator של IBM® Quantum Compute Service מחזירים תוצאות big-endian, אבל Executor מחזיר תוצאות little-endian.

מעגלים קוונטיים

המחלקה QuantumCircuit שומרת את הקיוביטים שלה ברשימה (QuantumCircuit.qubits). האינדקס של קיוביט ברשימה זו מגדיר את התווית שלו.

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"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 import QuantumCircuit, QuantumRegister
from qiskit.circuit import Qubit

qc = QuantumCircuit(2)
qc.qubits[0]  # qubit "0"

Qubit(QuantumRegister(2, "q"), 0)

<Qubit register=(2, "q"), index=0>

דיאגרמות מעגל

בדיאגרמת מעגל, קיוביט $0$ הוא הקיוביט העליון ביותר, וקיוביט $n-1$ הוא התחתון ביותר. ניתן לשנות זאת עם הארגומנט reverse_bits של QuantumCircuit.draw (ראה שינוי הסדר ב-Qiskit).

qc.x(1)
qc.draw()

q_0: ─────
     ┌───┐
q_1: ┤ X ├
     └───┘

מספרים שלמים

כשמפרשים ביטים כמספר, ביט $0$ הוא ביט הערך הנמוך ביותר (least significant), וביט $n-1$ הוא ביט הערך הגבוה ביותר. זה שימושי בכתיבת קוד מכיוון שלכל ביט יש את הערך $2^\text{label}$ (כאשר label הוא אינדקס הקיוביט ב-QuantumCircuit.qubits). לדוגמה, ריצת המעגל הבאה מסתיימת עם ביט $0$ בערך 0 וביט $1$ בערך 1. זה מפורש כמספר עשרוני 2 (נמדד עם הסתברות 1.0).

from qiskit.primitives import StatevectorSampler as Sampler

qc.measure_all()

job = Sampler().run([qc])
result = job.result()
print(f" > Counts: {result[0].data.meas.get_counts()}")

> Counts: {'10': 1024}

מחרוזות

כשמציגים או מפרשים רשימת ביטים (או קיוביטים) כמחרוזת, ביט $n-1$ הוא הביט השמאלי ביותר וביט $0$ הוא הביט הימני ביותר. הסיבה לכך היא שאנחנו בדרך כלל כותבים מספרים עם הספרה המשמעותית ביותר משמאל, וב-Qiskit ביט $n-1$ מפורש כביט הערך הגבוה ביותר.

לדוגמה, התא הבא מגדיר Statevector ממחרוזת של מצבי קיוביט בודד. במקרה זה, קיוביט $0$ נמצא במצב $|+\rangle$ וקיוביט $1$ נמצא במצב $|0\rangle$.

from qiskit.quantum_info import Statevector

sv = Statevector.from_label("0+")
sv.probabilities_dict()

{np.str_('00'): np.float64(0.4999999999999999),
 np.str_('01'): np.float64(0.4999999999999999)}

לפעמים זה גורם לבלבול בעת פירוש מחרוזת ביטים, כיוון שאולי תצפו שהביט השמאלי ביותר יהיה ביט $0$, בעוד שבדרך כלל הוא מייצג ביט $n-1$.

מטריצות וקטור מצב

כשמייצגים וקטור מצב כרשימה של מספרים מרוכבים (אמפליטודות), Qiskit מסדר את האמפליטודות כך שהאמפליטודה באינדקס $x$ מייצגת את מצב הבסיס החישובי $|x\rangle$.

print(sv[1])  # amplitude of state |01>
print(sv[2])  # amplitude of state |10>

(0.7071067811865475+0j)
0j

Gates

כל Gate ב-Qiskit יכול לפרש רשימת קיוביטים בדרכו שלו, אך gates מבוקרים בדרך כלל פועלים לפי המוסכמה (control, target).

לדוגמה, התא הבא מוסיף controlled-X gate שבו קיוביט $0$ הוא קיוביט הבקרה וקיוביט $1$ הוא קיוביט המטרה.

from qiskit import QuantumCircuit

qc = QuantumCircuit(2)
qc.cx(0, 1)
qc.draw()

q_0: ──■──
     ┌─┴─┐
q_1: ┤ X ├
     └───┘

בהתאם לכל המוסכמות שהוזכרו קודם ב-Qiskit, ה-CX-gate הזה מבצע את הטרנספורמציה $|01\rangle \leftrightarrow |11\rangle$, ולכן יש לו את המטריצה הבאה.

$$\begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0 \\ \end{pmatrix}$$

שינוי הסדר ב-Qiskit

כדי לצייר מעגל עם קיוביטים בסדר הפוך (כלומר קיוביט $0$ בתחתית), השתמש בארגומנט reverse_bits. זה משפיע רק על הדיאגרמה המיוצרת ולא על המעגל עצמו; ה-X-gate עדיין פועל על קיוביט $0$.

from qiskit import QuantumCircuit

qc = QuantumCircuit(2)
qc.x(0)
qc.draw(reverse_bits=True)

q_1: ─────
     ┌───┐
q_0: ┤ X ├
     └───┘

ניתן להשתמש במתודה reverse_bits כדי להחזיר מעגל חדש עם התוויות של הקיוביטים הפוכות (פעולה זו אינה משנה את המעגל המקורי).

qc.reverse_bits().draw()

q_0: ─────
     ┌───┐
q_1: ┤ X ├
     └───┘

שים לב שבמעגל החדש הזה, ה-X-gate פועל על קיוביט $1$.

השלבים הבאים

המלצות

• ראה דוגמה לשימוש במעגלים במדריך אלגוריתם של גרובר.
• ראה בתיעוד QuantumCircuit API.