How to program a quantum computer Part II

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

Battleships ด้วย Quantum Measurement

บทความนี้มีคำว่า ‘Part 2’ ในหัวข้อ เพราะมีเหตุผลที่ดี มันมี Part 1 ที่เราได้ดูที่ เบื้องต้นของการเขียนและรันโปรแกรมควอนตัมไปแล้ว

PART 1 : https://expert-programming-tutor.com/tutorial/article/MT203_How_to_program_a_quantum_computer_PART1.php

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

ผมจะสมมติว่าคุณได้อ่านอย่างน้อยครึ่งหนึ่งของอันแรกแล้วก่อนที่คุณจะมาที่นี่

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

วิธีที่จะไปดูที่ qubits

ในโปรแกรม เราจะมีตัวแปร ในบางจุดเราจำเป็นที่จะต้องดูที่พวกเขา

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

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

สิ่งนี้มันไม่จริงเกี่ยวกับตัวแปรควอนตัมซึ่งสามารถมีค่าที่ไม่แน่นอนได้ พวกเขา สามารถอยู่ในสิ่งที่เรียกว่า quantum superposition ซึ่งจะอนุญาตให้มันรองรับ ค่าที่ตรงกันข้ามกันหลายอันๆในครั้งเดียว

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

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

การทำแผนที่โลกของ qubit

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

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

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

สถานะ + ยังมีด้านตรงข้าม เพราะความแตกต่างจากมันก็เหมือน 0 มาจาก 1 สิ่งนี้อยู่บนฝั่งตรงกันข้ามซึ่งยังเป็นจุดหนึ่งตามแนวเส้นศูนย์สูตรเราจะเรียก
สถานะนี้ว่า -

ด้วยจุด 0 , 1 , + และ - ตอนนี้ได้ถูกกำหนดแล้ว อีกสองสามจุดกำลังขอความ สนใจจากเรา สิ่งเหล่านี้เป็นหนึ่งอันที่เป็นระยะห่างระหว่าง 0 และ 1 และยังเป็น ความห่างระหว่าง + และ - อีกด้วย เราจะเรียกสิ่งเหล่านี้ว่า ↻ และ ↺    ทำไมล่ะ? เพราะว่า ครั้งหนึ่งผมเห็นผู้ชายคนหนึ่งคนที่ไม่ได้เขียน The Da Vinci Code ทำมันและผมชอบมัน

ตอนนี้เราได้ทำแผนที่โลกของ qubit ด้วย 6 จุด  นี่ไม่ใช่แค่สิ่งเดียวที่เราจะใช้
พวกมันเป็น landmarks แบบง่ายๆที่เราจะนำทาง

Qubit Measurement  

measurement ใดๆเป็นเพียงแค่เราขอให้ qubit เลือกระหว่างจุด 2 จุดที่ตรงกัน ข้ามกันบนรูปทรงกลม

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

บนเส้นศูนย์สูตร มันมีโอกาส 50/50 ในทางใดทางหนึ่ง ดังนั้น ถ้าสถานะของพวก เราเป็น + หรือ - แล้วเราถามว่ามันเป็น 0 หรือ 1 หรือไม่ มันจะต้องเลือก 1 อัน ด้วยความเป็นไปได้ที่เท่ากัน

measurement มีพื้นฐานอยู่บน 0 และ 1 ที่มีชื่อ 2-3 ชื่อ เราสามารถเรียกมันว่า  0/1measurement สำหรับเหตุผลที่ชัดเจน มันยังสามารถเรียกว่า Z basis measurement (measurement พื้นฐาน Z) ได้อีกด้วย เนื่องด้วยความสัมพันธ์พิเศษ ที่สถานะ 0 และ 1 มีการดำเนินการที่เรียกว่า z จะขอเพิ่มเติมในเรื่องนี้ในเวลาอื่น

ชนิดของ measurement ที่ได้รับความนิยมอันต่อไป คือ อันหนึ่งสำหรับ + และ - ผมจะเรียกสิ่งนี้ว่า +/- measurement แต่คุณอาจจะเห็นว่ามันยังสามารถเรียกว่า X basis measurement ได้อีกด้วย มันทำงานในทางเดียวกันกับก่อนหน้านี้ แต่เป็น สำหรับ + และ - แทนที่จะเป็น 0 และ 1  ดังนั้น ถ้าคุณเริ่มต้นด้วย qubit ใน สถานะ + และทำ measurement นี้ คุณจะได้รับผลลัพธ์เป็น + แต่ถ้าคุณเริ่มด้วย 0 และถามคำถามที่เหมือนกันมันจะทำการเลือกแบบสุ่ม

