การเปลี่ยนเฟส Nishimori

ประมาณการใช้งาน: 3 นาทีบนโปรเซสเซอร์ Heron r2 (หมายเหตุ: นี่เป็นการประมาณการเท่านั้น เวลาที่ใช้จริงอาจแตกต่างกัน)

พื้นหลัง

บทช่วยสอนนี้แสดงวิธีการสร้างการเปลี่ยนเฟส Nishimori บนโปรเซสเซอร์ควอนตัม IBM® การทดลองนี้ถูกอธิบายไว้ครั้งแรกใน Realizing the Nishimori transition across the error threshold for constant-depth quantum circuits

การเปลี่ยนเฟส Nishimori หมายถึงการเปลี่ยนผ่านระหว่างเฟสที่มีลำดับระยะสั้นและระยะยาวในแบบจำลอง random-bond Ising บนคอมพิวเตอร์ควอนตัม เฟสที่มีลำดับระยะยาวแสดงออกมาในรูปของสถานะที่ Qubit ต่างๆ มีการพันกันทั่วทั้งอุปกรณ์ สถานะที่พันกันสูงนี้ถูกเตรียมโดยใช้โปรโตคอล การสร้างการพันกันด้วยการวัด (GEM) โดยใช้การวัดกลางวงจร โปรโตคอล GEM สามารถพัน Qubit ทั่วทั้งอุปกรณ์ได้โดยใช้ Circuit ที่มีความลึกคงที่เท่านั้น บทช่วยสอนนี้ใช้การนำโปรโตคอล GEM ไปใช้จาก ซอฟต์แวร์แพ็กเกจ GEM Suite

ข้อกำหนดเบื้องต้น

ก่อนเริ่มบทช่วยสอนนี้ ให้แน่ใจว่าคุณมีสิ่งต่อไปนี้ติดตั้งอยู่:

• Qiskit SDK v1.0 หรือใหม่กว่า พร้อมการสนับสนุน การแสดงผล
• Qiskit Runtime v0.22 หรือใหม่กว่า ( pip install qiskit-ibm-runtime )
• GEM Suite ( pip install gem-suite )

การตั้งค่า

# Added by doQumentation — required packages for this notebook
!pip install -q gem-suite matplotlib qiskit qiskit-ibm-runtime

import matplotlib.pyplot as plt

from collections import defaultdict

from qiskit_ibm_runtime import QiskitRuntimeService

from qiskit.transpiler import generate_preset_pass_manager

from gem_suite import PlaquetteLattice
from gem_suite.experiments import GemExperiment

ขั้นตอนที่ 1: แปลงอินพุตแบบคลาสสิกเป็นปัญหาควอนตัม

โปรโตคอล GEM ทำงานบนโปรเซสเซอร์ควอนตัมที่มีการเชื่อมต่อ Qubit ที่อธิบายด้วย lattice โปรเซสเซอร์ควอนตัม IBM ในปัจจุบันใช้ heavy hex lattice Qubit ของโปรเซสเซอร์ถูกจัดกลุ่มเป็น plaquette ตามเซลล์หน่วยของ lattice ที่มันอยู่ เนื่องจาก Qubit หนึ่งอาจอยู่ในเซลล์หน่วยมากกว่าหนึ่งเซลล์ plaquette จึงไม่แยกออกจากกัน บน heavy hex lattice แต่ละ plaquette มี 12 Qubit plaquette เองก็ก่อตัวเป็น lattice เช่นกัน โดย plaquette สองอันจะเชื่อมต่อกันหากมี Qubit ร่วมกัน บน heavy hex lattice plaquette ที่อยู่ข้างกันจะมี Qubit ร่วมกัน 3 ตัว

ในซอฟต์แวร์แพ็กเกจ GEM Suite คลาสพื้นฐานสำหรับการนำโปรโตคอล GEM ไปใช้คือ PlaquetteLattice ซึ่งแทน lattice ของ plaquette (ซึ่งแตกต่างจาก heavy hex lattice) PlaquetteLattice สามารถเริ่มต้นได้จาก qubit coupling map ปัจจุบันรองรับเฉพาะ coupling map แบบ heavy hex เท่านั้น

