How to program a quantum computer PART I

หมายเหตุ: บทความนี้เป็นส่วนหนึ่งของ "บทความชุด Article with Machine Translation" ซึ่งเป็นการแปลบทความจากต้นฉบับภาษาต่างประเทศด้วย Machine translation ดังนั้นจึงมีข้อผิดพลาดอยู่หลายจุด ขอให้ผู้อ่านโปรดใช้วิจารณญาณในการอ่าน ทาง EPT ไม่ขอรับประกันว่าข้อมูลที่ท่านได้อ่านเป็นข้อมูลที่ถูกต้อง และไม่ขอรับผิดชอบความเสียหายใด ๆ ที่เกิดต่อผู้อ่านทั้งทางร่างกาย จิตใจ ทรัพย์สิน ฯลฯ นะครับ

วิธีเขียนโปรแกรม Quantum Computer PART I

Battleships with partial NOT gates

เรือรบด้วย partial NOT gates

งานวิจัย IBM https://www.flickr.com/photos/ibm_research_zurich/16662697764/in/album-72157667479583962/

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

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

ผมไม่คิดว่าสิ่งนี้จะจริงทั้งหมด และด้วยบริษัทอย่าง IBM และ Google ที่ทำ อุปกรณ์ quantum นี่เป็นเวลาที่จะเริ่มต้นเล่นกับการเขียนโปรแกรม quantum!

คุณไม่จำเป็นที่จะต้องทำอะไรเจ๋งๆ! ในตอนแรกคุณสามารถเริ่มต้นการเดินทาง ของคุณไปกับการเขียนโปรแกรมแบบที่คนอื่นๆเริ่มต้นการเดินทางของพวกเขาใน โปรแกรมธรรมดาทั่วๆไป : เช่น การสร้างเกม

ไม่ต้องกังวลไป คุณไม่จำเป็นต้องมีคอมพิวเตอร์ควอนตัมเป็นของตัวเอง โปรแกรมควอนตัมอย่างง่ายๆสามารถที่จะรันบนคอมพิวเตอร์ปกติได้ คุณสามารถ ใช้เวลาซักหน่อยบนอุปกรณ์ควอนตัมจริงๆด้วย IBM’s Quantum Experience

นี่เป็นบทความแรกในชุดของบทความที่ผมจะอธิบายโปรแกรมง่ายๆบางอันที่ทำขึ้นได้โดยการใช้ IBM’s quantum API ในแต่ละอันจะมีเวอร์ชั่นเรือรบในตัวเองด้วย การดำเนินการควอนตัมอย่างง่าย ในการดำเนินการกลไกพื้นฐานของเกม

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

อะไร คือ Quantum Computer?

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

คอมพิวเตอร์ปกติมีพื้นฐานอยู่บน bits : ตัวแปรที่มีค่าที่เป็นไปได้แค่ 2 ค่า เรามัก จะเรียกมันว่า 0 และ 1 ถึงแม้ว่าในเนื้อหาของพีชคณิตบูลีน เราจะเรียกมันว่า True และ False ก็ตาม มันไม่สำคัญหรอกว่าเราจะเรียกมันว่าอะไร มันสำคัญที่ว่ามันมี แค่ 2 ค่าเท่านั้น

ด้วย bits เราสามารถที่จะดำเนินการบูลีนแบบง่ายๆได้ แบบ NOT , AND และ OR สิ่งเหล่านี้เป็น building blocks พื้นฐานของการคำนวณ ด้วยสิ่งนี้เราสามารถ ทำอะไรก็ได้ ตัวแปรใดๆมันซับซ้อนมากกว่า bit (แบบ int หรือ float) มันเป็น คอลเลกชั่นของบิตหลายๆอัน กาารดำเนินการใดๆจะซับซ้อนมากกว่า AND หรือ NOT จริงๆแล้วคือเอาพวกมันหลายๆอันมาติดกัน ที่ระดับที่เบสิคที่สุดของมัน นี่เป็นสิ่งที่คอมพิวเตอร์ธรรมดาเป็น

