เหตุใดตัวแปรในคอมพิวเตอร์ควอนตัมจึงดูน่ากลัว

เหตุใดตัวแปรในคอมพิวเตอร์ควอนตัมจึงดูน่ากลัว

เครดิตฟรี

การเขียนโปรแกรมคอมพิวเตอร์หมายถึงการจัดการตัวแปรจำนวนมาก เหล่านี้มาในรูปแบบต่างๆเช่นintหรือหรือfloat boolแต่พวกเขาทั้งหมดถูกสร้างขึ้นจากสิ่งเดียวกัน: บิต
ในคอมพิวเตอร์ควอนตัม โครงสร้างพื้นฐานจะแตกต่างกันเล็กน้อย เราจะใช้qubitsซึ่งเป็นเวอร์ชันควอนตัมของบิต พวกเขามีคุณสมบัติที่ฟังดูคล้ายกับปรัชญา mumbo-jumbo เช่น “เป็นทั้ง 0 และ 1 ในเวลาเดียวกัน” แต่มันไม่ใช่แค่เวทย์มนต์เท่านั้น: คุณสมบัติเหล่านี้ถูกกำหนดไว้อย่างดีและมีผลที่ทรงพลัง

สล็อต

หนึ่งในตัวอย่างที่รู้จักกันดีที่สุดที่เกี่ยวข้องกับการที่เรียกว่าการทดสอบเบลล์ การทดสอบเหล่านี้เป็นการทดสอบที่ตั้งค่าไว้โดยเฉพาะเพื่อให้ตัวแปรมาตรฐานผ่านเสมอ แต่บางครั้งควอนตัมอาจล้มเหลว ดังนั้นพวกเขาจึงเป็นวิธีที่สามารถวัดผลได้เพื่อแสดงให้เห็นว่าเราได้ย้ายเข้าสู่อาณาจักรควอนตัมแล้ว
ตอนนี้เรามีคอมพิวเตอร์ควอนตัมบนคลาวด์ และเรามี SDK เช่นQISKitของ IBM เพื่อตั้งโปรแกรม มาทำแบบทดสอบ Bell กันเถอะ!
การทดสอบกระดิ่งสำหรับตัวแปรคลาสสิก
คอมพิวเตอร์ทั่วไปเรียกว่าคอมพิวเตอร์คลาสสิกอย่างน้อยก็โดยพวกเราที่ทำงานเกี่ยวกับสิ่งลึกลับมากกว่า มาเริ่มกันที่พื้นเดิมโดยกำหนดการทดสอบ Bell สำหรับตัวแปรคลาสสิกที่คอมพิวเตอร์เหล่านี้ใช้
ประการแรก เราต้องกำหนดคู่ของตัวแปร สิ่งเหล่านี้สามารถเป็นประเภทใดก็ได้ที่คุณต้องการ (ฉันจะเลือกแบบลอยตัว) และสามารถเริ่มต้นได้ด้วยกระบวนการประเภทใดก็ได้ที่คุณต้องการ (ฉันจะใช้การสุ่มบางอย่าง)
def setup_variables ():

r = random.random()

A = r(2/3) B = r(1/3)

คืนค่า A, B
ต่อไป เราต้องกำหนดแฮชง่ายๆ นี่เป็นเพียงฟังก์ชันที่เราจะกำหนดซึ่งรับตัวแปรตัวใดตัวหนึ่งเป็นอินพุต และแยกบิตออกเป็นเอาต์พุต มีหลายวิธีที่สามารถทำได้ แต่เราแค่ต้องเลือกสองวิธี ฉันเรียกสิ่งเหล่านี้ว่า‘V’และ‘H’พิมพ์แฮช
เนื่องจากตัวแปรของฉันเป็นแบบทศนิยม ฉันจะกำหนดแฮชเป็นเพียงการเปรียบเทียบกับค่าบางค่า แฮชสองประเภทที่ต่างกันจะสอดคล้องกับค่าที่แตกต่างกันสองค่าที่ใช้สำหรับสิ่งนี้ แต่คุณสามารถกำหนดแฮชให้เป็นอะไรก็ได้ที่คุณต้องการ
def hash2bit ( variable, hash ):

if hash==’V’:
bit = (variable<0.5)
elif hash==’H’:
bit = (variable<0.25)

