การจำลองธรรมชาติ

ดูวิดีโอนี้จาก Olivia Lanes เกี่ยวกับการจำลองธรรมชาติด้วยคอมพิวเตอร์ควอนตัม หรือเปิดวิดีโอในหน้าต่างแยกบน YouTube.

บทเรียนนี้ใช้เนื้อหาจาก tutorial นี้:

Utility-scale error mitigation with probabilistic error amplification tutorial

บทนำ

หนึ่งในการประยุกต์ใช้ที่น่าสนใจที่สุดของคอมพิวเตอร์ควอนตัมคือความสามารถในการจำลองปรากฏการณ์ธรรมชาติ ในบทเรียนนี้ เราจะสำรวจวิธีที่คอมพิวเตอร์ควอนตัมถูกใช้แก้ปัญหา quantum dynamics โดยเฉพาะวิธีที่พวกมันช่วยเราเข้าใจการวิวัฒนาการตามเวลาของระบบควอนตัม

ก่อนอื่น เราจะมองภาพรวมกว้าง ๆ ของขั้นตอนทั่วไปที่เกี่ยวข้องในการทำการจำลองเหล่านี้ จากนั้นเราจะตรวจสอบตัวอย่างที่เป็นรูปธรรม: การทดลองที่ IBM นำเสนอในปี 2023 ซึ่งแสดงแนวคิดของ quantum utility การทดลองนี้ทำหน้าที่เป็น case study ที่ยอดเยี่ยมสำหรับการเข้าใจขั้นตอนและผลกระทบในทางปฏิบัติของการจำลอง quantum dynamics ด้วยฮาร์ดแวร์ควอนตัมจริง เมื่อจบแล้ว คุณจะมีภาพที่ชัดเจนขึ้นว่านักวิจัยเข้าถึงความท้าทายเหล่านี้อย่างไร และทำไมการจำลองควอนตัมจึงมีแนวโน้มอย่างมากในการพัฒนาความเข้าใจของเราเกี่ยวกับโลกธรรมชาติ

Richard Feynman ให้บรรยายที่มีอิทธิพลอย่างมากที่ Caltech ในปี 1959 มีชื่อที่มีชื่อเสียงว่า "There's Plenty of Room at the Bottom" ในการพาดพิงอย่างสนุกสนานถึงความเป็นไปได้อันกว้างใหญ่ที่ยังไม่ได้สำรวจในระดับไมโครสโคปิก Feynman โต้แย้งว่าฟิสิกส์ส่วนมากในระดับอะตอมและ subatomic ยังไม่ได้ถูกค้นพบ

ความสำคัญของการบรรยายเพิ่มขึ้นในทศวรรษ 1980 เมื่อเทคโนโลยีก้าวหน้า ในช่วงเวลานี้ Feynman กลับมาหาแนวคิดเหล่านี้ในการบรรยายสำคัญอีกครั้งที่ Caltech โดยนำเสนอเอกสารที่ชื่อ "Simulating Nature with Computers" ที่นั่นเขาตั้งคำถามที่กล้าหาญ: คอมพิวเตอร์สามารถใช้ทำการจำลองที่แม่นยำที่จำลองพฤติกรรมของธรรมชาติในระดับควอนตัมได้หรือไม่? Feynman เสนอว่าแทนที่จะพึ่งพาการประมาณคร่าว ๆ ในการสร้างแบบจำลองกระบวนการอะตอม เราสามารถใช้คอมพิวเตอร์ที่ใช้กฎของกลศาสตร์ควอนตัมเอง ไม่ใช่เพียงแค่สร้างแบบจำลองธรรมชาติ แต่เพื่อจำลองมัน

นี่คือประเภทของการจำลองทางกายภาพที่เราจะตรวจสอบผ่านบทเรียนนี้

ระลึกถึงกราฟ timeline นี้ที่แนะนำในตอนก่อนหน้า ปลายหนึ่งของสเปกตรัม เราเห็นปัญหาที่ตรงไปตรงมาในการแก้และไม่ต้องการความเร็วเพิ่มที่การประมวลผลควอนตัมอาจนำมา

ปลายอีกด้านคือปัญหาที่ท้าทายอย่างยิ่งที่ต้องการเครื่อง fault-tolerant ควอนตัมเต็มรูปแบบ ซึ่งเทคโนโลยียังไม่มี โชคดีที่ปัญหาการจำลองหลายอย่างเชื่อกันว่าอยู่ตรงกลางของ timeline นี้ ในช่วงที่คอมพิวเตอร์ควอนตัมในปัจจุบันสามารถนำไปใช้งานได้อย่างมีประสิทธิภาพแล้ว มีเหตุผลหลายอย่างที่จะตื่นเต้นและสนใจกับโอกาสนี้ เนื่องจากการจำลองธรรมชาติเป็นรากฐานสำหรับการประยุกต์ใช้ที่มีแนวโน้มหลากหลาย

ข้อมูลต่อไปนี้ครอบคลุมขั้นตอนการทำงานทั่วไปในการจำลองธรรมชาติแล้วตัวอย่างเฉพาะของขั้นตอนการทำงานเพื่อทำซ้ำผลลัพธ์จากการศึกษาที่รู้จักกันดี

ขั้นตอนการทำงานทั่วไป

ก่อนที่ใครจะนำการประมวลผลควอนตัมไปใช้กับพื้นที่ที่น่าตื่นเต้นเหล่านี้ สำคัญที่จะเข้าใจขั้นตอนพื้นฐานในขั้นตอนการจำลองทั่วไปก่อน:

1. ระบุ system Hamiltonian
2. การเข้ารหัส Hamiltonian
3. การเตรียมสถานะ
4. การวิวัฒนาการตามเวลาของสถานะ
5. การปรับ circuit ให้เหมาะสม
6. การรัน circuit
7. การ post-process