โค้ดต่อไปนี้เริ่มต้น plaquette lattice จาก coupling map ของโปรเซสเซอร์ควอนตัม IBM plaquette lattice ไม่ได้ครอบคลุมฮาร์ดแวร์ทั้งหมดเสมอไป ตัวอย่างเช่น ibm_torino มี Qubit ทั้งหมด 133 ตัว แต่ plaquette lattice ที่ใหญ่ที่สุดที่พอดีกับอุปกรณ์นี้ใช้เพียง 125 ตัวเท่านั้น และประกอบด้วย plaquette ทั้งหมด 18 อัน สิ่งที่คล้ายกันนี้สามารถสังเกตได้สำหรับอุปกรณ์ IBM Quantum® ที่มีจำนวน Qubit ต่างกันด้วย

# QiskitRuntimeService.save_account(channel="ibm_quantum", token="<YOUR_API_KEYN>", overwrite=True, set_as_default=True)
service = QiskitRuntimeService()
backend = service.least_busy(
    operational=True, simulator=False, min_num_qubits=127
)
plaquette_lattice = PlaquetteLattice.from_coupling_map(backend.coupling_map)

print(f"Number of qubits in backend: {backend.num_qubits}")
print(
    f"Number of qubits in plaquette lattice: {len(list(plaquette_lattice.qubits()))}"
)
print(f"Number of plaquettes: {len(list(plaquette_lattice.plaquettes()))}")

Number of qubits in backend: 133
Number of qubits in plaquette lattice: 125
Number of plaquettes: 18

คุณสามารถแสดงผล plaquette lattice ได้โดยสร้างแผนภาพของการแทนกราฟ ในแผนภาพ plaquette จะแสดงด้วยรูปหกเหลี่ยมที่มีป้ายกำกับ และ plaquette สองอันจะเชื่อมต่อกันด้วยขอบหากมี Qubit ร่วมกัน

plaquette_lattice.draw_plaquettes()

คุณสามารถดึงข้อมูลเกี่ยวกับ plaquette แต่ละอัน เช่น Qubit ที่มีอยู่ โดยใช้เมธอด plaquettes

# Get a list of the plaquettes
plaquettes = list(plaquette_lattice.plaquettes())
# Display information about plaquette 0
plaquettes[0]

PyPlaquette(index=0, qubits=[0, 1, 2, 3, 4, 15, 16, 19, 20, 21, 22, 23], neighbors=[3, 1])

คุณยังสามารถสร้างแผนภาพของ Qubit พื้นฐานที่ก่อตัวเป็น plaquette lattice ได้

plaquette_lattice.draw_qubits()

นอกจากป้ายกำกับ Qubit และขอบที่แสดงว่า Qubit ตัวใดเชื่อมต่อกัน แผนภาพยังมีข้อมูลเพิ่มเติมสามส่วนที่เกี่ยวข้องกับโปรโตคอล GEM:

• Qubit แต่ละตัวจะมีเฉดสี (สีเทา) หรือไม่มีเฉดสี Qubit ที่มีเฉดสีคือ Qubit "ไซต์" ที่แทนไซต์ของแบบจำลอง Ising และ Qubit ที่ไม่มีเฉดสีคือ Qubit "พันธะ" ที่ใช้เป็นตัวกลางสำหรับปฏิสัมพันธ์ระหว่าง Qubit ไซต์
• Qubit ไซต์แต่ละตัวจะถูกติดป้ายว่า (A) หรือ (B) ซึ่งบ่งบอกถึงหนึ่งในสองบทบาทที่ Qubit ไซต์สามารถมีได้ในโปรโตคอล GEM (บทบาทจะอธิบายในภายหลัง)
• แต่ละขอบจะถูกระบายสีโดยใช้หนึ่งในหกสี ทำให้ขอบถูกแบ่งออกเป็นหกกลุ่ม การแบ่งพาร์ทิชันนี้กำหนดวิธีที่เกตสองคิวบิตสามารถทำแบบขนานได้ รวมถึงรูปแบบการจัดกำหนดการต่างๆ ที่มีแนวโน้มจะเกิดข้อผิดพลาดในปริมาณต่างกันบนโปรเซสเซอร์ควอนตัมที่มีสัญญาณรบกวน เนื่องจากขอบในกลุ่มเดียวกันไม่มีจุดร่วม จึงสามารถใช้ชั้นของเกตสองคิวบิตกับขอบเหล่านั้นพร้อมกันได้ จริงๆ แล้ว สามารถแบ่งสีหกสีออกเป็นสามกลุ่ม กลุ่มละสองสี ได้ โดยที่สหภาพของแต่ละกลุ่มสองสียังคงไม่มีจุดร่วม ดังนั้น จำเป็นต้องใช้เพียงสามชั้นของเกตสองคิวบิตเพื่อเปิดใช้งานทุกขอบ มี 12 วิธีในการแบ่งพาร์ทิชันหกสีดังกล่าว และแต่ละพาร์ทิชันให้กำหนดการเกต 3 ชั้นที่แตกต่างกัน

