การ Mapping

ดูวิดีโอเกี่ยวกับการ mapping จาก Olivia Lanes หรือเปิดวิดีโอในหน้าต่างแยกบน YouTube.

บทนำ

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

ในบทเรียนที่ 2 และ 3 ของคอร์สนี้ เราได้กล่าวว่าขั้นตอนการ mapping เป็นขั้นตอนแรกจากสี่ขั้นตอนในกรอบงาน Qiskit patterns จากบทเรียนเหล่านั้น คุณอาจจำได้ว่าเป้าหมายของการ mapping คือการแปลหรือเขียนใหม่ปัญหาการประมวลผลเป็น cost function หรือค่าความคาดหวังที่เราสามารถประเมินได้โดยใช้คอมพิวเตอร์ควอนตัม

ในบทเรียนที่ 3 เราพูดถึงตัวอย่างที่เป็นรูปธรรมหนึ่งด้วย Max-Cut ซึ่งเป็นปัญหาที่ยากในการคำนวณ แต่พบบ่อยมากใน combinatorial optimization ในตัวอย่างนั้น เราผ่านหลายขั้นตอนเพื่อแปลปัญหากราฟเริ่มต้นให้เป็นสิ่งที่สามารถแก้ได้บนคอมพิวเตอร์ควอนตัม เราแปลงปัญหาของการหาจำนวนการตัดสูงสุดในกราฟเป็น cost function เขียน cost function ใหม่เป็น Hamiltonian และเตรียม trial quantum state ที่ ground state ของมันสอดคล้องกับการตัดสูงสุด สุดท้าย เราสร้าง quantum circuit ที่แสดงถึง trial quantum state ที่สนใจ แล้วเพิ่ม Gate เฉพาะเพื่อให้สถานะวิวัฒนาการตามเวลา ลำดับขั้นตอนทั้งหมดนี้เป็นส่วนหนึ่งของการ mapping แม้ว่าขั้นตอนที่แน่นอนจะไม่ซ้ำกันสำหรับปัญหา Max-Cut แต่ขั้นตอนทั่วไปเดียวกันสามารถนำไปใช้กับการประยุกต์ใช้อื่น ๆ มากมาย เช่น quantum chemistry และ quantum simulation

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

ข้อพิจารณาทั่วไป

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

ประการแรก คุณอาจต้องลดความซับซ้อนของปัญหาเพื่อให้เป็นไปได้ สิ่งนี้ไม่ได้เฉพาะเจาะจงสำหรับควอนตัม ทุกสาขาวิชาวิทยาศาสตร์ใช้แบบจำลองที่เรียบง่ายขึ้นเพื่อศึกษาปรากฏการณ์ที่สนใจ ในขณะที่ละเว้นรายละเอียดที่ไม่เกี่ยวข้อง ในฟิสิกส์ มีสำนวนที่มีชื่อเสียงที่นำหลักการนี้ไปสู่สุดโต่ง: "สมมติว่าเป็นวัวทรงกลม" มักยากเกินไปที่จะอธิบายระบบตรงตามที่ปรากฏ แต่เราสามารถทำการลดความซับซ้อนที่สมเหตุสมผลที่ยังนำไปสู่โซลูชันที่เป็นประโยชน์ได้ ตัวอย่างบางส่วนว่าเราอาจทำสิ่งนี้ในการประมวลผลควอนตัมอย่างไร ได้แก่ การจำกัดขนาดหรือความลึกของ Circuit โดยการเลือก hardware-efficient ansatz การตัดทอนการวิวัฒนาการเวลาที่ซับซ้อน หรือการละเว้น term ของ Hamiltonian ที่มีส่วนน้อยต่อพลังงานสุดท้ายของ quantum state

ประการที่สอง การ mapping เกี่ยวข้องกับการเขียนปัญหาในลักษณะที่คอมพิวเตอร์ควอนตัมสามารถเข้าใจได้ มักเกี่ยวข้องกับการถามสามคำถามนี้:

1. Qubit ของเราจะแสดงถึงอะไรในแบบจำลองของเรา?
2. ปัญหาของเราต่อเนื่องหรือไม่? เนื่องจากคอมพิวเตอร์ควอนตัมเป็นดิจิทัล ถ้าปัญหาต่อเนื่อง เราจำเป็นต้องหาวิธี discretize มัน
3. สุดท้าย topology ของปัญหาสอดคล้องกับ topology ของฮาร์ดแวร์หรือไม่? ถ้าไม่ เราอาจต้องใช้เทคนิคบางอย่างเพื่อให้มันทำงานได้

มาตอบคำถามแรกซึ่งอยู่ที่แกนกลางของความยากในการทำความเข้าใจการ mapping: Qubit สามารถแสดงถึงอะไรได้บ้าง?

Qubit สามารถใช้แสดงสิ่งต่าง ๆ มากมาย อย่างแรกและบางทีง่ายที่สุดคือ node บนกราฟ กราฟถูกใช้เพื่อแสดงการเชื่อมต่อในปัญหาทางคณิตศาสตร์ประเภทต่าง ๆ และ node เป็นองค์ประกอบพื้นฐานที่แสดงถึงจุดหรือองค์ประกอบภายในเครือข่าย ขึ้นอยู่กับสิ่งที่เครือข่ายทั้งหมดแสดงถึง อาจเป็นเมือง บุคคล หรือ ferromagnet ในแลตทิซ

Qubit ยังสามารถใช้แสดงถึง boson และ fermion แม้ว่าฉันจะเตือนว่า Qubit เดียวไม่ได้เท่ากับ boson หนึ่งตัวหรือ fermion หนึ่งตัวเลย มันซับซ้อนกว่านั้นเล็กน้อย ดังที่เราจะพูดถึงเพิ่มเติมในบทเรียน

ตอนนี้เรากำลังได้ตัวอย่างที่ซับซ้อนมากขึ้นเล็กน้อย สำหรับแบบจำลองเหล่านี้ ไม่มีความหมายอีกต่อไปที่จะพูดในแง่ของ Qubit เดี่ยว แทนที่เราต้องการกลุ่มของ Qubit เพื่อสร้างสิ่งที่มีความหมายทางกายภาพ ตัวอย่างเช่น กลุ่มของ Qubit ที่แสดงบน heavy hexagonal topology สามารถใช้แสดงตำแหน่งทางเรขาคณิตของกรดอะมิโน สายโพลิเมอร์ ตัวอย่างอื่นคือการจำลองการกระเจิงของแฮดรอนในแบบจำลองฟิสิกส์พลังงานสูง ซึ่งสามารถทำได้โดยการจำลองการวิวัฒนาการเวลาของ wave packet ของฮาดรอน ในกรณีนี้ register ของ Qubit สามารถใช้เข้ารหัสสถานะต่าง ๆ ของ quantum field; vacuum state ของ field นั้น หรือ wave packet ที่แพร่กระจายบน vacuum นั้น

แต่จนถึงจุดนี้เราพูดถึงความท้าทายในเชิงนามธรรมเพียงพอแล้ว มาดูตัวอย่างเหล่านี้อย่างละเอียดกัน

ตัวอย่างการ Mapping

Max-Cut

มาเริ่มด้วยตัวอย่างแรก หนึ่งในปัญหาการ mapping ที่ตรงไปตรงมาที่สุดคือสิ่งที่เราได้กล่าวถึงในเชิงลึกบ้างแล้ว: ตัวอย่าง Max-Cut ในปัญหานั้น การ mapping ค่อนข้างง่ายสำหรับเราเพราะ Qubit หนึ่งตัวเทียบเท่ากับ node หนึ่งตัวบนกราฟของเรา