คอมพิวเตอร์ควอนตัมมีพื้นฐานอยู่บน quantum bits หรือ qubits สิ่งเหล่านี้มี 2 ค่าที่เป็นไปได้ที่เราเรียกว่า 0 และ 1 แต่กฎของกลไกควอนตัมยังอนุญาติความ เป็นไปได้อื่นๆ ที่เราเรียกว่าสถานะ superposition 

ในบางความรู้สึก สถานะ superposition เป็นค่าที่มีอยู่ระหว่างทางของ 0 ถึง 1 เรา สามารถวาดรูปของ qubit เป็นทรงกลมได้ โดยที่ 0 และ 1 อยู่ในขั้วที่ตรงข้ามกัน 

สถานะ superposition เป็นจุดความเป็นไปได้อื่นๆทั้งหมดบนพื้นผิวของทรงกลม

ถูกดัดแปลงจาก https://commons.wikimedia.org/wiki/File:Bloch_Sphere.svg

พอๆกับ 0 และ 1 ภาพนี้ยังเป็นสัญลักษณ์ที่สำคัญของสถานะ superposition อีกด้วย อันหนึ่งเรียกว่า u3(0.5*pi,0,0) 0 เป็นที่ยอมรับว่ามันไม่ใช่ชื่อที่หลอกลวง แต่เราจะได้ดูว่าจริงๆแล้วมันหมายความว่าอย่างไรผ่านทางบทความนี้

วิธีการคิดแบบนี้เกี่ยวกับ qubits ทำให้มันดูเหมือนว่าเป็นตัวแปรต่อเนื่อง เรา สามารถที่จะแทนจุดใดๆก็ได้บนพื้นผิวของทรงกลม (เหมือนจุด ψ ในภาพ) โดย การใช้พิกัดขั้วโลกเพียงคู่เดียวของมุม (θ และ φ) ดังนั้น คุณจะถูกให้อภัย หาก ว่าคุณคิดว่า qubit เป็นคู่ของ floats ในความรู้สึกพวกเขาเป็น แต่ในอีกความรู้สึก ที่แม่นยำกว่า พวกเขาไม่ใช่

ความแตกต่างที่สำคัญ คือ พวกเราไม่สามารถดึงข้อมูลได้ไปมากกว่าชิ้นส่วน binary ของข้อมูลจาก qubit ด้วยกฎทางฟิสิกส์ของตัวมันเองปกป้องพวกเราจาก การหาว่า จริงๆแล้วพวกมันทำอะไรกันแน่ เราไม่สามารถร้องขอ qubit สำหรับ รายละเอียดจริงๆของสถานะ superposition ของมันได้ เราทำได้เพียงแค่บังคับ มันให้เลือก ระหว่าง 2 จุดที่ตรงข้ามกันบนทรงกลมเท่านั้น (เช่น 0 และ 1) ถ้ามันเป็นอย่างอื่น นอกเหนือไปจาก 2 สถานะนี้ มันจะทำการเลือกโดยการสุ่ม อันหนึ่งหรืออีกอัน 

ดังนั้น qubit มีบางคุณสมบัติของตัวแปรที่มีความต่อเนื่องและมีบางคุณสมบัติที่ ไม่ต่อเนื่องในความเป็นจริง คือ มันไม่ใช่ทั้ง 2 อย่าง มันเป็นตัวแปร quantum

อะไรที่เราสามารถทำได้กับ qubits?

เกมเรือรบที่เราจะทำวันนี้มีพื้นฐานอยู่บนตัวแปรญี่ปุ่น (Japanese Variant) ในที่นี้ เรือทุกลำมีเพียงสี่เหลี่ยมจัตุรัสเดียว แต่บางลำก็มีการชนมากขึ้นเพื่อจะจมอันอื่นๆ

เราจะมีเรืออันนึงที่สามารถจะจมลงได้โดยระเบิดเดี่ยว 1 ลูก บางลำอาจใช้ถึง 2 ถึง 3 ลูก