กระบวนการเริ่มต้นด้วยการระบุระบบควอนตัมที่สนใจ ซึ่งช่วยกำหนด Hamiltonian ที่กำกับการวิวัฒนาการตามเวลาของมัน รวมถึงคำอธิบายที่มีความหมายของคุณสมบัติเริ่มต้นหรือสถานะของมัน ต่อไป คุณต้องเลือกวิธีที่เหมาะสมในการใช้การวิวัฒนาการตามเวลาของสถานะนี้ สังเกตว่าสี่ขั้นตอนแรกในขั้นตอนการทำงานนี้เป็นส่วนหนึ่งของขั้นตอน Mapping ในกรอบงาน Qiskit patterns

หลังจากตั้งค่า time-evolution circuit แล้ว ขั้นตอนต่อมาเกี่ยวข้องกับการทำการทดลองจริง ซึ่งปกติรวมถึงการปรับ quantum circuit ที่ใช้อัลกอริทึม time-evolution ให้เหมาะสม การรัน circuit บนฮาร์ดแวร์ควอนตัม และการ post-process ผลลัพธ์ สิ่งเหล่านี้เหมือนกับสามขั้นตอนสุดท้ายในกรอบงาน Qiskit patterns

ต่อไป เราจะพูดถึงความหมายของขั้นตอนเหล่านี้ก่อนที่เราจะไปถึงการ coding

1. ระบุ system Hamiltonian

ขั้นตอนแรกที่สำคัญในการทำการทดลองการจำลองคือการระบุ Hamiltonian ที่อธิบายระบบ ในหลายกรณี Hamiltonian เป็นที่ยอมรับดีแล้ว อย่างไรก็ตาม เรามักสร้างมันโดยการรวมส่วนสนับสนุนพลังงานจากส่วนย่อยของระบบ ซึ่งปกติแสดงเป็นผลรวมของ term:

$$H=\sum_i^N {H_i}$$

โดยที่แต่ละ term $H_i$ ทำงานบน $N$ subsystem ท้องถิ่น (เช่นอนุภาคเดียวหรือกลุ่มอนุภาคขนาดเล็ก) ของ Hamiltonian รวม $H$ ในกรณีของอนุภาคมูลฐานที่ไม่สามารถแยกแยะได้ สำคัญที่จะกำหนดว่าระบบเกี่ยวข้องกับ fermion หรือ boson โดยที่ fermion ปฏิบัติตาม Pauli Exclusion Principle หมายความว่า fermion เดียวกันสองตัวไม่สามารถครอบครอง quantum state เดียวกันเหมือนอิเล็กตรอน ต่างจาก fermion หลาย ๆ boson สามารถอยู่ใน quantum state เดียวกันได้ และความแตกต่างนี้ส่งผลต่อสถิติของระบบและวิธีที่ต้องสร้างแบบจำลอง

ในทางปฏิบัติ ผู้คนมักสนใจระบบทางกายภาพที่องค์ประกอบสันนิษฐานว่าแยกออกจากกันหรือถูกติดฉลาก และด้วยเหตุนี้สามารถแยกแยะได้ เช่นสปินบนแลตทิซ

ระบบนี้ประกอบด้วย magnetic dipole spin ที่จัดเรียงบนแลตทิซ ซึ่งถูกจัดการเป็นอนุภาคที่สามารถแยกแยะได้โดยการนับที่อยู่ ระบบนี้อธิบายโดย Transverse-Field Ising Model และ Hamiltonian ของมันถูกสร้างจากผลรวมของสองส่วน:

$$H = \sum_i^N {H_i} = J \sum_{<i,j>}Z_iZ_j + h\sum_{i=0}^N X_i$$

โดยที่ term แรกแสดงถึงพลังงานปฏิกิริยาระหว่างสปินที่อยู่ติดกัน ที่นี่ $<i,j>$ บ่งชี้ว่าเราหาผลรวมเหนือคู่สปินทั้งหมดที่เชื่อมต่อโดยตรงบนแลตทิซ $Z_i$ และ $Z_j$ คือ Pauli-Z matrix ที่แสดงสถานะของสปินที่ตำแหน่ง $i$ และ $j$ และ $J$ คือค่าคงที่การจับคู่ซึ่งกำหนดความแข็งแกร่งของปฏิกิริยานี้ term ที่สองแสดงถึงอิทธิพลของสนามแม่เหล็กภายนอกที่ใช้กับระบบทั้งหมด ที่นี่ $X_i$ คือ Pauli-X matrix ที่ทำงานบนสปินแต่ละตัวที่ตำแหน่ง $i$ และ $h$ บ่งชี้ความแข็งแกร่งของสนามภายนอกนี้

2. การเข้ารหัส Hamiltonian

ขั้นตอนต่อมาคือการ แปล Hamiltonian เป็นรูปแบบที่คอมพิวเตอร์ควอนตัมสามารถประมวลผลได้ ซึ่งเราเรียกว่าการเข้ารหัส กระบวนการเข้ารหัสนี้ขึ้นอยู่อย่างมากกับประเภทของอนุภาคในระบบ: สามารถแยกแยะหรือไม่สามารถแยกแยะได้ และ fermion หรือ boson หากอนุภาคไม่สามารถแยกแยะได้

ถ้าคุณมีระบบที่มีอนุภาคที่สามารถแยกแยะได้ เช่นสปิน $1/2$ ที่ยึดอยู่บนแลตทิซ ซึ่งเราดูอย่างง่าย ๆ ข้างต้น Hamiltonian มักเขียนในภาษาที่เข้ากันได้กับ Qubit อยู่แล้ว ตัวอย่างเช่น Pauli-Z operator อธิบายสปิน up หรือ down ได้โดยธรรมชาติ และไม่จำเป็นต้องมีการเข้ารหัสพิเศษ