bit = str(int(bit)) # เอาต์พุตควร เป็นสตริง

ส่งคืนบิต’0′ หรือ ‘1’
การทดสอบ Bell ถูกกำหนดไว้อย่างชัดเจนเพื่อพิจารณาว่าผลลัพธ์ที่เราได้รับจากแฮชเหล่านี้สอดคล้องกับสิ่งที่เป็นไปได้สำหรับตัวแปรคลาสสิกหรือไม่ มันทำได้โดยการคำนวณตัวเลขสี่ตัว เราจะเก็บเหล่านี้ในพจนานุกรมหลามและเรียกพวกเขาP[‘HH’], P[‘HV’], และP[‘VH’]P[‘VV’]
มาเน้นP[‘HV’]เป็นตัวอย่าง นี่คือความน่าจะเป็นว่าค่าบิตมาจาก’H’กัญชาชนิดบนAเป็นเช่นเดียวกับที่จากประเภทที่มีต่อ’V’ Bเราจะประมาณความน่าจะเป็นนี้โดยการสุ่มตัวอย่างหลายครั้งและกำหนดเศษส่วนของตัวอย่างที่ค่าบิตที่สอดคล้องกันเห็นด้วย
ความน่าจะเป็นอื่น ๆ ที่มีการกำหนดไว้ในทำนองเดียวกัน: P[‘HH’]เปรียบเทียบ’H’ประเภทกัญชาทั้งบนAและB, P[‘VV’]เปรียบเทียบVกัญชาชนิดทั้งในและP[‘VH’]เปรียบเทียบVประเภทกัญชาบนAกับชนิดที่มีต่อHB
ความน่าจะเป็นเหล่านี้คำนวณในฟังก์ชันต่อไปนี้ พารามิเตอร์shotsคือจำนวนตัวอย่างที่เราจะใช้
นัด = 1024
def คำนวณ_P ( ):

P = {}
สำหรับแฮชใน [‘VV’,’VH’,’HV’,’HH’]:

P[แฮช] = 0
สำหรับช็อตในระยะ (ช็อต):
A, B = setup_variables()
a = hash2bit ( A, hashes[0] )
b = hash2bit ( B, hashes[1] )
P[hashes] += (a!=b) / shots

return P
ตัวเลขสี่ตัวที่เราจะออกมานั้นไม่ได้แยกจากกัน ตัวอย่างเช่นถ้าเราพบว่าP[‘HV’], P[‘VH’]และP[‘VV’]เป็นศูนย์ทั้งหมดที่เราต้องการรู้ว่าP[‘HH’]ต้องเป็นศูนย์เกินไป
มาดูกันว่าทำไม มาจำความP[‘HV’]=0.0หมายกัน มันเป็นความน่าจะเป็นที่hash2bit(A,H)และhash2bit(B,V)มีความแตกต่าง ดังนั้นถ้าเป็นศูนย์ พวกเขาก็ต้องเห็นด้วยเสมอ
hash2bit ( A, H ) = hash2bit ( B, V ) (1)

สล็อตออนไลน์