ในการลอกเลียนแบบนี้ลงบนคอมพิวเตอร์ควอนตัม เราสามารถที่จะใช้ qubit ได้ สำหรับเรือแต่ละลำ สถานะ 0 จะสามารถถูกระบุด้วยเรือที่ยังไม่หมดอายุอย่าง สมบูรณ์ และ 1 ด้วยอันที่ถูกทำลายลง สถานะ superposition จะสัมพันธ์กับการ เดินทางของเรือต่อการทำลายล้าง 

เรือที่ถูกทำลายจากการชนเพียงครั้งเดียวจะเป็นอะไรที่ง่ายมากต่อการลอกเลียน แบบ เราสามารถกำหนดการเริ่มต้นของมันด้วยสถานะ 0  และใช้ NOT เมื่อมัน ถูกชน เมื่อเราพบว่ามันอยู่ในสถานะ 1 เราจะรู้ว่ามันถูกทำลายลงแล้ว มาดูที่วิธี การดำเนินการการดำเนินการอย่างง่ายๆบนคอมพิวเตอร์ควอนตัม เราไม่ต้องกังวล เกี่ยวกับเรืออันอื่นๆ หรือ inputs และ outputs ในเวลานี้ 

ภาษาประกอบขั้นพื้นฐานของคอมพิวเตอร์ควอนตัมเรียกว่า QASM นี่เป็น QASM Script ที่เริ่มต้นใช้งานเรือ , ระเบิดมัน , แล้วมองไปที่ว่าอะไรที่มันยังคงลอยอยู่ 

ใน 2 บรรทัดแรกจะอยู่ด้านบนของไฟล์ QASM ที่เหมาะสมเสมอๆ หลังจากนั้น เราจะกำหนดบิตทั้งหมดที่เราจำเป็นต้องใช้ : ทั้งบนควอนตัมและเครื่องทั่วไป ในตัวอย่างนี้เราได้กำหนด qubit เดี่ยวๆในการลงทะเบียน เรียกว่า q เราสามารถ อ้างถึง qubit ในโค้ดเป็น q[0] เนื่องด้วย outputs จะต้องดี คนสามารถอ่านได้เป็น ข้อมูลปกติ เรายังกำหนดบิตเดี่ยวๆธรรมดาๆในการลงทะเบียน เรียกว่า c อีกด้วย

qubit q[0] ถูกตั้งค่าเริ่มต้นเป็นสถานะ 0 โดยอัตโนมัติ เนื่องจากว่าเป็นสถานะที่เรา ต้องการเริ่มต้นใช้งานจึงไม่จำเป็นต้องมีการเตรียมการเพิ่มเติม

ต่อไปเราต้องทำ q[0] = 0 เป็นเรือที่ยังไม่หมดอายุโดยสมบูรณ์ และแสดงผล NOT ด้วยบิตธรรมดาและภาษาโปรแกรมธรรมดา เราอาจจะดำเนินการสิ่งนี้เป็น q[0] = !q[0] (สำหรับ C++) หรือ q[0] = not q[0] (สำหรับ Python) ใน QASM มันสามารถทำให้เสร็จได้ในหลากหลายช่องทาง ทางที่ง่ายที่สุด คือการใช้ตัวดำเนิน การที่เรียกว่า x และ y นี่เป็นตัวอย่างการใช้ของพวกมัน ด้วยความเสมอภาคของ บรรทัด C++ และ Python สำหรับการเปรียบเทียบ

มันมีความแตกต่างบางอย่างระหว่าง x และ y ที่เราจะต้องจัดการกับมันซักวันหนึ่ง แต่ไม่ใช่วันนี้

คุณจะสังเกตเห็นว่าไม่ทั้ง x หรือ y ที่ปรากฎในไฟล์ QASM ก่อนหน้า แต่เรามี u3(pi,0,0) แทน นี่เป็นอีกทางหนึ่งในการดำเนินการ NOT

มันเป็นความเสมอภาคอย่างสมบูรณ์แบบสำหรับ y แต่ u3 เป็นการดำเนินการที่มี ความซับซ้อนมากกว่าโดยปกติแล้ว มันมี 3 arguments และด้วยการเปลี่ยนแปลง พวกมัน เราสามารถที่จะทำสิ่งอื่นๆได้ 