เมื่อจำลองอนุภาคที่ไม่สามารถแยกแยะได้ของ fermion หรือ boson จำเป็นต้องใช้การแปลงการเข้ารหัส อนุภาคเหล่านี้ถูกใช้อธิบายภายในกรอบทางคณิตศาสตร์พิเศษที่เรียกว่า second quantization ซึ่งติดตามตัวเลขการครอบครองของแต่ละ quantum state โดยการแนะนำ creation และ annihilation operator โดยที่ creation operator $\hat{a}_i^\dagger$ เพิ่มอนุภาคหนึ่งตัวสู่สถานะ $i$ ในขณะที่ annihilation operator $\hat{a}_i$ ลบอนุภาคหนึ่งตัวออกจากสถานะ $i$ จากกรอบ second quantization นี้ fermion สามารถแปลงได้โดย Bravyi-Kitaev และ Jordan-Wigner การแปลง Jordan-Wigner กำหนด fermionic creation operator $\hat{f}_j^\dagger = \Bigl( \prod\limits_{k \lt j}{(-Z_k)} \Bigr)\Bigl( \frac{X_j + i Y_j}{2} \Bigr)$ ซึ่งเติม quantum state ที่ $j$ ด้วย fermion และ fermionic annihilation operator $\hat{f}_j= \Bigl( \prod\limits_{k \lt j}{(-Z_k)} \Bigr)\Bigl( \frac{X_j - i Y_j}{2} \Bigr)$ ซึ่งลบ fermion ออกจากสถานะที่ $j$ คุณสามารถหารายละเอียดเพิ่มเติมของการแปลง Jordan-Wigner ที่นี่ Quantum Computing in Practice, ตอนที่ 5 - Mapping ในทำนองเดียวกัน boson ก็ต้องการวิธีการเข้ารหัสของตัวเอง เช่นการแปลง Holstein-Primakoff เพื่อแสดงด้วย Qubit

ท้ายที่สุด ไม่ว่าเส้นทางจะตรงหรือต้องการการแปล เป้าหมายเหมือนกัน: เพื่อแสดง Hamiltonian ของระบบในรูปแบบของ Pauli spin operator ที่คอมพิวเตอร์ควอนตัมสามารถเข้าใจและรันได้

3. การเตรียมสถานะ

หลังจากเข้ารหัส Hamiltonian ที่ต้องการเป็น gate set ของคอมพิวเตอร์ควอนตัมแล้ว ขั้นตอนสำคัญต่อมาคือการเลือก quantum state เริ่มต้นที่เหมาะสมเพื่อเริ่มการจำลอง การเลือก initial state ส่งผลต่อทั้งการบรรจบของอัลกอริทึม variational เช่น Variational Quantum Eigensolver (VQE) รวมถึงส่งผลต่อความแม่นยำและประสิทธิภาพของการวิวัฒนาการตามเวลาและการสุ่มตัวอย่าง โดยพื้นฐานแล้ว initial state ทำหน้าที่เป็นจุดเริ่มต้นของการคำนวณ วางรากฐานสำหรับการดึง observable ที่เป็นประโยชน์จากระบบควอนตัมที่ถูกสร้างแบบจำลอง ตามหลักการ สถานะนี้ควรแสดงถึงการกำหนดค่าที่มีความหมายทางกายภาพของระบบที่กำลังศึกษา

สำหรับการจำลอง quantum chemistry หลายอย่าง Hartree-Fock state สามารถเป็นจุดเริ่มต้นที่ดี ในภาษาของ second quantization Hartree-Fock state ($|\phi\rangle_{HF}$) สร้างขึ้นโดยการนำ creation operator ($\hat{a}_i^\dagger$) สำหรับแต่ละ orbital พลังงานต่ำสุดไปใช้กับ vacuum state ($|vac\rangle = |0_1 ... 0_k ... 0_N\rangle = |0\rangle ^{\otimes N}$) ซึ่งเป็นสถานะที่ไม่มีอิเล็กตรอน

$$|\phi\rangle_{HF} = \prod\limits_{i=1}^k \hat{a}_i^\dagger |0\rangle ^{\otimes N} = \hat{a}_1^\dagger ... \hat{a}_k^\dagger |0_1 ... 0_k ... 0_N\rangle$$

นอกจากนี้ ansatz ที่เตรียมได้ง่ายพร้อม overlap ที่สำคัญกับ ground state จริงสามารถทำหน้าที่เป็น initial state ที่ดีสำหรับปัญหา chemistry เช่นการหา ground state energy

โดยทั่วไปมากขึ้น เราสามารถเขียน $n$-qubit state โดยพลการเป็น superposition ของ computational basis state $∣c_i\rangle$ ที่มีสัมประสิทธิ์ $a_i$ ซึ่งตรงตามเงื่อนไข normalization การเตรียมสถานะดังกล่าวโดยทั่วไปสามารถเข้าถึงได้โดยการใช้ operator เฉพาะ $\hat{O}$ กับ initial state ซึ่งปกติเป็น all-zero standard basis state ตามข้อตกลง

$$|\psi\rangle = \sum_{i=0}^{2^n-1}{a_i |c_i\rangle}=\hat{O}|0\rangle^{\otimes n}\\ \text{with} \qquad \sum_{i=0}^{2^n-1}{|a_i^2|}=1$$

อย่างไรก็ตาม กระบวนการนี้มักต้องการ CNOT Gate จำนวนมากแบบเลขชี้กำลัง ทำให้ใช้ทรัพยากรสูงโดยทั่วไป เรามักมุ่งเน้นที่การเตรียม initial state ที่ความต้องการทรัพยากรในการใช้งานน้อยกว่า ด้วยเหตุนี้ เรามักมุ่งเน้นที่การเตรียม initial state ที่ซับซ้อนน้อยกว่า ตัวเลือกที่พบบ่อยและปฏิบัติได้คือ product state ที่ Qubit ไม่ entangle กัน สามารถเตรียมได้โดยใช้เฉพาะ single-qubit operation ลดความต้องการทรัพยากรของการเตรียม state และความซับซ้อนอย่างมีนัยสำคัญ 4. การวิวัฒนาการตามเวลาของสถานะ

ตอนนี้ initial state ถูกตั้งค่าแล้ว เราสามารถเริ่มการจำลองได้ในที่สุด ตรวจสอบว่าสถานะ $|\phi(t=0)\rangle$ ของระบบเปลี่ยนเป็น $|\phi(t)\rangle$ หลังจากเวลา $t$ ในกลศาสตร์ควอนตัม การวิวัฒนาการนี้อธิบายโดยการดำเนินการทางคณิตศาสตร์เดียวที่เรียกว่า time-evolution operator:

$$U(t) = e^{-iHt}$$

โดยที่เรากำหนด $\hbar=1$ ตามข้อตกลง การใช้ operator นี้กับ initial state ให้ final state: $|\phi(t)\rangle = e^{-iHt}|\phi(t=0)\rangle$

อย่างไรก็ตาม การสร้าง quantum circuit ที่ใช้ full operator $e^{-iHt}$ โดยตรงเป็นไปไม่ได้ปกติเมื่อ Hamiltonian ของเราเป็นผลรวมของส่วนต่าง ๆ ดังนั้น เราต้องการ Trotterization

ในคำพูดง่าย ๆ Trotterization เป็นเทคนิคสำหรับการประมาณ exponentiation ของ matrix (ที่นี่คือ Hamiltonian $H$) โดยเฉพาะเมื่อ exponent มี non-commuting operator ($[H_A, H_B] \neq 0$) มักที่ Hamiltonian $H$ ประกอบด้วย operator หลายตัวที่ไม่ commute ในกรณีนี้ คุณไม่สามารถแยก exponent ของพวกมันได้:

$$e^{-i(H_A + H_B)t} \neq e^{-iH_A t}e^{-iH_B t}$$

วิธีการที่มีประโยชน์คือการสลับนำ time-evolution exponent ของพวกมันมาใช้ในช่วงเวลาสั้น ๆ $t/n$ รวม $n$ ครั้ง ในกรณีของสองส่วนที่ไม่ commute เหล่านี้ เราจะเขียน

$$e^{−i H t}\approx \left(e^{−i H_A t/n}e^{−i H_B t/n}\right)^n$$

ข้อผิดพลาดที่เกิดจากการประมาณนี้เรียกว่า Trotter error เราสามารถลดข้อผิดพลาดนี้ได้โดยการเพิ่ม $n$ แต่สิ่งนี้มีค่าใช้จ่าย สูตรที่ก้าวหน้ามากขึ้น (สูตรอันดับสองและตัวแปรอื่น ๆ) ก็มีอยู่เช่นกัน ตัวอย่างเช่น สูตรอันดับสองให้ความแม่นยำที่ดีขึ้นโดยการใช้ขั้นตอนในรูปแบบสมมาตร

$$\begin{aligned} \text{อันดับแรก:} & \qquad e^{-iHt}\approx \left(\prod_j{e^{-iH_i t/n}}\right)^n\\ \text{อันดับสอง:} & \qquad e^{-iHt}\approx \left(\prod_{j=1}^N{e^{-iH_j t/2n}}\right)^n\left(\prod_{k=N}^1{e^{-iH_k t/2n}}\right)^n \end{aligned}$$

ที่นี่ $N$ คือจำนวน term ที่ไม่ commute $H_j$ ใน Hamiltonian ที่จะแบ่งในลักษณะนี้ และ $n$ คือจำนวน time step ขนาดเล็กที่การวิวัฒนาการนี้ถูกแบ่ง สังเกตลำดับย้อนกลับของ operator ใน product ที่สองในการจัดการอันดับสอง

ดูส่วน Trotterization ในคอร์ส Quantum Diagonalization Algorithms สำหรับรายละเอียดเพิ่มเติม 5. การปรับ Circuit ให้เหมาะสม

หลังจากสร้าง Trotterized circuit แล้ว ขั้นตอนการ mapping เสร็จสมบูรณ์และเราสามารถดำเนินการปรับ circuit ให้เหมาะสมได้ กระบวนการนี้เกี่ยวข้องกับงานหลักหลายอย่าง:

• กำหนด qubit layout ที่ map abstract Qubit ของ circuit สู่ physical Qubit บนฮาร์ดแวร์ ขั้นตอนนี้จำเป็นเพราะสถาปัตยกรรมของฮาร์ดแวร์มักมีข้อจำกัดการเชื่อมต่อเฉพาะ ในขณะที่การออกแบบ quantum circuit โดยทั่วไปสันนิษฐานว่า Qubit ใดก็ได้สามารถมีปฏิกิริยากับ Qubit อื่นใด
• แทรก swap gate ตามที่จำเป็นเพื่อให้สามารถมีปฏิกิริยาระหว่าง Qubit ที่ไม่ได้เชื่อมต่อโดยตรงบนอุปกรณ์
• แปล Gate ของ circuit เป็น Instruction Set Architecture (ISA) instruction ที่ฮาร์ดแวร์สามารถรันได้โดยตรง
• ทำการปรับ circuit ให้เหมาะสม เพื่อลดความลึกของ circuit และจำนวน Gate การปรับให้เหมาะสมนี้ยังสามารถใช้ก่อนหน้า บน virtual circuit ก่อนที่ Qubit จะถูกกำหนดให้กับการเชื่อมต่อฮาร์ดแวร์เฉพาะ

สำคัญที่จะสังเกตว่ากระบวนการปรับให้เหมาะสมนี้จำนวนมากถูกจัดการโดยอัตโนมัติโดยเครื่องมือใน Qiskit เราจะสำรวจวิธีที่ใช้งานได้จริงในภายหลังในบทเรียนนี้

6. การรัน Circuit

หลังจากทำขั้นตอนการปรับให้เหมาะสมเสร็จสิ้นแล้ว เราพร้อมที่จะรัน circuit โดยใช้ primitive เรากำลังพิจารณาการทดลองการจำลองที่เป้าหมายคือการเข้าใจวิธีที่คุณสมบัติบางอย่างของระบบเปลี่ยนแปลงตามเวลา สำหรับจุดประสงค์นี้ Estimator primitive เป็นตัวเลือกที่เหมาะสมที่สุด เนื่องจากช่วยให้คุณวัดค่าความคาดหวังของ observable ที่สอดคล้องกับคุณสมบัติเหล่านี้ได้