เรายังมี measurement สำหรับสิ่งที่เป็นลูกศรแปลกๆ สิ่งนี้เรียกว่า Y basis measurement ไม่มีใครชอบ Y basis measurements

Bit ก็คือ Bit แม้แต่เมื่อมันเป็นควอนตัม
measurement ของวัตถุที่ไม่ได้เป็นควอนตัมเป็นการดำเนินการ passive มันจะบอก คุณว่า กำลังทำวัตถุอะไรอยู่ แต่มันจะไม่ทำการเปลี่ยนแปลงมันไปในทางใดๆเลย measurement สิ่งที่เป็นควอนตัมเป็นอะไรที่แตกต่างมาก ควอนตัม measurement ไม่ได้เพียงแค่เปลี่ยนความรู้ของพวกเราเกี่ยวกับตัวแปรต่างๆ เท่านั้น พวกมันยัง เปลี่ยนตัวแปรด้วยตนเองอีกด้วย

เสนอให้คุณมี qubit ในสถานะ + แล้วถามมันว่ามันเป็น 0 หรือ 1 หรือไม่ เมื่อมัน ให้ผลลัพธ์แบบสุ่ม มันไม่ใช่แค่ทำให้คุณผิดหวัง มันไม่ได้บอกคุณเรื่องไร้สาระ เพราะว่าคุณถามคำถามที่ผิด เมื่อมันให้ผลลัพธ์แก่คุณ มันจะติดมากับมัน ค่าของ มันจะเปลี่ยนแปลงเพื่อสะท้อนคำตอบ ถ้ามันบอกคุณเป็น 0 มันจะเป็น 0 ตลอด ไป (หรืออย่างน้อยจนกว่าคุณจะยุ่งกับมันอีกครั้ง) มันจะลืมว่ามันเคยเป็น +  
นี่หมายความว่า qubit  สามารถตรวจสอบผลลัพธ์ของมันไปเป็น measurement เดี่ยวได้เท่านั้น ถ้ามันรู้อย่างแจ่มแจ้งว่ามันเป็น 0 หรือ 1 หรือไม่ มันจะไม่แน่ใจ อย่างสมบูรณ์ว่ามันเป็น + หรือ - หรือไม่และรวมไปถึงไม่แน่ใจอย่างสิ้นเชิงว่ามัน เป็น ↻หรือ↺หรือไม่ qubit มีข้อจำกัดในการจำกัดขอบเขตโดยจำกัดด้วยหลักการ ความไม่แน่นอนของ Heisenberg

นี่หมายความว่าเราจะได้รับแค่ 1 ครั้งจากการได้รับข้อมูลจาก qubit เมื่อเราทำการ แยกผลลัพธ์ binary เดี่ยว ทุกๆอย่างที่ qubit เคยรู้มาก่อน measurement จะลืม ทั้งหมด มันจะจดจำเฉพาะผลลัพธ์ที่มันแสดงผลให้เรา ดังนั้นแม้จะมีจำนวนอนันต์ ของสถานะ qubit ที่เป็นไปได้ เราสามารถทำการดึงบิตเดี่ยวของข้อมูลได้เท่านั้น นั่นคือ เหตุผลว่าทำไมเราถึงคิดว่ามันเป็นบิตเวอร์ชั่นควอนตัมมากกว่าที่จะเป็น quantum float หรือ quantum 3 vector และอื่นๆ

กลไกของเกม

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

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

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

ทางเดียวที่จะหลีกเลี่ยงการทำเรือแบบนั้นได้ด้วยบรรทัดของโค้ดง่ายๆ2-3บรรทัด แม้ว่ามันจะไม่ใช่สไตล์ของพวกเราก็ตาม เราเลยทำการซ่อมมันด้วยกลไกควอนตัม แทน! 

เราจะพยายามที่จะคั้น 2 บูลีนนี้ไปเป็น qubit เดี่ยว เพราะว่ามันไม่ค่อยเหมาะเท่า ไหร่ เราจะได้รับพฤติกรรมควอนตัมที่น่าสนใจ สิ่งนี้จะเพิ่ม gameplay ที่น่าสนใจ ไปยังเกมดีพอๆกับการปกป้องเรือใดๆจากการที่ไม่สามารถทำลายได้