Argument อันแรกเป็นมุมที่ถูกบีบอัดในรัศมี มันเป็นมุมที่เรากำลังจะเอารูปทรง กลมของ qubit ของเราไปใส่ไว้ในนั้น โดยมุม pi สัมพันธ์กับ 180° และนั่นหมาย ความว่าเราจะสามารถหมุนรูปทรงกลมให้คว่ำ 0 ไปยัง 1 และ 1 ไปยัง 0 ได้ นี่เป็น เหตุผลที่ว่าทำไมการดำเนินการนี้ปฏิบัติตัวเหมือนเป็น NOT ในการจะทำครึ่งนึง ของ NOT เราสามารถใช้ครึ่งนึงของมุมนี้ได้อย่างง่ายดาย : u3(0.5*pi,0,0)

ดังนั้นตอนนี้เรามีอีกวิธีหนึ่งที่จะแสดงผล NOT บน qubit ของเราแล้ว เราสามารถ ที่จะทำครึ่งนึงของ NOT ได้ 2 ครั้ง

เรายังสามารถทำ 1 ใน 3 sinv 1 ใน 4 ของ NOT ได้ โดยใช้ครึ่งหนึ่งของ NOT หรือ 2 ใน 8 ของ NOT คุณได้ไอเดียบ้างมั้ย?

บรรทัดสุดท้ายของไฟล์ QASM คือ

ในสิ่งนี้เราสามารถวัดหรือประมาณ qubit ได้ เราจะบอก q[0] ซึ่งจะตัดสินใจว่ามัน จะเป็นอะไร : 0 หรือ 1 ผลลัพธ์จะถูกจัดเก็บไว้ใน c[0] พร้อมที่จะถูกดูโดยสมอง ที่ไม่ใช่ควอนตัมหรือการดำเนินการโดยคอมพิวเตอร์ที่ไม่ใช่ควอนตัม ค่าของ c[0] เป็น output ของการคำนวณนี้

ถ้าเราไม่ได้ทำอะไรเลยระหว่างการดำเนินการการเริ่มต้นและการวัด…

…ผลลัพธ์ควรจะเป็น c[0] = 0

ถ้าเราทำ NOT…

…ผลลัพธ์ควรจะเป็น c[0]=1

ถ้าเราทำครึ่งนึงของ NOT…

…q[0] จะเป็นครึ่งทางระหว่าง 0 และ 1 เมื่อมันถูกวัด ในความเป็นจริงมันเป็น สถานะ superposition ที่เราเรียกว่า u3(0.5*pi,0,0) 0 ก่อนหน้านี้ วัดว่า สิ่งนี้เป็น 0 หรือ 1 หรือไม่จะบังคับพวกมันให้สุ่มเลือกมาอันนึงด้วยความเป็นไปได้ที่เท่ากัน 

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

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

การสร้างเกม

ต่อไปมาใช้ paths ต่างๆเหล่านี้ไปจนถึง NOT ในการสร้างเกมบนคอมพิวเตอร์ ควอนตัม

อย่างแรกเลย ผมจะบอกความลับกับคุณ คอมพิวเตอร์ควอนตัมเป็นอุปกรณ์ Hybrid บางส่วนของควอนตัมและบางส่วนของเครื่องปกติ เขาต้องใช้ inputs ที่รองรับและ outputs เพื่อที่จะสื่อสารกับคนที่ไม่เคยใช้อันนี้เพื่อที่จะใช้อุปกรณ์ อันนี้ได้

ด้วยธรรมชาติของ hybrid อันนี้จะส่งผลกระทบต่อวิธีการที่เราเขียนโปรแกรม การใช้ QASM เป็นสิ่งที่ดีสำหรับส่วนของควอนตัม แต่มันจะดีถ้าใช้บางอย่าง ที่มันคล้ายๆกันมากขึ้นในการทำส่วนที่เหลือ เช่น Python เป็นต้น