เมื่อสร้าง plaquette lattice แล้ว ขั้นตอนถัดไปคือการเริ่มต้นออบเจ็กต์ GemExperiment โดยส่งทั้ง plaquette lattice และ Backend ที่ต้องการรันการทดลองนั้น คลาส GemExperiment จัดการการนำโปรโตคอล GEM ไปใช้จริง รวมถึงการสร้าง Circuit การส่งงาน และการวิเคราะห์ข้อมูล โค้ดต่อไปนี้เริ่มต้นคลาสการทดลองขณะจำกัด plaquette lattice ให้เหลือเพียงสอง plaquette (21 Qubit) เพื่อลดขนาดการทดลองและให้แน่ใจว่าสัญญาณรบกวนในฮาร์ดแวร์ไม่ท่วมสัญญาณ

gem_exp = GemExperiment(plaquette_lattice.filter([9, 12]), backend=backend)

# visualize the plaquette lattice after filtering
plaquette_lattice.filter([9, 12]).draw_qubits()

Circuit ของโปรโตคอล GEM ถูกสร้างขึ้นโดยใช้ขั้นตอนต่อไปนี้:

1. เตรียมสถานะ all-$|+\rangle$ โดยใช้ Hadamard Gate กับ Qubit ทุกตัว
2. ใช้ $R_{ZZ}$ Gate ระหว่าง Qubit ที่เชื่อมต่อกันทุกคู่ ซึ่งทำได้โดยใช้ 3 ชั้นของ Gate แต่ละ $R_{ZZ}$ Gate ทำงานบน Qubit ไซต์และ Qubit พันธะ หาก Qubit ไซต์ถูกติดป้าย (B) มุมจะถูกกำหนดไว้ที่ $\frac{\pi}{2}$ หาก Qubit ไซต์ถูกติดป้าย (A) มุมจะได้รับอนุญาตให้เปลี่ยนแปลงได้ ทำให้ Circuit แตกต่างกัน โดยค่าเริ่มต้น ช่วงของมุมถูกตั้งค่าให้เป็น 21 จุดที่เว้นระยะเท่ากันระหว่าง $0$ ถึง $\frac{\pi}{2}$ รวมจุดสุดท้าย
3. วัด Qubit พันธะแต่ละตัวในฐาน Pauli $X$ เนื่องจาก Qubit ถูกวัดในฐาน Pauli $Z$ จึงสามารถทำได้โดยใช้ Hadamard Gate ก่อนวัด Qubit

สังเกตว่าเอกสารอ้างอิงในบทนำของบทช่วยสอนนี้ใช้แบบแผนที่ต่างกันสำหรับมุม $R_{ZZ}$ ซึ่งแตกต่างจากแบบแผนที่ใช้ในบทช่วยสอนนี้ด้วยปัจจัย 2

ในขั้นตอนที่ 3 มีเพียง Qubit พันธะเท่านั้นที่ถูกวัด เพื่อเข้าใจว่า Qubit ไซต์อยู่ในสถานะอะไร เป็นเรื่องน่าพิจารณาถึงกรณีที่มุม $R_{ZZ}$ ที่ใช้กับ Qubit ไซต์ (A) ในขั้นตอนที่ 2 เท่ากับ $\frac{\pi}{2}$ ในกรณีนี้ Qubit ไซต์จะอยู่ในสถานะที่พันกันสูงคล้ายกับสถานะ GHZ

$$\lvert \text{GHZ} \rangle = \lvert 00 \cdots 00 \rangle + \lvert 11 \cdots 11 \rangle.$$

