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

ספריית Circuit

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

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

qiskit[all]~=2.3.0

ה-Qiskit SDK כולל ספרייה של Circuits פופולריים לשימוש כאבני בניין בתוכניות שלך. שימוש ב-Circuits מוגדרים מראש חוסך זמן בחקירה, כתיבת קוד ואיתור שגיאות. הספרייה כוללת Circuits פופולריים בחישוב קוונטי, Circuits שקשה לדמות אותם קלאסית, ו-Circuits שימושיים לבנצ'מארקינג של חומרה קוונטית.

דף זה מציג את קטגוריות ה-Circuit השונות שהספרייה מספקת. לרשימה המלאה של Circuits, ראה את תיעוד ה-API של ספריית ה-Circuit.

Gates סטנדרטיים​

ספריית ה-Circuit כוללת גם Gates קוונטיים סטנדרטיים. חלקם הם Gates בסיסיים יותר (כגון UGate), ואחרים הם Gates רב-Qubit שבדרך כלל צריך לבנות מ-Gates של Qubit יחיד ושני Qubits. כדי להוסיף Gates מיובאים ל-Circuit שלך, השתמש במתודה append; הארגומנט הראשון הוא ה-Gate, והארגומנט הבא הוא רשימת Qubits להחיל עליהם את ה-Gate.

לדוגמה, תא הקוד הבא יוצר Circuit עם Hadamard gate ו-Gate רב-שליטה-X.

# Added by doQumentation — required packages for this notebook
!pip install -q qiskit
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, MCXGate

mcx_gate = MCXGate(3)
hadamard_gate = HGate()

qc = QuantumCircuit(4)
qc.append(hadamard_gate, [0])
qc.append(mcx_gate, [0, 1, 2, 3])
qc.draw("mpl")

Output of the previous code cell

ראה Gates סטנדרטיים בתיעוד ה-API של ספריית ה-Circuit.

Not sure what your gate's called? Try asking Qiskit Code Assistant.

Circuits מסוג N-local​

Circuits אלו מחלפים שכבות של Gates סיבוב לכל Qubit בנפרד עם שכבות של Gates שזירה רב-Qubit.

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

תא הקוד הבא מייבא Circuit מסוג n_local, שבו Gates השזירה הם Gates של שני Qubits. Circuit זה מערב בלוקים של Gates חד-Qubit בעלי פרמטרים, ואחריהם בלוקי שזירה של Gates דו-Qubit. הקוד הבא יוצר Circuit של שלושה Qubits, עם Gates RX לכל Qubit ו-Gates CZ דו-Qubit.

from qiskit.circuit.library import n_local

two_local = n_local(3, "rx", "cz")
two_local.draw("mpl")

Output of the previous code cell

ניתן לקבל אובייקט דמוי-רשימה של פרמטרי ה-Circuit מהמאפיין parameters.

two_local.parameters
ParameterView([ParameterVectorElement(θ[0]), ParameterVectorElement(θ[1]), ParameterVectorElement(θ[2]), ParameterVectorElement(θ[3]), ParameterVectorElement(θ[4]), ParameterVectorElement(θ[5]), ParameterVectorElement(θ[6]), ParameterVectorElement(θ[7]), ParameterVectorElement(θ[8]), ParameterVectorElement(θ[9]), ParameterVectorElement(θ[10]), ParameterVectorElement(θ[11])])

ניתן גם להשתמש בזה כדי להקצות לפרמטרים אלו ערכים אמיתיים באמצעות מילון בצורה { Parameter: number }. להדגמה, תא הקוד הבא מקצה לכל פרמטר ב-Circuit את הערך 0.

bound_circuit = two_local.assign_parameters(
    {p: 0 for p in two_local.parameters}
)
bound_circuit.decompose().draw("mpl")

Output of the previous code cell

למידע נוסף, ראה Gates מסוג N-local בתיעוד ה-API של ספריית ה-Circuit, או קח את קורס עיצוב אלגוריתמים ווריאציוניים ב-IBM Quantum Learning.

Circuits לקידוד נתונים​

Circuits בעלי פרמטרים אלו מקודדים נתונים למצבים קוונטיים לעיבוד על ידי אלגוריתמי למידת מכונה קוונטית. כמה Circuits הנתמכים על ידי Qiskit הם:

  • קידוד אמפליטודה, שמקודד כל מספר לאמפליטודה של מצב בסיס. זה יכול לאחסן 2n2^n מספרים במצב יחיד, אך עלול להיות יקר ליישום.
  • קידוד בסיס, שמקודד מספר שלם kk על ידי הכנת מצב הבסיס המתאים ∣k⟩|k\rangle.
  • קידוד זווית, שקובע כל מספר בנתונים כזווית סיבוב ב-Circuit בעל פרמטרים.

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

from qiskit.circuit.library import zz_feature_map

features = [0.2, 0.4, 0.8]
feature_map = zz_feature_map(feature_dimension=len(features))