สิ่งนี้จะถูกเข้าใกล้ได้ผ่านทาง IBM’s quantum API เวอร์ชั่นปัจจุบัน และการเข้า ใกล้ของมัน ผมได้ใช้ในการเรียนการสอนนี้ วิธีการอื่นๆก็มี เช่น Project Q

มันเป็นเรื่องสำคัญที่จะโน๊ตว่าทุกสิ่งทุกอย่างยังคงมีการพัฒนาและทุกสิ่งทุกอย่าง ที่เราทำในการเขียนโปรแกรมควอนตัมในทุกๆวันนี้จะเป็นการไกด์วิวัฒนาการนั้น อย่างหลีกเลี่ยงไม่ได้

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

https://github.com/QISKit/qiskit-sdk-py/blob/master/tutorial/sections/tutorial4developer.ipynb (ลิ้งค์นี้ไม่มี)

ต่อไปมาดูโค้ดกัน!

อย่างแรกเลย ทุกสิ่งทุกอย่างที่เราจำเป็นที่จะต้องใช้ในการรันโค้ดบน IBM’s Quantum Experience จำเป็นที่จะต้องถูกนำเข้ามา 

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

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

ผู้เล่นจะถูกถามว่าอุปกรณ์อันไหนที่ควรจะถูกใช้รันส่วนของควอนตัมในวงจร มันมี ตัวเลือก 3 อันหลักๆ หนึ่งเลย คือ การเลียนแบบสิ่งของควอนตัมลงบน คอมพิวเตอร์ของคุณ (local_qasm_simulator) คุณยังสามารถที่จะถามคอมพิวเตอร์ ของ IBM ให้ทำการลอกเลียนแบบให้คุณได้อีกด้วย (ibmqx_qasm_simulator) แต่ คุณจำเป็นที่จะต้องใช้อุปกรณ์ควอนตัมจริงๆ 5 qubit : ibmqx2 เราถามผู้เล่นว่า มันต้องการที่จะใช้สิ่งนี้หรือไม่ หรือเพื่อจำลองมันโดยเฉพาะในท้องที่ การดำเนิน การนี้ไม่ได้ซับซ้อนมากจนขนาดที่ว่าเราจำเป็นที่จะต้องใช้ IBM เพื่อทำการจำลอง ให้แก่เรา

เราจะทำการตั้งตัวแปรที่สำคัญอันอื่นๆ : จำนวนครั้งในแต่ละงานจะถูกรัน (เพื่อ เก็บเป็นสถิติ)

มันไม่มีเหตุผลเจ๋งๆอะไรสำหรับ 1024 คุณสามารถเปลี่ยนมันได้ถ้าคุณต้องการ

ต่อไปเราจะมาทำการตั้งค่าบอร์ด ซึ่งเป็นที่ๆแต่ละผู้เล่นเลือกที่ๆจะวางเรือ 3 ลำ มี 5 ตำแหน่งที่เป็นไปได้อยู่ในนี้ สัมพันธ์กับ 5 qubits บน IBM’s ibmqx2 chip ผมเห็นภาพตารางเป็นแบบนี้

ตัวเลขเป็นชื่อที่ผมใช้สำหรับแต่ละตำแหน่ง พวกเขายังสามารถใช้ชื่อ IBM ได้ด้วย ดังนั้น 2 เป็นตำแหน่งของ qubit q[2] เป็นต้น

ตัวเลือกที่ถูกสร้างโดยผู้เล่นจะถูกจัดเก็บไว้ใน shipPos นี่เป็นรายการสำหรับผู้เล่น 2 คน (player=0 สำหรับผู้เล่นคนแรก , player=1 สำหรับคนที่ 2) และแต่ละที่ๆ เรือ 3 ลำของพวกเขาจอดอยู่ รายการของ shipPos[player][ship] อยู่ในตำแหน่ง (0, 1, 2, 3 หรือ 4) สำหรับหมายเลขเรือ ship เป็นเจ้าของโดย player

การเลือกจากผู้เล่นโดยทั่วไปแล้วจะทำให้สำเร็จโดย