ต่อไป เราใช้ตัวเลือกรวมถึงเทคนิคการระงับและลดข้อผิดพลาด เพื่อปรับปรุงความแม่นยำของ Estimator สุดท้าย เราเรียกใช้การทดลองเพื่อเก็บผลลัพธ์

7. การ Post-process

ขั้นตอนสุดท้ายคือการ post-process ข้อมูลที่เก็บรวบรวม ซึ่งเกี่ยวข้องกับการดึงค่าความคาดหวังที่วัด หรือถ้าใช้ Sampler primitive การกระจายความน่าจะเป็นที่สุ่มใน computational basis เมื่อต้องการเฉพาะค่าความคาดหวังของ observable ที่เกี่ยวข้อง สามารถได้รับโดยตรงจาก Estimator primitive ทั้งเป็น raw result และพร้อม error mitigation บ่อยครั้ง ค่าความคาดหวังที่วัดเหล่านี้ทำหน้าที่เป็นจุดเริ่มต้นสำหรับการคำนวณเพิ่มเติมที่เกี่ยวข้องกับปริมาณที่สนใจอื่น ๆ การคำนวณเพิ่มเติมดังกล่าวโดยทั่วไปไม่ต้องการการประมวลผลควอนตัมและสามารถทำได้อย่างมีประสิทธิภาพบนคอมพิวเตอร์คลาสสิก

การทำซ้ำเอกสาร "Utility"

หมายเหตุ

ส่วนนี้เป็น high-level walk-through ของ tutorial Utility-scale error mitigation with probabilistic error amplification ที่ทำซ้ำผลลัพธ์ของเอกสาร Evidence for the Utility of Quantum Computing Before Fault Tolerance เราแนะนำอย่างยิ่งให้เปิด tutorial ที่อ้างถึงพร้อมกับ session นี้

ตอนนี้เราจะตรวจสอบตัวอย่างที่เป็นรูปธรรมจากเอกสารที่มีอิทธิพลสูงที่ IBM ตีพิมพ์ในปี 2023 ชื่อ Evidence for the Utility of Quantum Computing Before Fault Tolerance มักเรียกว่า "Utility paper"

เมื่อเผยแพร่ งานนี้กลายเป็นการศึกษาสำคัญในชุมชนการประมวลผลควอนตัมอย่างรวดเร็ว วิทยานิพนธ์กลางของมันคือคอมพิวเตอร์ควอนตัมที่มีสัญญาณรบกวน ซึ่งใช้ 127 Qubit และ 2,880 Gate สามารถสร้างค่าความคาดหวังที่แม่นยำสำหรับ quantum circuit ที่อยู่เกินการเข้าถึงของวิธีการจำลองคลาสสิก brute-force ซึ่งพยายามจำลองที่แน่นอนของ circuit เดียวกัน

การศึกษานี้มีความสำคัญเป็นพิเศษเพราะแสดงให้เห็นว่าคอมพิวเตอร์ควอนตัมสามารถใช้ตรวจสอบหรือเปรียบเทียบผลลัพธ์กับวิธีการจำลองคลาสสิกโดยประมาณ เช่น tensor network algorithm โดยเฉพาะในสถานการณ์ที่โซลูชันที่แน่นอนไม่เป็นที่รู้จักก่อนหน้านี้

ด้านที่น่าทึ่งอีกอย่างของงานนี้คือมันถูกทำซ้ำอย่างกว้างขวาง: นักวิจัยและผู้ใช้ตอนนี้มีความสามารถในการทำซ้ำและตรวจสอบการทดลองโดยใช้ระบบควอนตัม IBM ที่เข้าถึงได้จากคลาวด์และ Qiskit software framework ในส่วนต่อไป เราจะแนะนำคุณผ่านขั้นตอนในการทำการทำซ้ำนี้ด้วยตัวเองโดยทบทวน IBM's tutorial ทีละขั้นตอน

ในบทเรียนนี้ เราพูดถึงขั้นตอนเฉพาะที่จำเป็นในการแปลปัญหาเป็น input ที่อุปกรณ์ควอนตัมสามารถประมวลผลได้ เรามุ่งเน้นที่การจำลองพลวัตของ total magnetization ในระบบของ magnetic dipole spin ที่จัดเรียงบนแลตทิซ ภายใต้สนามแม่เหล็กภายนอก ระบบนี้สามารถอธิบายได้โดย Ising model ที่มีสนามแม่เหล็กขวาง เราแสดงมันโดยใช้ parametrized quantum circuit โดยที่พารามิเตอร์สอดคล้องกับค่าที่ปรับได้ของ spin-spin ($ZZ$) interaction และความแข็งแกร่งของสนามแม่เหล็กภายนอก transverse ($B_x$ พารามิเตอร์โดยใช้ $X$)

เนื่องจาก series นี้มีชื่อว่า Quantum Computing in Practice เราจะครอบคลุมรายละเอียดเพิ่มเติมของเทคนิคการทดลองที่ใช้ปรับปรุงคุณภาพของผลลัพธ์ ขั้นตอนสำคัญหนึ่งเกี่ยวข้องกับการระบุและลบ Qubit "เสีย" ซึ่งมี gate fidelity ต่ำหรือ decoherence time สั้น ที่อาจส่งผลกระทบอย่างมีนัยสำคัญต่อผลลัพธ์ของการทดลอง Qubit ที่มีปัญหาดังกล่าวอาจเกิดจากการ calibration ที่ไม่ดีหรือการมีปฏิกิริยากับ two-level systems (TLS) การลบ Qubit เหล่านี้เปลี่ยนแปลง topology ดั้งเดิมของฮาร์ดแวร์ ซึ่งเปลี่ยนแลตทิซที่ระบบถูกจำลองบนนั้น

นอกจากนี้ เราจะพูดถึงวิธีสร้าง parametrized quantum circuit ที่ใช้การวิวัฒนาการตามเวลาของระบบโดยใช้ Trotterization ส่วนสำคัญของกระบวนการนี้คือการระบุ entangling layer ภายใน circuit ซึ่งมีบทบาทสำคัญในเทคนิคการลดข้อผิดพลาดหลัก