ระลึกว่าเพื่อ map ปัญหา Max-Cut เราแสดง cost function เป็น Hamiltonian โดยใช้การกำหนดสูตร QUBO Hamiltonian cost function คือฟังก์ชันที่เข้ารหัสโซลูชันที่เหมาะสมที่สุดของปัญหาใน ground state ของ Hamiltonian เพื่อสร้าง cost Hamiltonian เราใช้คลาส SparsePauliOp ใน Qiskit เพื่อระบุการเชื่อมต่อของกราฟของเรา และขั้นตอนการ mapping สู่ quantum operator เสร็จสิ้น และ quantum circuit ก็เป็นแค่ QAOA ansatz สำหรับการทบทวน ดูที่บทเรียน Utility-scale QAOA ที่เราอธิบายทั้งหมดนี้ในรายละเอียดมากขึ้น

ในบทเรียนนั้น แม้ในตัวอย่าง utility-scale ที่มี 100 Qubit การเชื่อมต่อกราฟก็ตรงกับ topology ของฮาร์ดแวร์ superconducting ของเราแล้ว ดังนั้นเราไม่ต้องกังวลเกี่ยวกับวิธีจัดการกับ topology ต่าง ๆ แต่นั่นไม่ใช่กรณีเสมอไป หากเรามีกราฟที่ซับซ้อนหรือเชื่อมต่อหนาแน่นกว่าตัวอย่างที่เราเน้นไปจนถึงตอนนี้ เราจำเป็นต้องใช้ชุดของ SWAP Gate เพื่อปรับเปลี่ยนการเชื่อมต่อที่มีประสิทธิภาพของฮาร์ดแวร์ สิ่งนี้จัดการที่ขั้นตอนที่สองของ Qiskit patterns คือ transpilation แต่ควรคำนึงถึงแม้แต่ในขั้นตอนการ mapping

การพับโปรตีน

ต่อไป มาสำรวจตัวอย่างที่สร้างแบบจำลองในเอกสาร ที่ชื่อ "Resource-efficient quantum algorithm for protein folding" เขียนโดย IBM® และผู้ร่วมงานที่มหาวิทยาลัย New South Wales

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

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

ในโปรตีนจริง กรดอะมิโนสามารถครอบครองตำแหน่งต่อเนื่องได้มากมาย อย่างไรก็ตาม เราจะใช้การลดความซับซ้อนและจำกัดพวกมันโดยใช้แบบจำลองแลตทิซ โดยที่กรดอะมิโนแต่ละตัวครอบครองจุดบนกริด ที่นี่ผู้เขียนใช้แลตทิซเตตระฮีดรัล หมายเหตุด่วน: ที่นี่เราเข้ารหัสทิศทางของ edge ไม่ใช่ node เองเหมือนในปัญหา Max-Cut Qubit แต่ละตัวแสดงถึงเส้นทางเดินทางเดียวที่เป็นไปได้ตามกริดเตตระฮีดรัล สังเกตว่าตำแหน่งที่อยู่ติดกันถูกติดฉลากว่า A หรือ B เพราะทิศทางที่แตกต่างกันในแลตทิซ

สายโปรตีนถูกแสดงเป็นชุดของการเลี้ยวหรือทิศทางบนแลตทิซนี้ การเลี้ยวแต่ละครั้งระหว่างกรดอะมิโนสามารถอยู่ใน 4 ทิศทาง ที่สอดคล้องกับ edge ของ tetrahedron การเลี้ยวสี่ทิศทางที่เป็นไปได้เหล่านี้ถูกเข้ารหัสโดยใช้ Qubit สี่ตัวเป็นสถานะ 0001, 0010, 0100 หรือ 1000