สิ่งนี้จะพิมพ์ “ผู้เล่น player เลือกตำแหน่งสำหรับเรือ ship+1 (0, 1, 2, 3หรือ 4)”

และถามหาสำหรับ input โดยการใช้ getpass โดย input จะไม่ปรากฎอยู่บนหน้าจอ สำหรับให้ผู้เล่นคนอื่นเห็น สังเกตว่าเรือลำแรกถูกเรียกว่า ship=0 ในโค้ด แต่อ้าง ถึงเป็น ‘ship 1’ เมื่อพูดกับผู้เล่น เนื่องจากดัชนีส่วนใหญ่ของมนุษย์นับจาก 1 

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

ต่อไปเป็นเวลาของลูปเกมที่สำคัญๆ ในส่วนนี้เราจะถามผู้เล่นทั้ง 2 คนว่าที่ ไหนที่ตารางศัตรูของพวกเขาอยู่ ที่พวกเขาต้องการที่จะระเบิด สิ่งนี้จะถูกเพิ่ม เข้าไปใน bomb[player][position] ซึ่งจะนับว่ากี่ครั้งที่ player ได้ระเบิดใน position ในช่วงเวลาของเกม

ตอนนี้เรามีข้อมูลเพียงพอแล้วที่จะรันการดำเนินการนี้ลงบน quantum chip เรารู้ว่า qubits อันไหนถูกสนับสนุนให้เป็นเรือและที่ๆจะระเบิด ดังนั้นตอนนี้ถึงเวลาแล้วที่ จะมาสร้างไฟล์ QASM ที่สัมพันธ์กัน

ถ้าเราเขียนไฟล์ตรงๆ เราจะเริ่มต้นด้วย

สิ่งนี้แสดงให้เห็นว่ามีทั้งบิตควอนตัมและธรรมดาที่เราจำเป็นต้องใช้ เราแสดงให้ เห็น 5 อันของแต่ละอัน ถึงแม้ว่าเราไม่จำเป็นต้องใช้มันทั้งหมด การใช้ 5 qubits เป็นผลสะท้อนของความจริงที่ว่าเรารู้ว่ามี 5 qubits อยู่บน chip และมันอนุญาตให้ เราระบุเรือแต่ละลำด้วย qubit ทางกายภาพ โดยการใช้ 5 บิตธรรมดาๆ คืออะไร บางอย่างที่เราสามารถทำได้เพื่อหลีกเลี่ยงการบัคที่จะเกิดขึ้นในตอนจบของ IBM ในเวลานี้ 

แทนที่จะเขียนไฟล์ QASM ตรงๆ เราอาจจะใช้ Python ในการเขียนมัน ดังนั้น แทนที่จะเป็นคำนำหน้าเราจะกำหนดข้อกำหนดดังต่อไปนี้

เมื่อเราทำการติดตั้ง specs เราสามารถสร้างวงจรและเริ่มต้นที่จะควบคุมมันได้

“gridScript”เป็นสิ่งที่เราใช้เรียกวงจร เพราะว่ามันคำนวณว่าอะไรที่จะถูกทำให้เสร็จ ไปยังตารางเราสามารถเรียกมันว่า gridScript เมื่อเราเพิ่มการดำเนินการไปยังมัน เราอาจจะใช้ชื่อที่แตกต่างกันออกไปสำหรับ 2 สิ่งนี้โดยปกติแล้ว แต่เราจะไม่ทำ แบบนั้น

ตอนนี้สมมติว่าเราต้องการใช้บางส่วนของ NOT กับ qubit บางอย่าง ซึ่งหมาย ความว่าเราต้องการเพิ่มบรรทัดต่อไปนี้ไปยัง gridScript ,

แต่ด้วย frac และ position ซึ่งถูกแทนที่โดยหมายเลขจริงๆ เราจะทำสิ่งนี้ใน บรรทัดต่อไปด้วย Python