Qiskit patterns ขั้นตอนที่ 1: Map

Tutorial บรรลุขั้นตอน mapping ในลักษณะคล้ายกับวิธีการทั่วไปที่อธิบายข้างต้น สำหรับปัญหานี้โดยเฉพาะ tutorial ทำสิ่งต่อไปนี้:

• สร้าง parameterized Ising model circuit
• สร้าง entangling layer และลบ Qubit ที่ไม่ดี
• สร้างเวอร์ชัน Trotterized ของ circuit

ใน tutorial เราเริ่มต้นด้วยการสร้างชุดของ helper function ในช่วงต้นของ notebook ฟังก์ชันเหล่านี้ออกแบบมาเพื่อทำให้กระบวนการง่ายขึ้นเมื่อเราดำเนินต่อ สิ่งเหล่านี้ไม่ใช่ส่วนที่จำเป็นของขั้นตอน แต่นี่เป็นแนวปฏิบัติที่ดีทั่วไปเมื่อทำการทดลองที่คล้ายกัน: แบ่งปัญหาเป็นส่วนประกอบที่จัดการได้ ฟังก์ชันรวมถึง

• ลบ qubit coupling
• กำหนด qubit coupling
• สร้าง layer coupling
• สร้าง entangling layer
• กำหนด Trotterized circuit

มาสำรวจหัวข้อที่เกี่ยวข้องกับฟังก์ชันเหล่านี้เพิ่มเติม Layer coupling

Layer coupling กำหนดวิธีที่ Qubit มีปฏิกิริยากับ Qubit ที่อยู่ติดกันระหว่างการจำลอง อุปกรณ์ควอนตัมของเราใช้ heavy-hexagonal layout ซึ่งเป็นรูปแบบที่โดดเด่นสำหรับการเชื่อมต่อ Qubit ภายใน layout นี้ การเชื่อมต่อระหว่าง Qubit ที่รู้จักกันในชื่อ "edge" สามารถแบ่งออกเป็นสามชุดที่แตกต่างกัน สำคัญที่สองการเชื่อมต่อในชุดเดียวกันไม่แบ่ง Qubit สิ่งนี้แก้ข้อจำกัดฮาร์ดแวร์สำคัญ: บนคอมพิวเตอร์ควอนตัมจริง Qubit สามารถมีส่วนร่วมในเพียงหนึ่ง two-qubit Gate ในเวลาใด ๆ

โดยการจัด structure การเชื่อมต่อทั้งหมดเป็นสาม layer แยก สามารถใช้ two-qubit Gate กับอุปกรณ์ทั้งหมดในสามรอบต่อเนื่องกัน วิธีนี้รับประกันว่าไม่มี Qubit ใดที่เกี่ยวข้องกับ Gate มากกว่าหนึ่งตัวต่อ layer Gate เหล่านี้ใช้ ZZ interaction ใน Ising model และพวกมันถูกทำซ้ำในแต่ละ time step ของการจำลอง (แต่ละ Trotter step)

นอกจากนี้ เทคนิคที่เรียกว่า twirling ถูกใช้เพื่อปรับเปลี่ยนลักษณะสัญญาณรบกวนในอุปกรณ์ Twirling แปลงสัญญาณรบกวนเพื่อให้แม้แต่ noise model ง่าย ๆ กลายเป็นการแสดงที่แม่นยำกว่าของข้อผิดพลาดทางกายภาพ การปรับปรุงนี้ช่วยให้สามารถ characterize สัญญาณรบกวนได้แม่นยำกว่า ซึ่งสามารถนำมาใช้เพื่อปรับปรุงกลยุทธ์การลดข้อผิดพลาด การลบ Qubit "เสีย"

ขั้นตอนต่อมาเกี่ยวข้องกับการลบ Qubit "เสีย" ออกจากรายชื่อ physical Qubit ที่มีให้สำหรับการทดลอง Qubit สามารถกลายเป็น "เสีย" ได้ด้วยเหตุผลหลายประการ บางครั้งเป็นเรื่องของการ calibration ที่ไม่ดีซึ่งสามารถแก้ไขได้โดยการ recalibrate ในบางกรณี ปัญหาซับซ้อนกว่าและเกี่ยวข้องกับสิ่งที่รู้จักกันในชื่อ two-level system (TLS) defect TLS defect เหล่านี้ทำให้เกิดความผันผวนในพารามิเตอร์ Qubit และ relaxation การแก้ไขสิ่งนี้มักต้องใช้ความร้อนทั้งระบบและจากนั้นทำให้เย็นลงอีกครั้ง ซึ่งเป็นกระบวนการที่ใช้เวลาและไม่สามารถทำได้เมื่อเข้าถึงฮาร์ดแวร์ควอนตัมจากระยะไกลผ่านคลาวด์

สำหรับตอนนี้ วิธีที่ง่ายที่สุดคือการยกเว้น Qubit ที่มีปัญหาเหล่านี้จากกลุ่มของ physical Qubit ที่จะใช้ในการทดลอง IBM Quantum Platform® ทำให้ง่ายในการระบุ Qubit ที่มีประสิทธิภาพต่ำบน QPU คุณสามารถเปิด QPU และแสดงภาพลักษณะโดยตรงบนแพลตฟอร์มหรือดาวน์โหลดข้อมูลจากแพลตฟอร์มเป็นไฟล์ CSV จากนั้นสร้างรายชื่อ Qubit ที่จะยกเว้นและลบออกจากชุดรวมของ physical Qubit บนอุปกรณ์

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

ถึงเวลาแล้วที่จะสร้าง Trotterized circuit ของเรา ดังที่พูดถึงก่อนหน้า Trotterization แบ่งการวิวัฒนาการตามเวลาเป็น discrete step ดังนั้นเราต้องเลือกว่าจะใช้กี่ step สำหรับตัวอย่างนี้ เราจะเลือก 6 step โดยทั่วไป วิธีการเกี่ยวข้องกับการสมดุล Trotter error ซึ่งเป็นข้อผิดพลาดการประมาณที่นำโดยอัลกอริทึม กับข้อผิดพลาดที่เกิดจาก decoherence การเพิ่มจำนวน Trotter step ลดข้อผิดพลาดการประมาณ แต่ต้องการ quantum circuit ที่ลึกกว่า ซึ่งอ่อนแอต่อ decoherence noise มากกว่า