มาดูตัวอย่างในรูปด้านบน มาวางกรดอะมิโนแรกบนจุดที่ติดฉลาก "B" ล้อมวงแดงในแลตทิซเตตระฮีดรัลของเรา ทิศทางไปยังกรดอะมิโนแรกถึงที่สองเป็นไปตามอำเภอใจเพราะระบบสามารถหมุนได้เสมอเพื่อให้ edge นั้นชี้ไปในทิศทางใดก็ได้ที่เราต้องการ ดังนั้น เราสามารถวางกรดอะมิโนที่สองบนจุดด้านล่างตัวแรกที่ติดฉลาก "A" ไม่ง่ายนักที่จะเห็น แต่เส้นทางจากที่สองถึงที่สามก็เป็นไปตามอำเภอใจเช่นกัน การเลือกทั้งสามจะส่งผลให้เรามีสอง edge ที่มีมุมประมาณ 109.5 องศาระหว่างกัน การเลือก edge ที่สองนี้เพียงกำหนดทิศทางของโปรตีนเราในพื้นที่ ดังนั้น โดยไม่สูญเสียความทั่วไป เราสามารถเลือกการเลี้ยวสองครั้งแรกเป็น 0001 และ 0010

ด้วยการลดความซับซ้อนเหล่านี้ การกำหนดค่าของสายกรดอะมิโนถูกกำหนดโดยนิพจน์นี้:

$$(0001)(0010)(q_9 q_{10} q_{11} q_{12}) \cdots (q_{4N-3} q_{4N-2} q_{4N-1} q_{4N})$$

จนถึงตอนนี้ เรา map edge ของ tetrahedron สู่ Qubit แล้ว และ quantum circuit ของเราจะเป็น ansatz ตอนนี้เราต้องพิจารณาวิธีเข้ารหัสพลังงานของปัญหาเป็น Hamiltonian เพื่อให้ ground state ของมันให้รูปแบบการพับที่เหมาะสมที่สุด

สำหรับการกำหนดค่าใด ๆ ที่กำหนด จะมีพลังงานที่สัมพันธ์กันเนื่องจากการมีปฏิกิริยาระหว่างกรดอะมิโน การมีปฏิกิริยาเหล่านี้แข็งแกร่งที่สุดเมื่อกรดอะมิโนสองตัวอยู่ใกล้กัน เห็นได้ชัดว่า กรดอะมิโนที่อยู่ติดกันใน backbone ของสายจะมีปฏิกิริยากันเสมอ แต่เนื่องจากโปรตีนสามารถบิดและพับได้ คู่กรดอะมิโนอื่น ๆ ก็สามารถมีปฏิกิริยาได้เช่นกัน กรดอะมิโนที่ 10 และ 20 อาจอยู่บนตำแหน่งที่ติดกันหลังจากโปรตีนพับแล้ว ดังนั้น เราต้องการสูตรเพื่ออธิบายระยะทาง $d$ ระหว่างกรดอะมิโน $i$ และ $j$ โดยใช้ข้อมูลที่เข้ารหัสบน configuration Qubit วิธีนี้ เราสามารถใช้ระยะทางแยกเพื่อกำหนดความแข็งแกร่งของปฏิกิริยา

ก่อนอื่น มานำเสนอฟังก์ชัน $f_a(i)$ ที่บ่งชี้ว่า edge $a$ ถูกใช้สำหรับการเลี้ยวที่กรดอะมิโน $i$ หรือไม่ ที่นี่ $a$ สามารถรับทิศทางที่เป็นไปได้สี่ทิศทาง จากการกำหนดค่าที่เราเริ่มต้นข้างต้น เราสามารถเขียนฟังก์ชันเหล่านี้:

$$\begin{aligned} f_0(i) &= q_{4i-3} \\ f_1(i) &= q_{4i-2} \\ f_2(i) &= q_{4i-1} \\ f_3(i) &= q_{4i} \end{aligned}$$

จากนั้นเราสามารถกำหนดความแตกต่างในจำนวนการเลี้ยวที่ติดฉลาก $a$ บนแลตทิซ A และ B จากดัชนี $i$ ถึง $j$ เป็น $\Delta n$:

$$\begin{aligned} \Delta n_a(i,j) &= \sum\limits_{k=i}^{j}{(-1)^k f_a(k)} \end{aligned}$$

ทำไมเราถึงทำสิ่งนี้? มันกลายเป็นว่าการเลี้ยวของ $a$ จากตำแหน่งแลตทิซ A ถึง B ถูกยกเลิกอย่างแม่นยำโดยการเลี้ยวของ $a$ จากตำแหน่งแลตทิซ B ถึง A ดังนั้น เพื่อรู้ระยะทางที่กรดอะมิโนบนตำแหน่ง $i$ อยู่จากกรดอะมิโนบนตำแหน่ง $j$ เราเพียงต้องหาความแตกต่างระหว่างขั้นตอนที่ทำตาม edge ของ $a$ จากตำแหน่ง A และตำแหน่ง B เนื่องจากตำแหน่ง A และ B สลับกันตาม backbone ของโปรตีน สิ่งนี้ถูกจับใน $(−1)^k$ อาร์กิวเมนต์เดียวกันนี้ใช้กับประเภท edge ทั้งสี่ ดังนั้น ระยะทางรวมระหว่างกรดอะมิโนในขั้นตอนแลตทิซเตตระฮีดรัลสามารถคำนวณได้โดยนิพจน์นี้:

$$\begin{aligned} d(i,j) &= \sum\limits_{a}{||\Delta n_a(i,j)||^2} \\ &= (\Delta n_0(i,j))^2 + (\Delta n_1(i,j))^2 + (\Delta n_2(i,j))^2 + (\Delta n_3(i,j))^2 \end{aligned}$$

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

$$\begin{aligned} d(i,j) &= 0 \rightarrow r_{ij} = 0 \\ d(i,j) &= 1 \rightarrow r_{ij} = 1 \\ d(i,j) &= 2 \rightarrow r_{ij} = 2\sqrt\frac{2}{3} \approx 1.63 \\ d(i,j) &= 3 \rightarrow r_{ij} = \sqrt\frac{11}{3} \approx 1.91 \\ d(i,j) &= 4 \rightarrow r_{ij} = \frac{4}{\sqrt{3}} \approx 2.31 \\ d(i,j) &= 5 \rightarrow r_{ij} = \sqrt\frac{19}{3} \approx 2.52 \end{aligned}$$

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

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

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

การแปลง Jordan-Wigner

ตอนนี้มาสำรวจวิธีแปลระบบอนุภาคใต้อะตอมเป็น Pauli operator

อนุภาคใต้อะตอมแบ่งออกเป็นสองประเภท ได้แก่ boson และ fermion Boson เช่น photon หรือ Higgs ปฏิบัติตามกฎสถิติชุดหนึ่ง Fermion เช่นอิเล็กตรอนหรือนิวทริโน ปฏิบัติตามกฎอีกชุดหนึ่ง ความแตกต่างสำคัญระหว่างพวกมันคือ boson ได้รับอนุญาตให้ครอบครองสถานะเดียวกัน ไม่มีขีดจำกัดว่ามี boson กี่ตัวที่อยู่ใน ground state หรือสถานะที่กระตุ้นใด ๆ Fermion ในทางกลับกันเป็นพวกเห็นแก่ตัว พวกมันต้องการให้อนุภาคทุกตัวมีสถานะควอนตัมของตัวเอง

Boson ยังมีสปินเป็นจำนวนเต็มในขณะที่ fermion มีสปินครึ่งจำนวนเต็ม เช่น อิเล็กตรอน spin-1/2 และอนุภาค spin-3/2 ที่แปลกกว่า เพื่ออธิบายระบบของอนุภาค เราต้องการคำอธิบายพลังงานของพวกมัน มาเน้นที่ fermion เราสามารถเริ่มด้วย Hamiltonian ที่เขียนในแง่ของสิ่งที่เราเรียกว่า c operator สิ่งเหล่านี้เป็นพื้นฐานออบเจ็กต์ทางคณิตศาสตร์ที่สอดคล้องกับการสร้างหรือทำลาย fermion จากสถานะในระบบ สิ่งเหล่านี้มักเขียนเป็น $f_i^\dagger$ และ $f_j$ โดยที่ $f_i^\dagger$ เป็น operator ที่สร้าง fermion ในสถานะ $i$ และ $f_j$ เป็น operator ที่ทำลาย fermion ในสถานะ $j$