พวกเราจะดำเนินการสิ่งนี้ด้วยการเชื่อมโยงการโจมตีด้วยระเบิดด้วย
0/1 measurement ถ้าเราได้รับผลลัพธ์เป็น 1 เราบอกได้ว่าเรือลำนั้นจม สำหรับ 0 เราสามารถอนุมานได้ว่าเรือมีภูมิคุ้มกันต่อการโจมตีด้วยระเบิด สำหรับตอร์ปีโดเรา จะใช้ +/-measurement แทน โดย - บ่งบอกถึงการทำลาย ส่วน + บอกถึง ภูมิคุ้มกัน 

วิธีการนี้ทำให้มันเป็นไปไม่ได้สำหรับเรือที่มีภูมิคุ้มกันทั้ง 2 ชนิดของการโจมตี ถ้า เราพบว่าเรือลำนั้นของศัตรูมีภูมิคุ้มกันกับระเบิด (กล่าวคือ สถานะของมัน คือ 0) เราจะรู้อย่างไม่ต้องสงสัยว่าต้องเป็นตอร์ปีโด (ผลลัพธ์ของ +/- measurement) 

เพราะเมื่อการโจมตีด้วยระเบิดมัน fail แม้กระนั้นเราควรที่จะโจมตีด้วยตอร์ปีโด เป็นอันต่อไป

มันอาจจะแสดงออกมาได้ว่าการโจมตีด้วยตอร์ปีโดมันเฟล (สถานะจะกลายเป็น + หลังจากที่ +/- measurement) เรือจะตัดสินใจอย่างแน่นอนว่ามันเป็นภูมิคุ้มกัน สำหรับพวกเขา และไม่ว่าจะเป็นการโจมตีใดๆต่อไปด้วยตอร์ปีโดมันก็จะเฟล แต่เรายังไม่หมดหวัง เมื่อทราบเกี่ยวกับตอร์ปีโดแล้วก็มีความไม่แน่นอนเกี่ยวกับ ระเบิด โจมตีพวกมันด้วยอันต่อไป (ทำ 0/1 measurement) สามารถที่จะนำไปสู่ ชัยชนะได้

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

เราจะเริ่มต้นทำการจมเรือโดยไม่แน่ใจเกี่ยวกับภูมิคุ้มกันของพวกมันทั้ง 2 แบบ ของการโจมตี ซึ่งสามารถทำได้โดยการเริ่มต้น qubit ในสถานะพื้นฐานของ Y ไปต่อที่ ↻ จริงๆแล้วนี่เป็นสถานะที่เราได้เจอในพาร์ทที่ 1 คือ u3(0.5*pi,0,0) 0 ดังนั้น เราได้รู้เรียบร้อยแล้วเกี่ยวกับวิธีการทำมัน

จัดการกับ qubits ที่มีอายุสั้นๆ

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

เสนอเรือที่ถูกโจมตีด้วยระเบิดและยังอยู่ได้และในรอบต่อไปมันจะถูกโจมตีด้วย ตอร์ปีโด 

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

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

ทางเลือก คือ การรันการดำเนินการควอนตัมใหม่ทุกๆครั้งที่มีการโจมตี งานแรก คือ ทำการเริ่มต้นด้วยสถานะ ↻ ดังนั้น ผลลัพธ์จะเป็นการสุ่มสำหรับทั้ง 0/1 measurement (การโจมตีด้วยระเบิด) หรือ +/- measurement (การโจมตีด้วย ตอร์ปีโด) ผลลัพธ์ของ measurement จะถูกบันทึกและจัดเก็บไปยังหน่วยความจำ บนคอมพิวเตอร์ทั่วไป เมื่อเกิดการโจมตีอันต่อไป งานอีกอันจะถูกสร้างให้เห็นว่า อะไรจะเกิดขึ้น มันถูกเริ่มต้นด้วยผลลัพธ์ของ measurement อันล่าสุดและมันก็ต่อ เนื่องไปเรื่อยๆ

การทำ +/- measurement

จนถึงตอนนี้ ผมได้เขียนมาเยอะมากๆ แต่ไม่ใช่บรรทัดเดี่ยวของโค้ด มาเริ่มต้น ด้วยการฟื้นความจำในเรื่องของวิธีการที่ 0/1 measurement ถูกดำเนินการใน QASM code กัน