Circuit จะถูกกำหนดโดยใช้พารามิเตอร์หลายตัว: พารามิเตอร์ theta ที่แสดงความแข็งแกร่งของสนามแม่เหล็กภายนอก coupling ระหว่าง layer จำนวน step จำนวน Qubit และแน่นอน ตัวเลือกของ backend อุปกรณ์ เนื่องจาก magnetization ของระบบขึ้นอยู่กับความแข็งแกร่งของสนามแม่เหล็กภายนอก จึงมีประโยชน์ในการรันการจำลองที่ค่าสนามแม่เหล็กต่าง ๆ การเปลี่ยนแปลงนี้สอดคล้องกับมุมหมุนต่าง ๆ สำหรับ RX Gate ใน circuit

from qiskit.circuit import Parameter

num_steps = 6           #Trotter steps
theta = Parameter("theta")
circuit = trotter_circuit(
        theta, layer_couplings, num_steps, qubits = good_qubits, backend = backend
)
num_params = 12

# 12 parameter values for Rx between [0,p/2].
#Reshape to outer product broadcast with observables

parameter_values = np.linespace(0,np.pi/2,num_params).reshape((num_params,1))
num_params = parameter_values.size

Qiskit patterns ขั้นตอนที่ 2: Optimize

ตอนนี้ที่เราสร้าง circuit แล้ว ขั้นตอนต่อมา คือการปรับให้เหมาะสม ส่วนแรกของกระบวนการนี้เกี่ยวข้องกับการกำหนด pass manager ในบริบทของ Qiskit SDK transpilation คือกระบวนการของการแปลง input circuit เป็นรูปแบบที่เหมาะสมสำหรับการรันบนอุปกรณ์ควอนตัม การแปลงนี้เกิดขึ้นผ่านลำดับของขั้นตอนที่รู้จักกันในชื่อ transpiler pass Pass manager คือ object ที่เก็บรายชื่อของ transpiler pass เหล่านี้และสามารถนำไปใช้กับ circuit ได้ ในการสร้างหนึ่ง คุณ initialize PassManager ด้วยรายชื่อของ transpiler pass ที่ต้องการ ท้ายที่สุด pass manager สร้าง ISA circuit ซึ่งเป็น circuit ที่แสดงในแง่ของ Instruction Set Architecture (ISA) ของ backend นี่หมายความว่า circuit แสดงด้วย Gate ที่เป็น native ของ backend hardware แม้ว่าจะยังไม่รวมข้อมูล timing ที่จำเป็นในการรัน circuit บนอุปกรณ์

Qiskit patterns ขั้นตอนที่ 3: Execute โดยใช้ primitive

ตอนนี้ถึงเวลารัน circuit ของเราแล้ว เราจะใช้ Estimator เป็นเครื่องมือหลักสำหรับการทดลองนี้เพราะเป้าหมายของเราคือการวัด total magnetization ของระบบ Estimator ออกแบบมาเฉพาะเพื่อประมาณค่าความคาดหวังของ observable ทำให้เป็นตัวเลือกที่เหมาะสมที่สุดที่นี่ ในขั้นตอนนี้ สำคัญที่จะกำหนดค่าการตั้งค่าการลดข้อผิดพลาดของเรา เราจะใช้ Zero Noise Extrapolation (ZNE) เพื่อปรับปรุงความแม่นยำของผลลัพธ์ ใน tutorial คุณจะเห็นว่าเราระบุค่า noise factor สองตัวขึ้นไปที่จะประเมิน extrapolated model และเราเลือก "Probabilistic Error Amplification" (PEA) เป็นวิธีการขยาย PEA เป็นที่ต้องการสำหรับการทดลองนี้เพราะมันปรับขนาดได้ดีกว่าตัวเลือกอื่น ๆ อย่างมีนัยสำคัญ ซึ่งสำคัญมากเมื่อทำงานกับระบบที่มี Qubit 100 ตัวขึ้นไป

นั่นคือทั้งหมดที่จำเป็นในการรันการทดลอง

ช่วงพักเรื่อง Error mitigation

ก่อนที่เราจะดำเนินการ post-processing มาใช้เวลาสั้น ๆ เพื่อชี้แจงความหมายของ Zero Noise Extrapolation (ZNE) เราได้กล่าวถึงแนวคิดนี้ในตอนก่อนหน้า แต่คุ้มค่าที่จะทบทวนสั้น ๆ ZNE เป็นเทคนิคการลดข้อผิดพลาดที่ออกแบบมาเพื่อลดผลกระทบของสัญญาณรบกวนที่ไม่รู้จักที่เกิดขึ้นระหว่างการรัน quantum circuit ขอให้ระบุว่าสัญญาณรบกวนนี้สามารถปรับขนาดได้ในลักษณะที่ควบคุมได้ วิธีการนี้อาศัยสมมติฐานว่าค่าความคาดหวังปรับขนาดตามสัญญาณรบกวนตามฟังก์ชันที่รู้จัก:

$$\langle A(\lambda)\rangle = \langle A(0)\rangle + \sum_{k=0}^m {a_k \lambda^k}+R,$$

โดยที่ $λ$ แสดงถึงความแข็งแกร่งของสัญญาณรบกวน ซึ่งสามารถขยายได้โดยตั้งใจ

กระบวนการของการใช้ ZNE ประกอบด้วยขั้นตอนต่อไปนี้:

1. ขยายสัญญาณรบกวนของ circuit สำหรับ noise factor ต่าง ๆ $λ_1$, $λ_2$, …
2. รัน circuit ที่ขยายสัญญาณรบกวนแต่ละตัวเพื่อวัดค่าความคาดหวังที่สอดคล้อง $\langle A(\lambda_1)\rangle$, $\langle A(\lambda_2)\rangle$, ….
3. Extrapolate ผลลัพธ์เหล่านี้กลับสู่ zero-noise limit \langle $A(\lambda_0)\rangle$