เนื่องจากความสุ่มในผลลัพธ์การวัด สถานะจริงของ Qubit ไซต์อาจเป็นสถานะที่ต่างกันที่มีลำดับระยะยาว ตัวอย่างเช่น $\lvert 00110 \rangle + \lvert 11001 \rangle$ อย่างไรก็ตาม สถานะ GHZ สามารถกู้คืนได้โดยการใช้การดำเนินการถอดรหัสตามผลการวัด เมื่อมุม $R_{ZZ}$ ถูกปรับลดจาก $\frac{\pi}{2}$ ลำดับระยะยาวยังคงกู้คืนได้จนถึงมุมวิกฤต ซึ่งในกรณีที่ไม่มีสัญญาณรบกวนอยู่ที่ประมาณ $0.3 \pi$ ต่ำกว่ามุมนี้ สถานะที่ได้จะไม่แสดงการพันกันระยะยาวอีกต่อไป การเปลี่ยนผ่านระหว่างการมีและไม่มีลำดับระยะยาวนี้คือการเปลี่ยนเฟส Nishimori

ในคำอธิบายข้างต้น Qubit ไซต์ถูกปล่อยไว้โดยไม่ได้วัด และการดำเนินการถอดรหัสสามารถทำได้โดยการใช้ Gate ควอนตัม ในการทดลองตามที่นำไปใช้ใน GEM suite ซึ่งบทช่วยสอนนี้ตาม Qubit ไซต์ถูกวัดจริงๆ และการดำเนินการถอดรหัสจะถูกนำไปใช้ในขั้นตอนหลังประมวลผลแบบคลาสสิก

ในคำอธิบายข้างต้น การดำเนินการถอดรหัสสามารถทำได้โดยการใช้ Gate ควอนตัมกับ Qubit ไซต์เพื่อกู้คืนสถานะควอนตัม อย่างไรก็ตาม หากเป้าหมายคือการวัดสถานะทันที ตัวอย่างเช่น เพื่อวัตถุประสงค์ในการระบุลักษณะ Qubit ไซต์จะถูกวัดพร้อมกับ Qubit พันธะ และการดำเนินการถอดรหัสสามารถนำไปใช้ในขั้นตอนหลังประมวลผลแบบคลาสสิกได้ นี่คือวิธีที่การทดลองถูกนำไปใช้ใน GEM suite ซึ่งบทช่วยสอนนี้ตาม

นอกจากขึ้นอยู่กับมุม $R_{ZZ}$ ในขั้นตอนที่ 2 ซึ่งโดยค่าเริ่มต้นสแกนผ่าน 21 ค่า โปรโตคอล GEM Circuit ยังขึ้นอยู่กับรูปแบบการจัดกำหนดการที่ใช้ในการนำ 3 ชั้นของ $R_{ZZ}$ Gate ไปใช้ด้วย ดังที่กล่าวไว้ก่อนหน้า มี 12 รูปแบบการจัดกำหนดการดังกล่าว ดังนั้น จำนวน Circuit ทั้งหมดในการทดลองคือ $21 \times 12 = 252$

Circuit ของการทดลองสามารถสร้างได้โดยใช้เมธอด circuits ของคลาส GemExperiment

circuits = gem_exp.circuits()
print(f"Total number of circuits: {len(circuits)}")

Total number of circuits: 252

สำหรับจุดประสงค์ของบทช่วยสอนนี้ การพิจารณารูปแบบการจัดกำหนดการเพียงรูปแบบเดียวก็เพียงพอ โค้ดต่อไปนี้จำกัดการทดลองให้เหลือรูปแบบการจัดกำหนดการแรก ส่งผลให้การทดลองมีเพียง 21 Circuit หนึ่งสำหรับมุม $R_{ZZ}$ แต่ละค่าที่สแกนผ่าน

# Restrict experiment to the first scheduling pattern
gem_exp.set_experiment_options(schedule_idx=0)

# There are less circuits now
circuits = gem_exp.circuits()
print(f"Total number of circuits: {len(circuits)}")

# Print the RZZ angles swept over
print(f"RZZ angles:\n{gem_exp.parameters()}")

Total number of circuits: 21
RZZ angles:
[0.         0.07853982 0.15707963 0.23561945 0.31415927 0.39269908
 0.4712389  0.54977871 0.62831853 0.70685835 0.78539816 0.86393798
 0.9424778  1.02101761 1.09955743 1.17809725 1.25663706 1.33517688
 1.41371669 1.49225651 1.57079633]

โค้ดต่อไปนี้วาดแผนภาพของ Circuit ที่อินเด็กซ์ 5 เพื่อลดขนาดของแผนภาพ เกตการวัดที่ท้าย Circuit จะถูกลบออก