บทบาทของ c[0] ที่นี่มันเป็นเรื่องสำคัญที่จะกลับไปดูอีกครั้ง มันเป็น output ของ กระบวนการ  measurement มันเป็นบิตธรรมดาที่ผลลัพธ์ของ measurement ได้ ถูกจัดเก็บไว้

นี่มันค่อนข้างที่จะตรงไปข้างหน้าเรื่อยๆสำหรับ 0/1 measurement แต่สิ่งที่เราจะ ดูตอนนี้ คือ +/-measurements เราจะได้รับข้อมูลจากหนึ่งในนั้นอย่างไร?

เรายังคงต้องการที่จะจัดเก็บผลลัพธ์ในบิตธรรมดา c[0] เพราะว่ามันเป็นบิต ธรรมดา มันไม่มีความรู้เลยเกี่ยวกับสถานะที่แปลกออกไปของ + และ - มันรู้ เฉพาะ binary ธรรมดา แม้กระนั้นเราเลือกที่จะรีพอร์ทผลลัพธ์ + เป็น c[0]=0 และ - เป็น  c[0]=1 ความจริง คือ สิ่งเหล่านี้มันดูเหมือนกับผลลัพธ์ของ 0/1measurement ไม่ได้เป็นปัญหา เช่นเดียวกับในโปรแกรมคอมพิวเตอร์ใดๆ เรา ควรรู้ว่าอะไรที่เราจะทำการเขียนโปรแกรมและดังนั้นเราควรจะรู้วิธีการแปลผลลัพธ์

ตอนนี้เรารู้วิธีการที่จะเอาผลลัพธ์จาก +/- measurement แล้ว แต่เรายังไม่รู้ถึง วิธีการที่จะทำมันขึ้นมาอันนึง เป็นเพราะเราจำเป็นต้องแอบอ้างเรื่องนี้ เราจำเป็น ที่จะต้องแฮ็ก การดำเนินการที่ทำ 0/1 measurements และทำให้มันทำ +/- อันหนึ่ง แทน

คีย์ในการแฮ็กของพวกเรา คือ การดำเนินการที่เรียกว่า Hadamard ประยุกต์ใช้สิ่งนี้ ไปยัง qubit q[0] ใน QASM code จะมีหน้าตาแบบนี้ 

คำสั่งที่เราใช้ใน Python เพื่อที่จะเพิ่มบรรทัดนี้ไปยังไฟล์ QASM เรียกว่า gridScript คำสั่งนี้ คือ

ผลกระทบของ Hadamard คือ เพื่อที่จะแลกเปลี่ยนสถานะ Z basis ด้วย X basis อันหนึ่งและในทางกลับกัน  มันคือการหมุนรูปทรงกลมที่เคลื่อนย้ายสถานะ qubit 0 ไปเป็น + และ + เป็น 0 เหมือนกันกับ 1 ถูกหมุนไปเป็น - และในทางกลับกัน

สิ่งนี้หมายความว่าเรื่องราวที่เราสามารถบอกเกี่ยวกับ qubit ในแง่ของ 0 และ 1 ก่อน Hadamard เราต้องบอกด้วย + และ - หลังจากมัน และเรื่องราวใดๆของ + และ - กลายเป็น 1 ใน 0 และ 1

สิ่งนี้ิ คือสิ่งที่เราต้องการจริงๆ มันหมายความว่า +/- measurement บน qubit q[0] สามารถทำให้เสร็จได้ด้วยโค้ด QASM ด้านล่างนี้   

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

ตัวอย่าง 0 :

qubit เริ่มต้นในสถานะ 0 มันถูกถามว่ามันเป็น 0 หรือ 1 หรือไม่และบอก c[0] ถึงคำตอบ ผลลัพธ์จะเป็น c[0]=0 เสมอ  

ตัวอย่าง 1 :

qubit เริ่มต้นในสถานะ 0 และทำการหมุนไปเป็น 1 มันถูกถามว่ามันเป็น 0 หรือ 1 หรือไม่ คำตอบของมันจะเป็น 1 เสมอ

ตัวอย่าง + :

qubit เริ่มต้นในสถานะ 0 และทำการหมุนไปเป็น + ทันที แล้วมันจะถามว่าสถานะ ของมันเป็น 0 หรือ 1 หรือไม่ มันจะทำการเลือก 1 หรืออันอื่นๆโดยการสุ่มและ สถานะของมันจะถูกอัปเดตด้วยคำตอบ 