สิ่งนี้บอกเราว่าhash2bit(A,H)และhash2bit(B,H)ไม่เคยไม่เห็นด้วย ซึ่งเป็นสิ่งที่เราตั้งใจจะพิสูจน์: P[‘HH’]=0.0.
โดยใช้หลักการเดียวกันนี้ เราสามารถกำหนดขอบเขตที่บังคับใช้ได้โดยทั่วไปกับสิ่งที่P[‘HH’]ได้รับอนุญาตให้ทำ
P[‘HH’] ≤ P[‘HV’] + P[‘VH’] + P[‘VV’]
เช่นเดียวกันสำหรับP[‘HV’], P[‘VH’]และP[‘VV’]เช่นกัน: ความน่าจะเป็นสี่แต่ละรายการต้องไม่มากกว่าผลรวมของอีกสามความน่าจะเป็น
นี่คือสิ่งที่เราทดสอบด้วยการทดสอบ Bell: ความน่าจะเป็นเหล่านี้เป็นไปตามขอบเขตบนหรือไม่? หากเป็นตัวแปรแบบคลาสสิกก็จะเป็นเช่นนั้น
การทดสอบเบลล์สำหรับตัวแปรควอนตัม
หากตัวแปรเป็นควอนตัม ความน่าจะเป็นที่เราได้รับอาจไม่เป็นไปตามขอบเขตเหล่านี้
หากคุณต้องการเห็นสิ่งนี้เกิดขึ้นจริง คุณสามารถทดสอบได้ด้วยตัวคุณเอง นี่เป็นโน้ตบุ๊ค Jupyter กับsetup_variables(), hash2bit()และcalculate_P()ฟังก์ชั่นทั้งหมดที่ตั้งขึ้นสำหรับคู่ของ qubits และAB
สิ่งที่คุณต้องมีคือกรอกโปรแกรมควอนตัมเพื่อบอกจริง ๆAและBต้องทำอะไร และโน้มน้าวให้พวกเขาทำในสิ่งที่ตัวแปรคลาสสิกไม่สามารถทำได้ เนื่องจากนั่นอาจดูเหมือนเป็นงานที่ค่อนข้างยากลำบาก ฉันจึงทำเป็นเกมสำหรับคุณ
ด้วยสิ่งนี้ คุณสามารถสร้างโปรแกรมที่ทำงานตรงข้ามกับตรรกะที่เราเคยใช้มาก่อน มันจะทำในสิ่งที่เราพิสูจน์แล้วว่าเป็นไปไม่ได้ มันจะให้ผลลัพธ์ที่มีลักษณะเช่นนี้
ขอบเขตบนสำหรับ P[‘VV’] คือ 1.1484375
ค่าของ P[‘VV’] คือ 0.150390625
ขอบเขตบนเป็นไปตามคำสั่ง 🙂

ขอบเขตบนสำหรับ P[‘VH’] คือ 1.14453125
ค่าของ P[‘VH’ ] คือ 0.154296875
ขอบบนเป็นไปตาม 🙂

ขอบเขตบนสำหรับ P[‘HV’] คือ 1.15625
ค่าของ P[‘HV’] คือ 0.142578125
ขอบเขตบนเป็นไปตาม 🙂

ขอบเขตบนสำหรับ P[‘HH’] คือ 0.447265625
ค่าของ P[‘HH’] คือ 0.8515625
!!!!! เรื่องนี้ผ่านพ้นไปด้วยดี :O !!!!!

jumboslot