# Get the circuit at index 5
circuit = circuits[5]
# Remove the final measurements to ease visualization
circuit.remove_final_measurements()
# Draw the circuit
circuit.draw("mpl", fold=-1, scale=0.5)

ขั้นตอนที่ 2: ปรับปรุงปัญหาสำหรับการประมวลผลบนฮาร์ดแวร์ควอนตัม

การ Transpile Circuit ควอนตัมสำหรับการรันบนฮาร์ดแวร์มักเกี่ยวข้องกับ หลายขั้นตอน โดยทั่วไป ขั้นตอนที่มีโอเวอร์เฮดการคำนวณมากที่สุดคือการเลือกเลย์เอาต์ Qubit การกำหนดเส้นทาง Gate สองคิวบิตให้สอดคล้องกับการเชื่อมต่อ Qubit ของฮาร์ดแวร์ และการปรับแต่ง Circuit เพื่อลดจำนวน Gate และความลึก ในโปรโตคอล GEM ขั้นตอนเลย์เอาต์และการกำหนดเส้นทางไม่จำเป็น เนื่องจากการเชื่อมต่อฮาร์ดแวร์ถูกรวมไว้ในการออกแบบโปรโตคอลแล้ว Circuit มีเลย์เอาต์ Qubit อยู่แล้ว และ Gate สองคิวบิตถูกแมปกับการเชื่อมต่อ native แล้ว นอกจากนี้ เพื่อรักษาโครงสร้างของ Circuit ขณะที่มุม $R_{ZZ}$ เปลี่ยนแปลง ควรทำการปรับแต่ง Circuit เพียงขั้นพื้นฐานเท่านั้น

คลาส GemExperiment ทำการ Transpile Circuit อย่างโปร่งใสเมื่อรันการทดลอง ขั้นตอนเลย์เอาต์และการกำหนดเส้นทางถูกแทนที่โดยค่าเริ่มต้นให้ไม่ทำอะไร และการปรับแต่ง Circuit จะทำในระดับที่ปรับแต่งเฉพาะ Gate คิวบิตเดี่ยวเท่านั้น อย่างไรก็ตาม คุณสามารถแทนที่หรือส่งตัวเลือกเพิ่มเติมโดยใช้เมธอด set_transpile_options เพื่อแสดงให้เห็นด้านภาพ โค้ดต่อไปนี้ทำการ Transpile Circuit ที่แสดงก่อนหน้าด้วยตนเองและวาด Circuit ที่ถูก Transpile แล้ว

# Demonstrate setting transpile options
gem_exp.set_transpile_options(
    optimization_level=1  # This is the default optimization level
)
pass_manager = generate_preset_pass_manager(
    backend=backend,
    initial_layout=list(gem_exp.physical_qubits),
    **dict(gem_exp.transpile_options),
)
transpiled = pass_manager.run(circuit)
transpiled.draw("mpl", idle_wires=False, fold=-1, scale=0.5)

ขั้นตอนที่ 3: ประมวลผลโดยใช้ Qiskit primitives

เพื่อรัน Circuit ของโปรโตคอล GEM บนฮาร์ดแวร์ ให้เรียกเมธอด run ของออบเจ็กต์ GemExperiment คุณสามารถระบุจำนวน shot ที่ต้องการสุ่มตัวอย่างจากแต่ละ Circuit เมธอด run คืนค่า ExperimentData ซึ่งควรบันทึกไว้ในตัวแปร สังเกตว่าเมธอด run เพียงแค่ส่งงานโดยไม่รอให้เสร็จ ดังนั้นจึงเป็นการเรียกแบบ non-blocking

exp_data = gem_exp.run(shots=10_000)

เพื่อรอผลลัพธ์ ให้เรียกเมธอด block_for_results ของออบเจ็กต์ ExperimentData การเรียกนี้จะทำให้ตัวแปลโปรแกรมรอจนกว่างานจะเสร็จ

exp_data.block_for_results()

ExperimentData(GemExperiment, d0d5880a-34c1-4aab-a7b6-c4f58516bc03, job_ids=['cwg12ptmptp00082khhg'], metadata=<5 items>, figure_names=['two_point_correlation.svg', 'normalized_variance.svg', 'plaquette_ops.svg', 'bond_ops.svg'])

ขั้นตอนที่ 4: หลังประมวลผลและแสดงผลในรูปแบบคลาสสิกที่ต้องการ