การใช้สิ่งนี้เราสามารถที่จะเพิ่มระเบิดทั้งหมดที่ผู้เล่นฝั่งตรงข้ามได้จุดระเบิดขึ้นที่ ตารางนี้ สำหรับตารางของ player เราจะวนลูปไปทั่วๆ 3 ตำแหน่งที่มันเป็นเรือ แล้วเพิ่มบรรทัดไปยัง gridScript สำหรับระเบิดทุกๆอันที่ได้ถูกส่งมาที่นี่

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

ในแง่ของ qubits , สิ่งนี้หมายความว่าระเบิดที่ไประเบิดเรือลำแรกจะต้องถูก ประยุกต์ใช้ไปเป็น NOT ทั้งหมด ระเบิดลูกที่ไประเบิดเรือลำที่ 2 จะถูกใช้เป็น ครึ่งหนึ่งของ NOT และลำที่ 3 ใช้เป็น 1 ใน 3 ของ NOT เศษส่วนของ frac ถูกกำหนดว่าเรือลำไหนที่จะถูกพุ่งชน สำหรับสิ่งนี้เราจะใช้ frac = 1/(ship+1)

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

สิ่งนี้สร้างบรรทัด QASM

ตอนนี้เรามีไฟล์ QASM ที่สมบูรณ์ที่ถูกจัดเก็บเป็น gridScript ถึงเวลาที่จะรัน มันแล้ว สิ่งนี้จะทำให้เสร็จได้โดยการใช้

ที่นี่ device และ shots ถูกกำหนดไว้ก่อนหน้านี้ตอนที่เราถามผู้เล่นว่าอุปกรณ์ไหน ที่จะให้รันบนนั้น คุณจะได้รับการอัปเดตบนการดำเนินการของคุณทุกๆ wait วินาที และมันจะล้มเลิกหลังจาก timeout วินาที

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

เมื่องานถูกรัน เราสามารถแยกข้อมูลได้

ที่นี่ผมได้ก้อปปี้ผลลัพธ์ไปยัง grid ด้วยผลลัพธ์สำหรับการระเบิดเรือของ player ใน grid[player] ผลลัพธ์จะถูกเก็บไว้ใน grid[player] เป็นพจนานุกรม คีย์ คือ bit strings และดังนั้นมันดูเหมือนว่าบางอย่างดูเหมือน 110 บิตด้านขวาสุด คือ c[0] และดังนั้น c[0]=0 ในตัวอย่าง bit string นี้ โดยการดำเนินการผลลัพธ์เราจะรู้ว่า มีการรันกี่ครั้งในแต่ละผลลัพธ์ (0 หรือ 1) สำหรับแต่ละบิตธรรมดาๆ

เราแปลเศษส่วนของครั้ง qubit ถูกวัดเป็น 1 เป็นเปอร์เซ็นต์ความเสียหายสำหรับ เรือของพวกเรา เราไม่สามารถคาดหวังความเสียหาย 100% ได้เนื่องจากผลกระทบ ของ noise (หรืออากาศ ถ้าคุณต้องการคำอธิบายในจักรวาล) ดังนั้น เราจะนับ ความเสียหายที่มากกว่า 95% นั่นหมายความว่าเรือได้จมลงแล้ว

ไปดูตัวอย่าง outputs บางอันจากการดำเนินการควอนตัม สมมุติว่าผู้เล่นคนนึง เอาเรือลำที่ 3 ของพวกเขาไปไว้ที่ตำแหน่งที่ 2 ผู้เล่นอีกคนก็ระเบิดมัน ผลลัพธ์ ควรจะมีหน้าตาแบบนี้ 

ที่นี่ 290 ของ 1024 รันพบ 1 ที่ตำแหน่งที่ 2 แสดงว่าเรือลำนี้ประสบกับความ ยากลำบากจากการทำลายนี้จริงๆ 

อีกตัวอย่างหนึ่ง : ผู้เล่นคนหนึ่งวางเรือลำแรกของเขาไว้ที่ตำแหน่งที่ 1 และลำที่ 2 ไว้ที่ตำแหน่งที่ 2 ผู้เล่นอีกคนระเบิดที่ตำแหน่งที่ 1 ในรอบแรกและตำแหน่งที่ 2 ในรอบที่ 2 ผลลัพธ์ควรจะเป็น