เทคนิคนี้ช่วยให้เราประมาณว่าผลลัพธ์จะเป็นอย่างไรหากไม่มีสัญญาณรบกวน ปรับปรุงความแม่นยำของการประมวลผลควอนตัม

ความท้าทายหลักในการใช้ ZNE อย่างมีประสิทธิผลคือการพัฒนา noise model ที่แม่นยำสำหรับค่าความคาดหวังและการขยายสัญญาณรบกวนในลักษณะที่ควบคุมได้และเข้าใจได้ดี เทคนิคทั่วไปสำหรับการขยายข้อผิดพลาดใน ZNE รวมถึงการปรับขนาด pulse duration ผ่านการ calibration การทำซ้ำ Gate โดยใช้ identity cycle และการเพิ่มสัญญาณรบกวนผ่านการสุ่ม Pauli channel ซึ่งเป็นวิธีที่เรียกว่า Probabilistic Error Amplification (PEA)

ในบรรดาวิธีเหล่านี้ PEA มักเป็นตัวเลือกที่ต้องการด้วยเหตุผลหลายประการ:

• Pulse stretching มีค่าใช้จ่ายในการคำนวณสูง
• Gate folding ซึ่งใช้ identity insertion ขาดการรับประกันทางทฤษฎีที่แข็งแกร่งสำหรับการรักษา noise bias
• PEA ใช้ได้กับ circuit ใดก็ตามที่รันด้วย native noise factor แม้ว่าจะต้องเรียนรู้ noise model ล่วงหน้า

PEA ทำงานภายใต้สมมติฐานของ layer-based noise model คล้ายกับที่ใช้ใน probabilistic error cancellation (PEC) อย่างไรก็ตาม ต่างจาก PEC มันหลีกเลี่ยง exponential sampling overhead ที่ปกติเพิ่มขึ้นตามสัญญาณรบกวนของ circuit ประสิทธิภาพนี้ทำให้ PEA เป็นวิธีการที่ปฏิบัติได้และแข็งแกร่งสำหรับการขยายสัญญาณรบกวนใน ZNE ช่วยให้การลดข้อผิดพลาดควอนตัมน่าเชื่อถือมากขึ้น เพื่อ characterize noise model เราต้องระบุ layer ที่แตกต่างกันของการดำเนินการ two-qubit ภายใน circuit ก่อน สำหรับแต่ละ layer เหล่านี้ เราใช้ขั้นตอน Pauli twirling กับ two-qubit Gate ซึ่งช่วยรับประกันว่าสัญญาณรบกวนสามารถอธิบายได้อย่างแม่นยำโดย damping noise model ต่อไป เราทำซ้ำคู่ของ identity layer ที่ความลึกต่าง ๆ และสุดท้าย เราปรับค่า fidelity เพื่อกำหนด error rate สำหรับแต่ละ noise channel

แม้ว่าจะเป็นประโยชน์ที่จะเข้าใจวิธีการนี้ในเชิงแนวคิด การใช้งานด้วยตนเองใน Qiskit นั้นง่ายกว่ามาก ดังที่แสดงใน tutorial ที่มาพร้อมกัน

Qiskit patterns ขั้นตอนที่ 4: Post-process

หลังจากการทดลองเสร็จสิ้น คุณสามารถดูผลลัพธ์ได้โดยการpost-process เส้นประสีเทาในข้อมูลที่พล็อตแสดงผลลัพธ์ที่ได้โดยใช้วิธีการคลาสสิกโดยประมาณ โดยที่ข้อผิดพลาดการประมาณลดลงสู่เกณฑ์ต่ำ จุดข้อมูล raw สำหรับ noise factor ต่าง ๆ ที่เลือกตั้งแต่แรก เห็นได้ชัดว่า offset จากเส้นประนี้ ในทางตรงข้าม เส้นสีน้ำเงินแสดงข้อมูลหลังจากใช้ ZNE processing ของเรา ซึ่งทำให้ผลลัพธ์ใกล้เคียงกับค่าที่แน่นอนอย่างเห็นได้ชัด โดยสรุป ค่าที่ได้ภายใต้สภาวะสัญญาณรบกวนปกติ (noise factor nf=1.0) แสดงการเบี่ยงเบนอย่างมีนัยสำคัญจากผลลัพธ์ที่แน่นอน ในขณะเดียวกัน ค่าที่บรรเทาแล้วสอดคล้องอย่างใกล้ชิดกับค่าที่แน่นอน แสดงให้เห็นประสิทธิผลของเทคนิคการลดข้อผิดพลาดด้วย PEA

สรุป

เพื่อสรุปสั้น ๆ สิ่งที่เราได้เรียนรู้:

• Quantum simulation เป็นหนึ่งในพื้นที่การประยุกต์ใช้ที่มีแนวโน้มมากที่สุดในระยะสั้นถึงกลาง
• มีการประยุกต์ใช้ที่หลากหลาย ตั้งแต่ pharmaceuticals ไปถึงฟิสิกส์พลังงานสูง วิทยาศาสตร์วัสดุ และอื่น ๆ
• Utility paper จาก IBM ที่ตีพิมพ์ในปี 2023 ชี้ทางไปสู่ความสามารถในการใช้คอมพิวเตอร์ควอนตัมสำหรับการค้นพบทางวิทยาศาสตร์ และเราผ่าน tutorial ที่เกี่ยวข้องกับเอกสารนั้น
• ขั้นตอนในการทำงานผ่านปัญหาการจำลองตั้งแต่ต้นจนจบค่อนข้างตรงไปตรงมา และเราหวังว่าคุณสามารถใช้วิดีโอและ tutorial นี้เป็นแนวทางสำหรับปัญหาการจำลองเพิ่มเติม

แบบสำรวจหลังเรียน

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

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.