แต่จำไว้ว่า คอมพิวเตอร์ควอนตัมปกติทำงานใน qubit basis ด้วยกฎเฉพาะสำหรับการแสดงระบบ fermionic พวกมันไม่ทำงานในภาษาของ fermionic operator โดยธรรมชาติ เพื่อเชื่อมช่องว่างนี้ เราต้อง map สัญกรณ์ fermionic นี้สู่ Pauli operator ซึ่งสอดคล้องตามธรรมชาติกับ quantum gate

มีการแปลงดังกล่าวหลายอย่างสำหรับ fermion ตัวเลือกทั่วไปคือการแปลง Jordan-Wigner การ mapping ของ Bravyi-Kitaev และ parity เป็นการเข้ารหัส fermionic ที่ล่าสุดกว่า Bosonic operator สามารถแปลงได้โดยใช้การแปลง Holstein-Primakoff หรือการ map Fock state สู่ sub-basis ของ bosonic mode ที่มีอยู่โดยตรง และตัวเลือกอื่น ๆ การเข้ารหัสอื่น ๆ ยังถูกวิจัยอยู่อย่างแข็งขัน สำหรับตอนนี้ เราจะมุ่งเน้นที่การแปลง Jordan-Wigner เท่านั้น

การแปลง Jordan-Wigner เกี่ยวข้องกับการ map fermion เดียวสู่ Qubit หลายตัว ทำไมเราถึงไม่กำหนด Qubit หนึ่งตัวเพื่อแสดงแต่ละอิเล็กตรอน? สิ่งนี้เกี่ยวข้องกับความสามารถในการแยกแยะของ fermion เดียวกัน Qubit สามารถแยกแยะได้และอิเล็กตรอนไม่สามารถ ตัวอย่างเช่น เราสามารถติดฉลากและระบุ Qubit แต่ละตัวบนอุปกรณ์ใดก็ได้ได้ง่าย แต่ความไม่สามารถแยกแยะของอิเล็กตรอนหมายความว่าเราไม่สามารถติดฉลากพวกมันได้เลย ดังนั้น เราต้องติดฉลาก operator ตาม orbital ที่ถูกครอบครอง เช่น 1s, 2p, 2p เป็นต้น แทนที่จะเป็นอิเล็กตรอนเฉพาะ ดังนั้น Qubit แต่ละตัวมีบทบาทประมาณบทบาทของ orbital ในโมเลกุลซึ่งถูกครอบครองหรือไม่ถูกครอบครอง แต่วิธีที่เราทำสิ่งนั้นซับซ้อนกว่าเล็กน้อย การ mapping ของ Jordan-Wigner ติดตาม anti-symmetry และรับประกันสถิติที่ถูกต้องของระบบ fermionic โดยรวม การ mapping ของ Jordan-Wigner แสดง fermionic operator ในแง่ของ Pauli operator โดยใช้ความสัมพันธ์เหล่านี้:

$$\begin{aligned} f_j^\dagger &= \Bigl( \prod\limits_{k \lt j}{(-Z_k)} \Bigr)\Bigl( \frac{X_j + i Y_j}{2} \Bigr) \\ f_j &= \Bigl( \prod\limits_{k \lt j}{(-Z_k)} \Bigr)\Bigl( \frac{X_j - i Y_j}{2} \Bigr) \end{aligned}$$