ที่นี่P[‘HH’]ไม่เพียงแค่เกินขอบเขตบนเล็กน้อย หากเป็นเช่นนั้น เราสามารถอธิบายได้โดยความไม่ถูกต้องของตัวเลข หรือสัญญาณรบกวนทางสถิติจากการหาค่าเฉลี่ยจากจำนวนตัวอย่างที่จำกัด แต่สิ่งเหล่านี้ไม่สามารถอธิบายข้อเท็จจริงที่P[‘HH’]เกือบจะสองเท่าของมูลค่าที่คาดคะเนได้ว่าจะไม่มีวันมากกว่า
เกิดอะไรขึ้นที่นี่? ห่วงโซ่ของตรรกะที่เราใช้การทดสอบ Bell นั้นใช้ไม่ได้กับตัวแปรควอนตัมอย่างชัดเจน แต่ทำไม?
คำตอบคือมีข้อสันนิษฐานที่ซ่อนอยู่ในตรรกะนั้น เราใช้มันเพื่อหาจุด (4)
hash2bit ( A, H ) = hash2bit ( A, V ) (4)
ที่นี่เราเปรียบเทียบค่าที่เราได้รับจากHประเภทของแฮชของตัวแปรAกับค่าVของแฮชประเภท
สำหรับตัวแปรแบบคลาสสิก นี่สมเหตุสมผลอย่างยิ่ง ไม่มีอะไรหยุดเราไม่ให้คำนวณทั้งแฮชและเปรียบเทียบผลลัพธ์ แม้ว่าการคำนวณแฮชของตัวแปรจะเปลี่ยนตัวแปร แต่ก็ไม่เป็นปัญหา สิ่งที่เราต้องทำคือคัดลอกไว้ล่วงหน้าและเราสามารถทำแฮชทั้งสองแบบได้โดยไม่มีปัญหาใดๆ
เช่นเดียวกันกับตัวแปรควอนตัม ผลลัพธ์ของแฮชไม่เป็นที่รู้จักจนกว่าเราจะทำจริง เมื่อนั้น qubit เท่านั้นที่จะตัดสินใจว่าจะให้ค่าบิตใด และเมื่อมันกำหนดมูลค่าของแฮชประเภทหนึ่งแล้ว เราก็ไม่สามารถระบุได้ว่ามันจะตัดสินอะไรหากเราใช้แฮชประเภทอื่น เราไม่สามารถรับรอบนี้โดยการคัดลอกตัวแปรควอนตัมทั้งเพราะตัวแปรควอนตัมไม่สามารถคัดลอก ซึ่งหมายความว่าไม่มีบริบทใดที่ค่านิยมhash2bit(A,H)และhash2bit A,V)ถูกกำหนดไว้อย่างดีในเวลาเดียวกัน ดังนั้นจึงเป็นไปไม่ได้ที่จะเปรียบเทียบ
อีกสมมติฐานที่ซ่อนอยู่ก็คือว่าhash2bit(A,hash)ขึ้นอยู่กับชนิดของกัญชาเลือกสำหรับตัวแปรและไม่ได้เป็นหนึ่งทางเลือกสำหรับตัวแปรA Bนี่เป็นเรื่องที่สมเหตุสมผลอย่างยิ่ง เนื่องจากนี่เป็นวิธีที่เราตั้งค่าhash2bit()ฟังก์ชัน อย่างไรก็ตาม ข้อเท็จจริงที่ว่าขอบเขตบนถูกละเมิดดูเหมือนจะบ่งบอกว่าตัวแปรแต่ละตัวรู้ว่าแฮชกำลังทำอะไรกับอีกฝ่าย ดังนั้นพวกเขาจึงสามารถสมรู้ร่วมคิดที่จะให้พฤติกรรมที่แตกต่างกันมากเมื่อทั้งคู่มีHแฮชประเภท
ถึงกระนั้นเอฟเฟกต์ก็ยังบอบบาง เป็นไปไม่ได้ที่จะระบุได้ว่าตัวแปรใดที่ส่งผลกระทบ: คุณสามารถเปลี่ยนลำดับการทำแฮช หรือทำอย่างมีประสิทธิภาพพร้อมกันและคุณจะได้ผลลัพธ์แบบเดียวกัน ซึ่งหมายความว่ายังไม่ชัดเจนว่าเราสามารถพูดได้หรือไม่ว่ามีผลกระทบต่อกัน (ดูที่นี่สำหรับการสนทนาบางส่วน) แต่สิ่งที่เราพูดได้ก็คือมันเป็นบริบท : เพื่อให้เข้าใจผลลัพธ์จากตัวแปรหนึ่งอย่างถ่องแท้ บางครั้งก็จำเป็นต้องดูสิ่งที่ทำกับอีกตัวแปรหนึ่ง
ทั้งหมดนี้แสดงให้เห็นว่าตัวแปรควอนตัมไม่ได้เป็นไปตามตรรกะที่เราคุ้นเคยเสมอไป พวกมันทำตามกฎที่แตกต่างกัน กฎของกลศาสตร์ควอนตัม ซึ่งจะช่วยให้เราค้นพบวิธีการคำนวณแบบใหม่
สำหรับการใช้งานจริง
การทดสอบเหล่านี้ไม่ได้ออกแบบมาให้มีการใช้งานจริงเพิ่มเติม ดังนั้น เมื่อคุณได้พิสูจน์ความควอนตัมด้วยการทดสอบ Bell แล้ว อาจไม่ชัดเจนว่าคุณควรทำอย่างไรกับการทดสอบนี้ หากต้องการทราบเกี่ยวกับเรื่องนี้ คุณอาจต้องการดูที่อื่น บทแนะนำ QISKit จะเป็นจุดเริ่มต้นที่ดี
ในบทความนี้ ผมจะช่วยอธิบายความมหัศจรรย์เบื้องหลังการเข้ารหัสควอนตัม superdense พร้อมกับโค้ดตัวอย่างบางส่วนที่คุณสามารถเรียกใช้เองบนประสบการณ์ควอนตัมของ IBMเพื่อให้คุณได้เห็นการทำงานจริง เราจะใช้QISKitเพื่อดาวน์โหลดและติดตั้ง SDK

slot

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