encoded = feature_map.assign_parameters(features)
encoded.draw("mpl")

Output of the previous code cell

ראה Circuits לקידוד נתונים בתיעוד ה-API של ספריית ה-Circuit.

Circuits לאבולוציית זמן​

Circuits אלו מדמים מצב קוונטי המתפתח בזמן. השתמש ב-Circuits לאבולוציית זמן כדי לחקור תופעות פיזיקליות כמו העברת חום או מעברי פאזה במערכת. Circuits לאבולוציית זמן הם גם אבן בניין בסיסית של פונקציות גל בכימיה (כמו מצבי ניסיון unitary coupled-cluster) ושל אלגוריתם ה-QAOA שאנו משתמשים בו לבעיות אופטימיזציה.

from qiskit.circuit.library import PauliEvolutionGate
from qiskit.circuit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp

# Prepare an initial state with a Hadamard on the middle qubit
state = QuantumCircuit(3)
state.h(1)

hamiltonian = SparsePauliOp(["ZZI", "IZZ"])
evolution = PauliEvolutionGate(hamiltonian, time=1)

# Evolve state by appending the evolution gate
state.compose(evolution, inplace=True)

state.draw("mpl")

Output of the previous code cell

קרא את תיעוד ה-API של PauliEvolutionGate.

Circuits לבנצ'מארקינג ותורת המורכבות​

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

לדוגמה, בנצ'מארק "נפח קוונטי" מודד עד כמה מחשב קוונטי מבצע בדיוק סוג של Circuit קוונטי אקראי. הציון של המחשב הקוונטי עולה עם גודל ה-Circuit שהוא יכול להפעיל בצורה אמינה. זה לוקח בחשבון את כל ההיבטים של המחשב, כולל מספר Qubits, נאמנות הוראות, קישוריות Qubits, ו-Software Stack של Transpiling ועיבוד תוצאות לאחר מכן. קרא עוד על נפח קוונטי במאמר הנפח הקוונטי המקורי.

הקוד הבא מציג דוגמה של Circuit נפח קוונטי שנבנה ב-Qiskit ופועל על ארבעה Qubits (הבלוקים unitary הם Gates דו-Qubit אקראיים).

from qiskit.circuit.library import quantum_volume

quantum_volume(4).draw("mpl")

Output of the previous code cell

ספריית ה-Circuit כוללת גם Circuits שמאמינים שקשה לדמות אותם קלאסית, כמו Circuits פולינומיאליים קוונטיים מיידיים (iqp). Circuits אלו מכניסים Gates אלכסוניים מסוימים (בבסיס חישובי) בין בלוקי Hadamard gates.

Circuits נוספים כוללים את grover_operator לשימוש באלגוריתם גרובר, ואת Circuit fourier_checking לבעיית בדיקת פורייה. ראה Circuits אלו בCircuits קוונטיים מיוחדים בתיעוד ה-API של ספריית ה-Circuit.

Circuits אריתמטיים​

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

כדוגמה, בוא ננסה לחבר שני מספרים בני שלושה ביטים באמצעות Circuit "ripple-carry" לביצוע חיבור במקום (FullAdderGate). מחבר זה מחבר שני מספרים (נקרא להם "A" ו-"B") וכותב את התוצאה לרגיסטר שהכיל את B. בדוגמה הבאה, A=2 ו-B=3.

from qiskit.circuit.library import FullAdderGate
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister

adder = FullAdderGate(3)  # Adder of 3-bit numbers

# Create the number A=2
reg_a = QuantumRegister(3, "a")
number_a = QuantumCircuit(reg_a)
number_a.initialize(2)  # Number 2; |010>

# Create the number B=3
reg_b = QuantumRegister(3, "b")
number_b = QuantumCircuit(reg_b)
number_b.initialize(3)  # Number 3; |011>

# Create a circuit to hold everything, including a classical register for
# the result
qregs = [
    QuantumRegister(1, "cin"),
    QuantumRegister(3, "a"),
    QuantumRegister(3, "b"),
    QuantumRegister(1, "cout"),
]
reg_result = ClassicalRegister(3)
circuit = QuantumCircuit(*qregs, reg_result)

# Compose number initializers with the adder. Adder stores the result to
# register B, so we'll measure those qubits.
circuit = (
    circuit.compose(number_a, qubits=reg_a)
    .compose(number_b, qubits=reg_b)
    .compose(adder)
)
circuit.measure(reg_b, reg_result)
circuit.draw("mpl")

Output of the previous code cell

דימוי ה-Circuit מראה שהוא מפיק 5 לכל 1024 הירויות (כלומר נמדד עם הסתברות 1.0).

from qiskit.primitives import StatevectorSampler

result = StatevectorSampler().run([circuit]).result()

print(f"Count data:\n {result[0].data.c0.get_int_counts()}")
Count data:
 {5: 1024}

ראה אריתמטיקה בתיעוד ה-API של ספריית ה-Circuit.

צעדים הבאים​

המלצות