การ mapping ของ Jordan-Wigner เข้าใจได้ง่ายตามแนวคิดเนื่องจากการสอดคล้องแบบหนึ่งต่อหนึ่งระหว่าง orbital และ Qubit มีการ mapping อื่น ๆ ที่บรรลุเป้าหมายที่คล้ายกัน รวมถึง parity mapping การคำนวณ parity ของสถานะต้องการการพิจารณา Qubit หลายตัว ใน parity mapping (และบางตัวอื่น) การตีความที่ Qubit หนึ่งตัวสอดคล้องกับ orbital หนึ่งตัวไม่ใช้ ตอนนี้มาผ่านตัวอย่างง่าย ๆ สมมติว่าเราต้องการคำนวณปฏิกิริยา Qubit เดียว $f_0^\dagger f_0$ เราเริ่มด้วยการเสียบนิยามของเราสำหรับ creation และ annihilation operator

$$\begin{aligned} f_0^\dagger f_0 &= \biggl( \prod_{k < 0} (-Z_k)^2 \biggr) \biggl( \frac{X_0 + i Y_0}{2} \biggr) \biggl( \frac{X_0 - i Y_0}{2} \biggr) \\ &= \frac{1}{4} (X_0^2 + i Y_0 X_0 - X_0 Y_0 + Y_0^2) \\ &= \frac{1}{4} (2 I - i[X_0,Y_0]) \end{aligned}$$

commutator $[X_0, Y_0] = 2i Z_0$ ดังนั้น นิพจน์สุดท้ายกลายเป็น:

$$\begin{aligned} f_0^\dagger f_0 = \frac{1}{2}(I+Z_0) \end{aligned}$$

ดังนั้น เราได้เขียนนิพจน์ fermionic ใหม่เป็น Pauli operator ที่คอมพิวเตอร์ควอนตัมของเราสามารถเข้าใจได้สำเร็จแล้ว มาพูดถึงวิธีที่เราจะใช้ Jordan-Wigner mapping ใน Qiskit อย่างรวดเร็ว สำคัญที่จะเข้าใจว่าการแปลงประเภทนี้ทำงานอย่างไร แต่จะไม่ปฏิบัติได้ที่จะคำนวณด้วยตนเองทุกครั้ง โดยเฉพาะสำหรับระบบขนาดใหญ่ โชคดีที่ Qiskit ทำให้สิ่งนี้ง่ายสำหรับเราด้วยฟังก์ชัน SparsePauliOp

ในระดับสูง ขั้นตอนคือ:

1. ใช้ฟังก์ชัน from_list ของ SparsePauliOp เพื่อสร้าง identity operator ที่สอดคล้องกับขนาดของพื้นที่พารามิเตอร์ที่จะ map
2. ตามนิยามของ creation และ destruction operator ที่แสดงก่อนหน้า ใช้ฟังก์ชัน from_list ของ SparsePauliOp เพื่อกำหนด $X$, $Y$, $Z$ Pauli operator สิ่งนี้จะ map fermionic creation และ annihilation operator สู่ qubit spin operator เข้ารหัสตัวเลขการครอบครองของ fermionic เข้าไปใน computation basis ของ Qubit
3. สร้าง Hamiltonian ที่ต้องการใน Pauli basis โดยการนำ operator ข้างต้นไปใช้กับ orbital ที่สนใจ ปกติสอดคล้องกับการสร้าง identity matrix ที่แสดง core (non-interacting) orbital แล้วนำ creation และ annihilation operator ไปใช้กับ active space ด้วยน้ำหนักที่สอดคล้องกับสิ่งเฉพาะของปัญหา