ที่มุม $R_{ZZ}$ เท่ากับ $\frac{\pi}{2}$ สถานะที่ถอดรหัสแล้วจะเป็นสถานะ GHZ ในกรณีที่ไม่มีสัญญาณรบกวน ลำดับระยะยาวของสถานะ GHZ สามารถแสดงได้โดยการพล็อตค่าแม่เหล็กของบิตสตริงที่วัดได้ ค่าแม่เหล็ก $M$ ถูกนิยามเป็นผลรวมของตัวดำเนินการ Pauli $Z$ คิวบิตเดี่ยว

$$M = \sum_{j=1}^N Z_j,$$

โดยที่ $N$ คือจำนวน Qubit ไซต์ ค่าสำหรับบิตสตริงหนึ่งเท่ากับความแตกต่างระหว่างจำนวนศูนย์และจำนวนหนึ่ง การวัดสถานะ GHZ จะให้สถานะ all zeros หรือ all ones ด้วยความน่าจะเป็นเท่ากัน ดังนั้นค่าแม่เหล็กจะเป็น $+N$ ครึ่งหนึ่งของเวลาและ $-N$ อีกครึ่งหนึ่ง เมื่อมีข้อผิดพลาดจากสัญญาณรบกวน ค่าอื่นก็จะปรากฏขึ้นด้วย แต่ถ้าสัญญาณรบกวนไม่มากเกินไป การกระจายก็ยังคงมียอดอยู่ใกล้ $+N$ และ $-N$

สำหรับบิตสตริงดิบก่อนการถอดรหัส การกระจายของค่าแม่เหล็กจะเทียบเท่ากับบิตสตริงแบบสุ่มสม่ำเสมอในกรณีที่ไม่มีสัญญาณรบกวน

โค้ดต่อไปนี้พล็อตค่าแม่เหล็กของบิตสตริงดิบและบิตสตริงที่ถอดรหัสแล้วที่มุม $R_{ZZ}$ เท่ากับ $\frac{\pi}{2}$

def magnetization_distribution(
    counts_dict: dict[str, int],
) -> dict[str, float]:
    """Compute magnetization distribution from counts dictionary."""
    # Construct dictionary from magnetization to count
    mag_dist = defaultdict(float)
    for bitstring, count in counts_dict.items():
        mag = bitstring.count("0") - bitstring.count("1")
        mag_dist[mag] += count
    # Normalize
    shots = sum(counts_dict.values())
    for mag in mag_dist:
        mag_dist[mag] /= shots
    return mag_dist

# Get counts dictionaries with and without decoding
data = exp_data.data()
# Get the last data point, which is at the angle for the GHZ state
raw_counts = data[-1]["counts"]
# Without decoding
site_indices = [
    i for i, q in enumerate(gem_exp.plaquettes.qubits()) if q.role == "Site"
]
site_raw_counts = defaultdict(int)
for key, val in raw_counts.items():
    site_str = "".join(key[-1 - i] for i in site_indices)
    site_raw_counts[site_str] += val
# With decoding
_, site_decoded_counts = gem_exp.plaquettes.decode_outcomes(
    raw_counts, return_counts=True
)

# Compute magnetization distribution
raw_magnetization = magnetization_distribution(site_raw_counts)
decoded_magnetization = magnetization_distribution(site_decoded_counts)

# Plot
plt.bar(*zip(*raw_magnetization.items()), label="raw")
plt.bar(*zip(*decoded_magnetization.items()), label="decoded", width=0.3)
plt.legend()
plt.xlabel("Magnetization")
plt.ylabel("Frequency")
plt.title("Magnetization distribution with and without decoding")

Text(0.5, 1.0, 'Magnetization distribution with and without decoding')

เพื่อระบุลักษณะลำดับระยะยาวอย่างเข้มงวดมากขึ้น คุณสามารถตรวจสอบค่าสหสัมพันธ์สองจุดเฉลี่ย $f$ ที่นิยามเป็น

$$f = \frac{1}{N^2} \left(\langle M^2 \rangle - \langle M \rangle ^2\right).$$

