วิธีการโปรแกรมคอมพิวเตอร์ควอนตัม - ส่วนที่ 2

เรือรบที่มีการวัดควอนตัม

IBM Research https://www.flickr.com/photos/ibm_research_zurich/33072160062/

บทความนี้มี 'ส่วนที่ 2' ในชื่อเรื่องด้วยเหตุผลที่ดี มีส่วนที่ 1 ซึ่งเราดูที่พื้นฐานของการเขียนและเรียกใช้โปรแกรมควอนตัม

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

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

วิธีดู qubits

ในโปรแกรมเรามีตัวแปร เมื่อถึงจุดหนึ่งเราจะต้องดูพวกเขา

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

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

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

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

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

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

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

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

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

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

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

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

การวัด qubit

การวัดใด ๆ ก็คือเราขอให้ qubit เลือกระหว่างจุดสองจุดตรงข้ามบนทรงกลม

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

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

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

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

นอกจากนี้เรายังมีการวัดสำหรับสิ่งที่ลูกศรแปลก ๆ สิ่งนี้เรียกว่าการวัดพื้นฐานแบบ Y ไม่มีใครชอบการวัดพื้นฐาน Y

บิตเป็นเพียงเล็กน้อยแม้ว่ามันจะเป็นควอนตัม

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

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

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

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

ช่างเกม

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

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

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

วิธีหนึ่งในการหลีกเลี่ยงการสร้างเรือรบดังกล่าวคือการใช้โค้ดง่ายๆ นั่นไม่ใช่สไตล์ของเราจริงๆ แต่เราจะแก้ไขด้วยกลศาสตร์ควอนตัม!

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

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

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

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

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

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

การจัดการกับ qubits อายุสั้น

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

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

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

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

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

ทำการวัด +/-

จนถึงตอนนี้ฉันได้เขียนจำนวนคำทั้งหมด แต่ไม่ใช่รหัสบรรทัดเดียว เริ่มจากการนึกถึงวิธีการวัดค่าแบบ 0/1 ในรหัส QASM

วัด q [0] -> c [0];

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

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

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

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

กุญแจสำคัญในการแฮ็คของเราคือการดำเนินการที่เรียกว่า Hadamard การใช้สิ่งนี้กับ qubit q [0] ในรหัส QASM มีลักษณะเช่นนี้

HQ [0];

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

gridScript.h (ด [0])

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

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

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

HQ [0]; วัด q [0] -> c [0]; HQ [0];

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

ตัวอย่างศูนย์:

วัด q [0] -> c [0];

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

ตัวอย่างที่หนึ่ง:

XQ [0];
วัด q [0] -> c [0];

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

ตัวอย่าง +:

HQ [0];
วัด q [0] -> c [0];

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

ตอนนี้เราได้ทำตัวอย่างเล็ก ๆ น้อย ๆ มาทำสิ่งที่ซับซ้อนมากขึ้น

ตัวอย่าง ++:

HQ [0];
HQ [0]; วัด q [0] -> c [0]; HQ [0];

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

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

สำหรับเรื่องราวอื่น ๆ เราจะดูที่เอฟเฟกต์ของเส้นทีละตัว Hadamard ตัวที่สองยกเลิกผลกระทบของอันแรกและหมุน qubit กลับสู่สถานะ 0 จากนั้นจะถูกถามว่าสถานะของมันคือ 0 หรือ 1 และตอบเสมอ 0 อีก Hadamard หมุนมันอีกครั้งเพื่อ +

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

หากคุณต้องการศัพท์แสงบางอย่างเพื่อค้นหาใน Wikipedia นี่คือตัวอย่างของSchrödingerและ Heisenberg รูปภาพของกลศาสตร์ควอนตัม

ตัวอย่างที่ 1:

XQ [0];
HQ [0]; วัด q [0] -> c [0]; HQ [0];

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

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

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

HQ [0]; วัด q [0] -> c [0]; HQ [0];

ในฐานะที่เป็นการวัด +/- เรามีอิสระที่จะทำเช่นนั้น ถ้าเราต้องการคิดว่ามันเป็น Hadamard ตามด้วยการวัด 0/1 แล้วตามด้วย Hadamard ก็ถือว่าใช้ได้เช่นกัน

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

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

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

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

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

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

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

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

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

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

วางมันทั้งหมดเข้าด้วยกัน

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

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