ตอนนี้ที่เราเข้าใจ Jordan-Wigner mapping อย่างสมบูรณ์แล้ว มาดูตัวอย่างที่ซับซ้อนกว่า คุณอาจจำเอกสาร ที่ชื่อ "Scalable Circuits for Preparing Ground States on Digital Quantum Computers: The Schwinger Model Vacuum on 100 Qubits" จากบทเรียนก่อนหน้า เราจะไม่ผ่านเอกสารในรายละเอียดอีกครั้ง เราจะมุ่งเน้นเฉพาะที่ Jordan-Wigner mapping ซึ่งถูกใช้เพื่อแสดง Hamiltonian ของตำแหน่งแลตทิซที่มี $L$ ตำแหน่งสำหรับ Schwinger model ในกรณีที่ไม่มีสนามไฟฟ้า

ที่นี่ มันยากกว่ามากที่จะระบุว่า Qubit หนึ่งตัวแสดงถึงอะไรในแบบจำลองนี้ เพราะมันเป็นเพียงชุดของ Qubit รวมกันที่สร้างสิ่งที่มีความหมายทางกายภาพ ในกรณีนี้คือ wave packet แทนที่ คุณสามารถคิดคร่าว ๆ ว่า Qubit เป็นชิ้นส่วนที่ถูก discretize ของพื้นที่ ที่นี่ $L$ คือปริมาตรแลตทิซที่แต่ละองค์ประกอบ (unit cell) ประกอบด้วย Qubit สองตัว Fermionic operator ที่เราเห็นในสไลด์ก่อนหน้าอธิบายแอมพลิจูดของ wave function บนตำแหน่งเฉพาะ ดังนั้น Hamiltonian ของเราประกอบด้วย fermionic creation และ annihilation operator เหล่านี้ ดังนั้นเราใช้การแปลง Jordan-Wigner เพื่อ map operator เหล่านี้สู่ Pauli operator

$$\begin{aligned} \cal{H} &= \cal{H}_m + \cal{H}_{kin} + \cal{H}_{el} \\ &= \frac{m}{2} \sum\limits_{j=0}^{2L-1} [(-1)^j Z_j + I] + \frac{1}{2} \sum\limits_{j=0}^{2L-2}(\sigma_j^+\sigma_{j+1}^- + h.c.) + \frac{g^2}{2} \sum\limits_{j=0}^{2L-2} \Bigl( \sum\limits_{k \le j} Q_k\Bigr)^2 \end{aligned}$$

โดยที่ $\sigma_+$ คือ Pauli operator $X + iY$ และ $\sigma_{-}$ คือ $X - iY$ เมื่อเรามี Hamiltonian ที่เขียนในรูปแบบนี้แล้ว ส่วนที่ยากของขั้นตอนการ mapping เสร็จสิ้น และตอนนี้สามารถเขียนลงใน circuit ใน Pauli operator ได้ง่าย

บทสรุป

เราได้พูดถึงตัวอย่างสี่อย่างว่าเทคนิค mapping เฉพาะถูกนำมาใช้ล่าสุดในสาขาการประมวลผลควอนตัมอย่างไร โดยเริ่มจากที่ง่ายที่สุดและทำงานขึ้นไปจนถึงการนำการแปลง Jordan-Wigner ไปใช้กับพลวัตของแฮดรอน เนื้อหานี้มีความเป็นเทคนิคมาก และหากคุณไม่เคยเห็นมาก่อน อาจดูน่ากลัวมาก แต่มันจะง่ายขึ้นเมื่อคุณใช้เวลาฝึกฝนมากขึ้น ซึ่งเป็นเหตุผลที่คอร์สนี้เรียกว่า Quantum Computing in Practice ไม่ใช่ว่าใครก็ตามสามารถหยิบขึ้นมาและวิ่งได้ตั้งแต่ต้น ต้องใช้การศึกษา ความงงงวย และอาจเป็นช่วงเวลาที่น่าหงุดหงิด แต่ฉันขอแนะนำให้นั่งกับความรู้สึกไม่สบายนั้นและสำรวจคำถามที่เกิดขึ้นจริง ๆ เมื่อคุณดำเนินต่อไป นั่นเป็นวิธีเดียวที่จะเรียนรู้