ค่าที่สูงขึ้นบ่งบอกถึงระดับการพันกันที่มากขึ้น คลาส GemExperiment คำนวณค่านี้สำหรับบิตสตริงที่ถอดรหัสแล้วโดยอัตโนมัติเป็นส่วนหนึ่งของการประมวลผลข้อมูลการทดลอง มันเก็บรูปภาพที่เข้าถึงได้ผ่านเมธอด figure ของคลาสข้อมูลการทดลอง ในกรณีนี้ ชื่อของรูปภาพคือ two_point_correlation

exp_data.figure("two_point_correlation")

เพื่อกำหนดจุดวิกฤตของการเปลี่ยนเฟส Nishimori คุณสามารถดูความแปรปรวนที่ปรับให้เป็นมาตรฐานของ $M^2 / N$ ที่นิยามเป็น

$$g = \frac{1}{N^3} \left(\langle M^4 \rangle - \langle M^2 \rangle^2\right),$$

ซึ่งวัดปริมาณความผันแปรในค่าแม่เหล็กกำลังสอง ค่านี้จะสูงสุดที่จุดวิกฤตของการเปลี่ยนเฟส Nishimori ในกรณีที่ไม่มีสัญญาณรบกวน จุดวิกฤตจะอยู่ที่ประมาณ $0.3 \pi$ เมื่อมีสัญญาณรบกวน จุดวิกฤตจะเลื่อนขึ้น แต่การเปลี่ยนเฟสยังคงสังเกตได้ตราบเท่าที่จุดวิกฤตอยู่ต่ำกว่า $0.5 \pi$

exp_data.figure("normalized_variance")

ขยายขนาดการทดลอง

โค้ดต่อไปนี้รันการทดลองสำหรับหก plaquette (49 Qubit) และ plaquette เต็ม 12 อัน (125 Qubit) และพล็อตความแปรปรวนที่ปรับให้เป็นมาตรฐาน เมื่อการทดลองถูกขยายไปยังขนาดที่ใหญ่ขึ้น ปริมาณสัญญาณรบกวนที่มากขึ้นจะเลื่อนจุดวิกฤตไปทางขวา

gem_exp = GemExperiment(
    plaquette_lattice.filter(range(3, 9)), backend=backend
)
gem_exp.set_experiment_options(schedule_idx=0)
exp_data = gem_exp.run(shots=10_000)
exp_data.block_for_results()
exp_data.figure("normalized_variance")

gem_exp = GemExperiment(plaquette_lattice, backend=backend)
gem_exp.set_experiment_options(schedule_idx=0)
exp_data = gem_exp.run(shots=10_000)
exp_data.block_for_results()
exp_data.figure("normalized_variance")

สรุป

ในบทช่วยสอนนี้ คุณได้สร้างการเปลี่ยนเฟส Nishimori บนโปรเซสเซอร์ควอนตัมโดยใช้โปรโตคอล GEM เมตริกที่ตรวจสอบในขั้นตอนหลังประมวลผล โดยเฉพาะอย่างยิ่งสหสัมพันธ์สองจุดและความแปรปรวนที่ปรับให้เป็นมาตรฐาน ทำหน้าที่เป็นตัวชี้วัดความสามารถของอุปกรณ์ในการสร้างสถานะที่พันกันระยะยาว ตัวชี้วัดเหล่านี้ขยายประโยชน์ของโปรโตคอล GEM ออกไปนอกเหนือจากการตรวจสอบฟิสิกส์ที่น่าสนใจ เป็นส่วนหนึ่งของโปรโตคอล คุณได้พัน Qubit ทั่วทั้งอุปกรณ์โดยใช้ Circuit ที่มีความลึกคงที่เท่านั้น ความสำเร็จนี้เป็นไปได้เพราะโปรโตคอลใช้การวัดกลางวงจร ในการทดลองนี้ สถานะที่พันกันถูกวัดทันที แต่เส้นทางที่น่าสนใจที่จะสำรวจคือการนำสถานะนั้นไปใช้ต่อในการประมวลผลควอนตัมเพิ่มเติม!

แบบสำรวจบทช่วยสอน

โปรดทำแบบสำรวจสั้นๆ นี้เพื่อให้คำติชมเกี่ยวกับบทช่วยสอนนี้ ข้อมูลเชิงลึกของคุณจะช่วยให้เราปรับปรุงเนื้อหาและประสบการณ์ผู้ใช้

ลิงก์ไปยังแบบสำรวจ

Note: This survey is provided by IBM Quantum and relates to the original English content. To give feedback on doQumentation's website, translations, or code execution, please open a GitHub issue.