นี่คือผลทั้งหมดที่มี 1 ในช่องที่ 2 ทางด้านขวา (อันหนึ่งสำหรับตำแหน่งที่ 1) เรือนั้นถูกทำลายโดยลูกระเบิดเพียงลูกเดียว อีกอันที่ตำแหน่งที่ 2 ถูกทำลายเพียง แม้ว่าเพียงแค่ครึ่งเดียว ดังนั้นครึ่งของผลลัพธ์มี 1 สำหรับสิ่งนั้น ผลลัพธ์ของตัว อย่างเหล่านี้ ดีและชัดเจน ดังนั้น เราสามารถบอกได้ว่าพวกมันถูกทำให้เสร็จบน เครื่องจำลอง ในอุปกรณ์จริงคุณสามารถคาดหวังว่าจะพบเรือที่ไม่ได้ถูกทิ้งระเบิด เพียงไม่กี่รายการและสำหรับ qubits ที่ไม่ใช่เรือ ถ้ามันมีข้อผิดพลาดขณะกำลัง ดำเนินการไฟล์ QASM บน quantum chip (หรือ เครื่องจำลอง) ใน output จะมีสิ่งนี้รวมอยู่ด้วย

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

มันคือ else ของคำประกาศนี้ซึ่งการดำเนินการของผลลัพธ์ทั้งหมดถูกทำให้สำเร็จ พอๆกับการที่ไปบอกผู้เล่นว่าอะไรเกิดขึ้นกับเรือของพวกเขา

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

เมื่อเปอร์เซ็นต์ความเสียหายได้ถูกคำนวณ มันจะแสดงผลไปยังผู้เล่น ตัวอย่างเช่น ถ้าเรือที่ตำแหน่งที่ 2 ถูกตี และมันได้รับความเสียหาย 50% มันจะถูกโชว์เป็น

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

คุณจะสังเกตเห็นว่าการระเบิดเรือลำที่ 3 ของผู้เล่นได้รับความเสียหายประมาณ 25% เพราะว่าเรือลำนี้เป็นลำดับที่ 3 ในการทำลายล้าง คุณอาจคาดว่าจะได้ 33%

เหตุผลก็คือตรีโกณมิติ ไม่ต้องพึ่งพาเรื่องนี้มากนักในตอนนี้

มันเป็นเรื่องสำคัญที่จะโน๊ตว่า scenario ทั้งหมดได้รีรันทุกๆครั้ง ถ้าระยะเวลา ระหว่างการหมุนอาจเป็นเพียงแค่นาทีแต่เกือบจะเป็นนิรันดร์สำหรับ qubits แม้แต่ที่อุณหภูมิ 0.02 เคลวิน ข้อมูลจะถูกเผาไปนานก่อนจะถึงอันต่อไป นอกจากนี้ความต้องการของเราในการดึงข้อมูลก็จะรบกวนระบบควอนตัมทั้งหมด ในระบบ สำหรับหตุผลเหล่านี้ การดำเนินการใดๆที่ต้องการการตอบสนองของ มนุุษย์ตลอดจนจะต้องมีส่วนควอนตัมที่จะเรียกใช้ซ้ำตั้งแต่ต้นสำหรับแต่ละอินพุต ใหม่ 

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

Source Code ทั้งหมดสามารถเข้าถึงได้ผ่านทางด้านล่าง

https://github.com/QISKit/qiskit-tutorial/blob/master/5_games/battleships_with_partial_NOT_gates.ipynb (ลิ้งค์นี้ไม่มี)

เรื่องราวจะดำเนินต่อไปด้วยอีกเวอร์ชั่นของ Battleships ในพาร์ทที่ 2 

https://expert-programming-tutor.com/tutorial/article/MT204_How_to_program_a_quantum_computer_PART2.php

https://medium.com/@decodoku/how-to-program-a-quantum-computer-part-2-f0d3eee872fe

References :

https://medium.com/qiskitters/how-to-program-a-quantum-computer-982a9329ed02