ตอนนี้เราได้ทำตัวอย่างเล็กๆน้อยๆแล้ว ขออนุญาตทำอะไรที่มันซับซ้อนมากกว่านี้

ตัวอย่าง ++ :

qubit เริ่มต้นในสถานะ 0 และทำการหมุนไปยัง + หลังจากนั้น มันมี 2 ทางที่มี ความสมดุลกันที่เราสามารถที่จะไปต่อเรื่องราวได้

อันที่ 1 คือ การที่จะพูดว่า 3 บรรทัดสุดท้ายเป็นการทำ +/- measurement อย่าง รวมๆกัน มันถาม qubit ว่ามันเป็น + หรือ - หรือไม่ สำหรับ + พวกเขาจะให้ ผลลัพธ์ c[0]=0 กลับมาและสำหรับ - พวกเขาจะให้ c[0]=1 กลับมา เพราะว่า

qubit ไปยัง measurement ด้วยสถานะ + ในตัวอย่างนี้ มันมักจะถูกวัดเป็น + แม้กระนั้นสิ่งที่ออกมาของ measurement ยังคงอยู่ในสถานะนี้
สำหรับเรื่องอื่นๆที่เราจะดูไปที่ผลกระทบของบรรทัดแบบบรรทัดต่อบรรทัดแล้ว การ undo ของ Hadamard อันที่ 2 ส่งผลกระทบไปยังอันแรกด้วย ดังนั้น ต้องทำ การหมุน qubit กลับไปยังสถานะ 0 แล้วมันจะถามว่าสถานะของมันเป็น 0 หรือ 1 หรือไม่และมักจะได้คำตอบ 0 เสมอ Hadamard อันต่อไปจะทำการหมุนมันอีกครั้ง ให้เป็น + 

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

ถ้าคุณต้องการศัพท์เฉพาะเพื่อที่จะดูสิ่งต่างๆนี้บน Wikipedia นี่เป็นตัวอย่าง ของรูปของกลไกควอนตัมของ Schrödinger และ Heisenberg 

ตัวอย่าง +1 :

นี่เป็นอีกตัวอย่างหนึ่งที่เรามีเรื่องราวที่เทียบเท่ากัน 2 เรื่อง เราสามารถพูดได้ว่า q[0] เริ่มต้นเป็น 0 และทำการหมุนไปเป็น 1 แล้วสิ่งนี้ทำการหมุน t0 - ก่อนที่จะ ไปผ่าน 0/1 measurement มันตัดสินใจเป็น 1 หรืออันอื่นๆโดยการสุ่ม ให้เอาท์พุต  
c[0]=0 or c[0]=1 และมีสถานะของมันที่ถูกอัปเดตตาม ถ้ามันตัดสินว่าเป็น 0 Hadamard อันสุดท้ายจะหมุนมันเป็น + มิฉะนั้นมันจะจบลงด้วย -

ในอีกทางหนึ่ง เราสามารถพูดว่าหลังจากการหมุนไปเป็น 1 แล้ว qubit จะไปผ่าน +/- measurement มันจะทำการตัดสินใจแบบสุ่มระหว่าง 2 ตัวเลือกเหล่านี้ ให้ เอาท์พุต c[0]=0 สำหรับ + และ c[0]=0 สำหรับ - สถานะจะถูกอัปเดตตาม จบลง ด้วยในสถานะ + หรือ - อย่างใดอย่างหนึ่ง

อีกครั้งนึงเรื่อง 2 เรื่องนี้มีความถูกต้องเท่าเทียมกันและเห็นด้วยกับผลกระทบที่ สามารถสังเกตได้ทั้งหมด ถ้าเราต้องการที่จะคิดเกี่ยวกับ 3 บรรทัด

เป็น +/- measurement ดังนั้น เราเป็นอิสระที่จะทำมัน ถ้าคุณต้องการคิดว่ามันเป็น  Hadamard ตามด้วย 0/1 measurement ตามด้วย Hadamard นั่นก็โอเคเหมือนกัน

มันมีสิ่งหนึ่งที่สำคัญที่จะโน๊ตก่อนที่เราจะไปกันต่อ API ของ IBM  ตอนนี้ไม่ อนุญาตให้เราทำสิ่งใดๆก็ตามบน qubit หลังจากที่เราได้ทำการวัดมัน นี่ไม่ได้เป็น กฎธรรมดาสำหรับคอมพิวเตอร์ควอนตัม โดยปกติเราคาดว่าจะสามารถวัดและ จัดการกับ qubits ได้ตราบนานเท่าที่เราต้องการ แต่เราไม่สามารถทำมันได้ใน ตอนนี้

นี่ไม่ใช่ปัญหาเลย เพราะ qubits ไม่ได้อยู่รอบๆขณะที่ผู้เล่นทำการเลือกตัวเลือก เราต้องสร้างสถานะใหม่ทั้งหมดหลังจากแต่ละ measurement รอบๆ Hadamard ที่ 2 จะมีผลในงานต่อไป , ทำบนเวอร์ชั่นแรกของสถานะ   

measurements ที่เป็นไปได้อื่นๆสามารถทำได้โดยการแฮ็กที่คล้ายกัน เราจำเป็น ต้องดำเนินการบางอย่างก่อนเพื่อตรวจสอบ measurement อื่นๆของเราแล้ว (หาก API อนุญาต) ดำเนินการตรงข้ามต่อไป     

จัดการกับข้อผิดพลาด

เทคโนโลยีควอนตัมปัจจุบันไม่ได้เพอร์เฟ็กต์ qubits ไม่ได้ทำในสิ่งที่พวกมันควรทำ เสมอ ถ้า qubit เป็น 0 และคุณทำ 0/1 measurement ผลลัพธ์มักจะเป็น 0 เสมอ ย้ำว่า “เสมอ” แต่ด้วยอุปกรณ์ควอนตัมปัจจุบันมันมีโอกาสที่จะเป็น 1 มันอาจจะ เป็นได้ อาจเป็นเพราะการดำเนินงาน x แอบเข้าไปในขณะที่เราไม่ได้มองหาหรือ อาจเป็นเพราะ measurement กำลังโกหกเรา สถานการณ์แบบนี้เป็นอะไรที่หาได้ ยากแต่มันก็เกิดขึ้นได้

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

วิธีที่ 2 ที่จะจัดการกับความผิดพลาด คือ พยายามที่จะลบผลกระทบของพวกเขา ถ้ามี qubits มากมายที่มีอยู่ เราสามารถทำสิ่งนี้ได้ด้วย quantum error correction (การแก้ไขความผิดพลาด quantum) น่าเสียดาย มันอยู่ได้แค่ไม่กี่ปี

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

ในกรณีที่ไม่มีเสียงรบกวน ความเป็นไปได้ทั้งหมดอาจจะเป็น 0% , 100% หรือ 50% ผลลัพธ์เป็นไปไม่ได้ (เหมือนได้รับ 1 แต่สถานะเป็น 0) , แน่นอน (เหมือน ได้รับ + ถ้าสถานะของมันเป็น +) หรือสุ่มอย่างสมบูรณ์แบบ (เหมือนได้รับ 0 เมื่อสถานะเป็น +) อย่างใดอย่างหนึ่ง

เสียงรบกวนจะทำให้สิ่งนี้ยุ่งยากนิดหน่อย เมื่อเราทำ 0/1 measurement ของ 0 เราอาจจะพบว่าผลลัพธ์ 0 ปรากฎขึ้นเพียงแค่ 98% เท่านั้น ส่วนอีก 2% สำหรับ 1 แทน เพื่อแก้ไขปัญหานี้เราจะทำอะไรบางอย่างโดยพลการ เราจะตัดสินใจว่า อะไร ก็ตามที่มีความเป็นไปได้น้อยกว่า 5% ควรจะไม่เคยเกิดขึ้นเลยและอะไรก็ตามที่มี ความเป็นไปได้มากกว่า 95% ควรจะเกิดขึ้นแน่นอน        

เอามันทั้งหมดมารวมกัน

บทความนี้ครอบคลุมในวงกว้างในเรื่องของกลไกเกมสำหรับเวอร์ชั่นนี้ของ Battleships และวิธีการที่จะดำเนินการมันด้วยคอมพิวเตอร์ควอนตัม แทนที่จะ ไปผ่านทุกรายละเอียดสารัตถะที่นี่ ผมจะทิ้งมันไว้สำหรับความคิดเห็นใน source code จริงๆ
https://github.com/decodoku/Battleships_with_complementary_measurements/blob/master/Battleships_with_complementary_measurements.ipynb

หากมีสิ่งใดที่คุณคิดว่าต้องการคำอธิบายเพิ่มเติมโปรดแจ้งให้ผมทราบ

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