สัญญาณรบกวนและข้อผิดพลาด

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

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

สาเหตุ

สัญญาณรบกวนและข้อผิดพลาดแบบคลาสสิก

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

สัญญาณรบกวนจากความร้อน:

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

ความเสียหายและการเสื่อมสภาพจากความร้อน:

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

ผลกระทบที่เกิดจากรังสี (Single-Event Upsets, SEUs):

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

การรบกวนทางแม่เหล็กไฟฟ้า:

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

การรบกวนข้ามสาย (Crosstalk) ระหว่างจุดเชื่อมต่อ:

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

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

สัญญาณรบกวนและข้อผิดพลาดเชิงควอนตัม

ในการคำนวณเชิงควอนตัม สัญญาณรบกวนและข้อผิดพลาดมักถูกกล่าวถึงควบคู่กัน แต่การรับรู้ถึงความแตกต่างระหว่างทั้งสองเป็นสิ่งสำคัญ สัญญาณรบกวนเชิงควอนตัมหมายถึงการรบกวนทางกายภาพพื้นฐานที่ส่งผลต่อคิวบิตและระบบเชิงควอนตัม ซึ่งรวมถึงปฏิสัมพันธ์หรือความผันผวนที่ไม่พึงประสงค์ทุกรูปแบบจากสภาพแวดล้อม การควบคุมที่ไม่สมบูรณ์แบบ หรือข้อบกพร่องของฮาร์ดแวร์ ที่ทำให้สถานะเชิงควอนตัมเบี่ยงเบนไปจากอุดมคติ ข้อผิดพลาดเชิงควอนตัมคือความคลาดเคลื่อนหรือข้อบกพร่องที่เฉพาะเจาะจงในข้อมูลเชิงควอนตัมซึ่งเป็นผลมาจากสัญญาณรบกวนเชิงควอนตัม ข้อผิดพลาดเชิงควอนตัมคือการแสดงออกที่สามารถวัดได้หรือเชิงปฏิบัติการของสัญญาณรบกวน และข้อผิดพลาดรวมถึงการพลิกบิต (bit-flip) การพลิกเฟส (phase-flip) การหน่วงแอมพลิจูด (amplitude damping) และอื่น ๆ ทั้งสัญญาณรบกวนและข้อผิดพลาดสามารถเกิดขึ้นในลักษณะต่อเนื่องได้ ตัวอย่างเช่น สนามที่ใช้ในเกตเชิงควอนตัมอาจคลาดเคลื่อนไป 0.1%, 0.15% หรือเศษส่วนอื่นใด สิ่งนี้อาจส่งผลให้เฟสบนคิวบิตไม่ถูกต้อง ด้วยปริมาณต่อเนื่องใด ๆ เช่นกัน แต่คุณจะเห็นว่าในทางปฏิบัติ โดยเฉพาะในการแก้ไขข้อผิดพลาด มักมีการปฏิบัติต่อข้อผิดพลาดราวกับว่าเป็นแบบไม่ต่อเนื่อง โดยการจัดกลุ่มผลกระทบที่สะสมให้เป็นการพลิกบิตแบบไม่ต่อเนื่องหรือการหมุนเฟสเพียงครั้งเดียว วิธีนี้มีประโยชน์สำหรับการแก้ไขข้อผิดพลาดและการกำหนดลักษณะของมัน แต่ไม่ได้หมายความว่าผลกระทบของสัญญาณรบกวนต่อคิวบิตจะเป็นเพียงชุดข้อผิดพลาดแบบไม่ต่อเนื่องเท่านั้น

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

Thermal:

สถานะฐานเชิงคำนวณสองสถานะ $|0\rangle$ และ $|1\rangle$ ของคิวบิตถูกแยกจากกันด้วยปริมาณพลังงานที่น้อยมาก ค่าที่แน่นอนขึ้นอยู่กับฮาร์ดแวร์เชิงควอนตัมแน่นอน สำหรับคิวบิตแบบโซลิดสเตต (transmon ความถี่คงที่) เช่นที่ใช้โดย IBM Quantum® ช่องว่างพลังงานระหว่างสถานะเหล่านี้มีขนาดประมาณ $10^{-24}$ J หรือไม่กี่ไมโครอิเล็กตรอนโวลต์ สเกลพลังงานนี้สามารถเชื่อมโยงกับความถี่ผ่าน $E=hf$ หรือกับอุณหภูมิลักษณะเฉพาะ เนื่องจากอุณหภูมิเกี่ยวข้องกับพลังงานจลน์เฉลี่ยของอนุภาคในตัวอย่าง เราสามารถใช้ค่าคงที่ Boltzmann เพื่อประมาณอุณหภูมิที่อนุภาคโดยเฉลี่ยจะมีพลังงานเพียงพอที่จะทำให้เกิดการเปลี่ยนสถานะได้:

$$E\approx k_BT \rightarrow T~E/k_B \approx 10^{-24}\text{ J } \times 1.381 \times 10^{−23}\text{ J/K}\approx 100 \text{mK}.$$

เพื่อลดโอกาสที่ปฏิสัมพันธ์เชิงความร้อนจะทำให้เกิดการเปลี่ยนสถานะจากสถานะฐานเชิงคำนวณหนึ่งของคิวบิตไปยังอีกสถานะหนึ่ง อุณหภูมิของคิวบิตต้องถูกรักษาไว้ให้ต่ำกว่า 100 mK อย่างมีนัยสำคัญ โดยควรใกล้เคียงกับ 15-25 mK การเพิ่มขึ้นของอุณหภูมิอย่างมีนัยสำคัญเหนือเกณฑ์เหล่านี้จะส่งผลให้การครอบครองสถานะเป็นแบบสุ่มโดยสิ้นเชิงและสูญเสียข้อมูลเชิงควอนตัมทั้งหมด

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

การรบกวนข้ามสายและการแทรกสอด:

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

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

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

การดำเนินการเกตที่ไม่สมบูรณ์แบบ:

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

สัญญาณรบกวนที่มีอยู่ในตัวเชิงควอนตัม:

สัญญาณรบกวนประเภทสุดท้ายนี้แตกต่างจากประเภทอื่นอย่างมาก มันไม่ได้เกิดจากข้อผิดพลาด แต่เกิดจากธรรมชาติของกลศาสตร์ควอนตัม สมมติว่าคิวบิตในสถานะเชิงควอนตัม $|\psi\rangle$ ถูกวัดและยุบตัวลงสู่สถานะไอเกน ($|0\rangle$ หรือ $|1\rangle$) ในระบบ transmon ความถี่คงที่ คิวบิตจะถูกเชื่อมต่อแบบ dispersive กับเรโซเนเตอร์ไมโครเวฟที่ความถี่เรโซแนนซ์ขึ้นอยู่กับสถานะของคิวบิตเล็กน้อย พัลส์ตรวจสอบไมโครเวฟถูกส่งผ่านเรโซเนเตอร์ และสัญญาณขาออกจะได้รับการเปลี่ยนเฟสและการเปลี่ยนแปลงแอมพลิจูดที่ขึ้นกับสถานะ จากนั้นสัญญาณนี้จะถูกขยายและวัดโดยใช้อุปกรณ์อิเล็กทรอนิกส์แบบคลาสสิก

ในระดับควอนตัม สัญญาณการวัดถูกส่งผ่านโดยสนามไมโครเวฟแบบโคฮีเรนต์ที่มีจำนวนโฟตอนเฉลี่ยจำกัด เนื่องจากธรรมชาติเชิงควอนตัมของสนามแม่เหล็กไฟฟ้า ควอดราเจอร์ของสนามจึงแสดงความผันผวนที่มีอยู่ในตัว ความผันผวนเหล่านี้เป็นอิสระจากความไม่สมบูรณ์แบบทางเทคนิค และเกิดขึ้นแม้ในสถานะโคฮีเรนต์ในอุดมคติ การเพิ่มจำนวนโฟตอนเฉลี่ย $N$ จะเพิ่มสัญญาณการวัด แต่ระดับสัญญาณรบกวนพื้นฐานยังคงมีค่าจำกัด ดังนั้นความสามารถในการแยกแยะระหว่างผลลัพธ์จึงดีขึ้นเพียงในอัตรา $\sqrt{N}$​

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

ความไม่แน่นอนไม่ใช่ข้อผิดพลาด:

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

$|\psi\rangle = \frac{4}{5}|0\rangle+\frac{3}{5}|1\rangle.$

สถานะนี้มีโอกาส 64% ที่จะถูกวัดได้เป็นสถานะ $|0\rangle$ และ 36% ที่จะถูกวัดได้เป็นสถานะ $|1\rangle$ แต่การวัดเพียงครั้งเดียวจะให้ผลเป็น $|0\rangle$ หรือ $|1\rangle$ เท่านั้น — ดังนั้นการวัดครั้งเดียวจึงแทบไม่บอกอะไรมากนักเกี่ยวกับสถานะก่อนการวัด จำเป็นต้องมีการวัดหลายครั้งเพื่อให้ได้ข้อมูลที่ละเอียดเกี่ยวกับสถานะ จากการวัดสิบครั้ง เราอาจคาดหวังว่าหกหรือเจ็ดครั้งจะให้ผลเป็น $|0\rangle$ แต่ก็ไม่ใช่เรื่องน่าตกใจหากการวัดสิบครั้งแรกทั้งหมดบังเอิญให้ผลเป็น $|0\rangle$ (เหมือนการโยนเหรียญที่เที่ยงตรงแล้วได้ "หัว" สิบครั้งติดต่อกัน: ไม่บ่อยนัก แต่ก็เป็นไปได้อย่างสมเหตุสมผล) หากเราทำการวัดซ้ำ 1000 ครั้งแล้วได้ผลเป็น $|0\rangle$ เสมอ นั่นถึงจะน่าตกใจจริง ๆ

ดังนั้นจึงมีความไม่แน่นอนในความรู้ของเราเกี่ยวกับสถานะเชิงควอนตัมโดยอาศัยจำนวนการวัดที่จำกัดใด ๆ เมื่อเราทำการวัดซ้ำ ความรู้ของเราเกี่ยวกับสถานะเชิงควอนตัมก่อนการวัดจะดีขึ้น แต่จะไม่มีวันสมบูรณ์แบบ อาจกล่าวได้อย่างไม่เป็นทางการว่ามักมี "ข้อผิดพลาด" แฝงอยู่เสมอในผลการวัดเชิงควอนตัมใด ๆ แต่นี่เป็นการใช้คำว่า "ข้อผิดพลาด" ในความหมายที่ต่างออกไป และควรถูกอธิบายว่าเป็นความไม่แน่นอนเชิงสถิติมากกว่า กระบวนการเพิ่มความรู้เกี่ยวกับสถานะเชิงควอนตัมผ่านการวัดหลายครั้งเรียกว่า quantum state tomography อย่างไรก็ตาม quantum state tomography ไม่ได้จำกัดอยู่เพียงการวัดตามแกน Z เท่านั้น โดยทั่วไปหมายถึงการวัดตามแกนที่ตั้งฉากกัน (เช่น X, Y และ Z) เพื่อกำหนดแอมพลิจูดและเฟสสัมพัทธ์ สำหรับข้อมูลเพิ่มเติมเกี่ยวกับกระบวนการนี้ ดูหัวข้อนี้ ในคอร์สของ John Watrous เรื่อง General Formulation of Quantum Information หรือสำหรับการนำไปใช้จริง ดูบทเรียนการเทเลพอร์ตนี้ ของคอร์สเรื่อง Utility-Scale Quantum Computing

การสังเกตข้อผิดพลาดและการสะสมของมัน

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

มาเริ่มต้นด้วยข้อผิดพลาดจากการคลายพลังงาน (energy relaxation) กัน

ข้อผิดพลาดจากการคลายพลังงาน ($T_1$)

จากการอภิปรายเรื่องสัญญาณรบกวนจากความร้อนก่อนหน้านี้ ที่อุณหภูมิใด ๆ ที่ไม่เป็นศูนย์ ระบบเชิงควอนตัมมีความน่าจะเป็นที่จะเปลี่ยนสถานะระหว่างสถานะไอเกนพลังงาน การคลายตัว ($|1\rangle \rightarrow |0\rangle$) เป็นตัวหลักเนื่องจากถูกขับเคลื่อนโดยการปล่อยรังสีเองตามธรรมชาติ (spontaneous emission) (ซึ่งไม่ขึ้นกับอุณหภูมิ) ในขณะที่อุณหภูมิต่ำจะกดกระบวนการกระตุ้นที่แข่งขันกันไว้ ยิ่งคิวบิตอยู่นิ่งเฉยนานเท่าใด ก็ยิ่งมีเวลามากขึ้นที่จะเกิดการเปลี่ยนสถานะดังกล่าว ความน่าจะเป็นที่คิวบิตซึ่งเตรียมไว้ในสถานะ $|1\rangle$ จะยังคงอยู่ในสถานะ $|1\rangle$ หลังจากเวลา $t$ มีค่าเป็น

$$p = e^{-t/T_1}$$

ในที่นี้ เวลา $T_1$ คือเวลาลักษณะเฉพาะที่กำหนดได้จากการทดลอง ซึ่งแตกต่างกันไปในแต่ละคิวบิต และอาจเปลี่ยนแปลงเล็กน้อยไปตามเวลาได้ คอมพิวเตอร์ควอนตัมของ IBM® ได้รับการวัดประสิทธิภาพเป็นประจำ ดังนั้นค่าเวลา $T_1$ ที่คุณพบสำหรับคิวบิตบนคอมพิวเตอร์ควอนตัมของ IBM ควรมีความแม่นยำและเป็นปัจจุบัน ค่า $T_1$ ที่มากหมายความว่าคิวบิตยังคงอยู่ในสถานะที่คุณเตรียมไว้นานขึ้น (โดยเฉลี่ย) ค่า $T_1$ โดยทั่วไปแตกต่างกันไปในแต่ละสถาปัตยกรรม คิวบิตในคอมพิวเตอร์ควอนตัมของ IBM มักมีค่าเวลา $T_1$ ในช่วง 200-300 $\mu s$ และคุณสามารถตรวจสอบค่าล่าสุดได้ที่หน้า Compute resources

เวลาลักษณะเฉพาะ $T_2$ วัดสิ่งที่แตกต่างออกไป นั่นคือการสูญเสียข้อมูลเฟส เราจะกลับมาพูดถึงเรื่องนี้ในภายหลัง

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

มาเริ่มต้นด้วยการนำเข้าแพ็กเกจบางส่วนและเลือก backend ที่มีคิวน้อยที่สุด

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"cycler": "cycler", "matplotlib": "matplotlib", "numpy": "numpy", "qiskit": "qiskit", "qiskit_aer": "qiskit-aer", "qiskit_ibm_runtime": "qiskit-ibm-runtime"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

from qiskit_ibm_runtime import QiskitRuntimeService
import numpy as np
import matplotlib.pyplot as plt

# If your credentials are already saved locally
service = QiskitRuntimeService()

# To load an unsaved instance, uncomment the line below
# service = QiskitRuntimeService(channel = "ibm_quantum_platform", instance = "your crn here")

# To select the least-busy backend:
# backend = service.least_busy(simulator=False, operational=True)

# To specify the backend by name:
backend = service.backend("ibm_boston")

props = backend.properties()
print(backend)

<IBMBackend('ibm_boston')>

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

qubit_idx = 0
qubit_props = props.qubit_property(qubit_idx)

t1 = qubit_props["T1"][0]  # * 1e6  # Convert seconds to µs
t2 = qubit_props["T2"][0]  # * 1e6  # Convert seconds to µs

# print(f"Qubit {qubit_idx}: T1={t1} µs, T2={t2} µs")
print(f"Qubit {qubit_idx}: T1={t1} s, T2={t2} s")

Qubit 0: T1=0.0002737016180018049 s, T2=0.00042784777605680494 s

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

• เวลาการสุ่มตัวอย่าง $dt$ - จังหวะนาฬิกาที่เล็กที่สุดที่กระบวนการควบคุมสามารถถูกดำเนินการได้บนคอมพิวเตอร์ควอนตัม

• เวลาเกตของคิวบิตเดี่ยว - เวลาที่ต้องใช้ในการดำเนินการเกตบนคิวบิตเดี่ยว ค่านี้จะไม่ใช่ค่าเดียว แต่เป็นช่วงของตัวเลขที่เป็นไปได้ขึ้นอยู่กับประเภทของเกต

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

มาตรวจสอบค่า $dt$ สำหรับ backend ของเรา และแสดงช่วงที่เป็นไปได้ของเวลาเกต

print(f"Using backend: {backend.name}")

# Access the backend target
target = backend.target

def get_gate_times(target, gate_name):
    results = []

    if gate_name not in target:
        return results  # gate not supported

    # target[gate_name] is a dict: {(qubits): InstructionProperties}
    for qubits, props in target[gate_name].items():
        if props.duration is not None:
            results.append({"qubits": qubits, "duration_ns": props.duration * 1e9})

    return results

# Query some gates
for gate in ["cz", "x"]:
    times = get_gate_times(target, gate)

    print(f"\nGate: {gate}")
    if times:
        for entry in times[:5]:
            print(f"  Qubits {entry['qubits']}: {entry['duration_ns']:.2f} ns")
    else:
        print("  Not available on this backend")

Using backend: ibm_boston

Gate: cz
  Qubits (0, 1): 68.00 ns
  Qubits (1, 0): 68.00 ns
  Qubits (1, 2): 68.00 ns
  Qubits (2, 1): 68.00 ns
  Qubits (2, 3): 88.00 ns

Gate: x
  Qubits (0,): 32.00 ns
  Qubits (1,): 32.00 ns
  Qubits (2,): 32.00 ns
  Qubits (3,): 32.00 ns
  Qubits (4,): 32.00 ns

เวลาเกตเหล่านี้จะแตกต่างกันไปในแต่ละ backend เราจะกำหนดค่าคงที่ของเวลาเกตสองคิวบิตที่ดึงมาจาก ibm_boston ไว้ที่ 68 ns

dt = backend.configuration().dt
two_q_gate_time = 68e-9
print("The sampling time is : ", dt)
print("dts per T_1 : ", t1 / dt)
print("2-qubit characteristic time : ", two_q_gate_time)
print("The sampling time intervals per two-qubit gate : ", two_q_gate_time / dt)
print("2-qubit gates per T_1 : ", t1 / two_q_gate_time)

The sampling time is :  4e-09
dts per T_1 :  68425.40450045122
2-qubit characteristic time :  6.8e-08
The sampling time intervals per two-qubit gate :  17.0
2-qubit gates per T_1 :  4025.0237941441897

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

เราจะเริ่มต้นด้วยการใช้ตัวจำลอง (simulator) ที่มีแบบจำลองสัญญาณรบกวน แล้วจึงเปรียบเทียบผลลัพธ์กับฮาร์ดแวร์จริง

from qiskit_aer import AerSimulator
from qiskit_aer.noise import NoiseModel, thermal_relaxation_error
from qiskit import QuantumCircuit
from qiskit.quantum_info import Pauli
from qiskit.transpiler import generate_preset_pass_manager
from qiskit_aer.primitives import EstimatorV2

pass_manager = generate_preset_pass_manager(backend=backend, optimization_level=0)

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

n_points = 50  # We will show 50 steps
delay_unit = 80  # The delay in units of two-qubit-time from above
shots = 100

เราสร้างแบบจำลองสัญญาณรบกวนสำหรับตัวจำลองของเรา ซึ่งรวมข้อผิดพลาดจากการคลายตัวเชิงความร้อนไว้อย่างชัดเจน

# Create noise model with thermal relaxation for delays
noise_model = NoiseModel()
error = thermal_relaxation_error(
    t1, t2, two_q_gate_time * delay_unit
)  # error model characterized by times in ns
noise_model.add_all_qubit_quantum_error(error, ["delay"])

sim = AerSimulator(noise_model=noise_model)

ตอนนี้เราสร้างวงจรและออบเซอร์เวเบิลของเรา สิ่งเหล่านี้เรียบง่ายเป็นพิเศษ วงจรจะประกอบด้วยเพียงการเตรียมคิวบิตในสถานะ $|1\rangle$ และการดำเนินการหน่วงเวลาที่เพิ่มขึ้นเรื่อย ๆ โดยใช้เวลาเกตลักษณะเฉพาะและ $dt$ ที่กำหนดไว้ข้างต้น ออบเซอร์เวเบิลจะเป็นเพียง $Z$ เพราะสิ่งที่เราต้องการรู้คือคิวบิตยังคงอยู่ในสถานะ $|1\rangle$ หรือคลายตัวไปเป็น $|0\rangle$ แม้ว่าการทรานสไพล์จะไม่จำเป็นเสมอไปสำหรับตัวจำลอง แต่เราจะดำเนินการทรานสไพล์วงจรของเราที่นี่เพื่อนำไปใช้ในภายหลังกับ backend จริง

observables = [Pauli("Z")] * n_points
circuits = []
obs = []
delay_times_sim = []
for i in range(n_points):
    qc = QuantumCircuit(1, 1)
    qc.x(0)
    if i > 0:
        for j in range(i):
            qc.delay(delay_unit * two_q_gate_time, 0, "s")
            j = j + 1
    qc_opt = pass_manager.run(qc)
    circuits.append(qc_opt)
    delay_times_sim.append(delay_unit * two_q_gate_time * i)
    observables_isa = observables[i].apply_layout(layout=qc_opt.layout)
    obs.append(observables_isa)

เรารันงานของเราโดยใช้ตัวจำลอง

pubs = list(zip(circuits, obs))

# Create AerSimulator with noise model as backend
simulator = AerSimulator(noise_model=noise_model)

# Create SamplerV2 from the AerSimulator backend
estimator = EstimatorV2.from_backend(simulator)

# Run the sampler on the circuit, specify shots
job = estimator.run(pubs)
result = job.result()

สุดท้ายเราพล็อตผลลัพธ์

# Optional: color palette similar to 'mpl', style = 'clifford'

from cycler import cycler

plt.rcParams["axes.prop_cycle"] = cycler(
    color=[
        "#4C78A8",  # muted blue
        "#72B7B2",  # teal
        "#54A24B",  # green
        "#9C89CC",  # purple
        "#B279A2",  # mauve
    ]
)

# Everything else stays at Matplotlib defaults

# Example data: assume result is a list of objects with structure result[i].data.evs.item()
# and delay_times is already defined as a list of floats.

# Extract y-values
y_sim_values = [(1 - r.data.evs.item()) / 2 for r in result]

# Use delay_times as x-values
x_sim_values = delay_times_sim

# Create the plot
plt.figure(figsize=(8, 5))
plt.plot(x_sim_values, y_sim_values, marker="o", linestyle="-", label="EV Data")

plt.xlabel("Idle Time (s)")
plt.ylabel("Probability of measuring |1>")
plt.title("T1 Decay")
plt.grid(True)
plt.show()

การคลายตัวแบบเอกซ์โพเนนเชียลนั้นมองเห็นได้ชัดเจน และในช่วงเวลานี้ มันคลายตัวลงเหลือเพียงต่ำกว่า 40% ที่จะอยู่ในสถานะ $|1\rangle$ โปรดสังเกตว่าสิ่งนี้สอดคล้องอย่างแม่นยำกับแบบจำลอง: $p = e^{-t/t_1}$ โดยที่เราเลือก $t$ สูงสุดให้มีอันดับเดียวกับ $t_1$ จำได้ว่าเราบอกว่า $t_1$ อาจสอดคล้องกับเกต 60 ครั้ง (หรืออันดับขนาดนั้น) และในที่นี้ $t$ สอดคล้องกับเกต 60 ครั้ง ดังนั้น

$$p \rightarrow e^{-0.25 \text{ ms}/0.267\text{ ms}} \approx 0.392$$

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

# This took 27 s on ibm_boston

from qiskit_ibm_runtime import EstimatorV2

# Explicitly use a pass manager with optimization level 0 so that we don't remove the delays
pass_manager = generate_preset_pass_manager(backend=backend, optimization_level=0)

# Use the same time parameters and shots
n_points = 10
delay_unit = 400
shots = 100

# Measure Pauli Z's as your observables
observables = [Pauli("Z")] * n_points
circuits = []
obs = []
delay_times = []
for i in range(n_points):
    qc = QuantumCircuit(1, 1)
    qc.x(0)
    if i > 0:
        qc.delay(delay_unit * two_q_gate_time * i, 0, "s")
    qc_opt = pass_manager.run(qc)
    circuits.append(qc_opt)
    delay_times.append(delay_unit * two_q_gate_time * i)
    observables_isa = observables[i].apply_layout(layout=qc_opt.layout)
    obs.append(observables_isa)

pubs = list(zip(circuits, obs))
estimator = EstimatorV2(mode=backend)
job = estimator.run(pubs=pubs)
result = job.result()

# To print the job id for later retrieval of data
# job_id = job.job_id()
# print(f"Job ID: {job_id}")

ตอนนี้เราพล็อตผลลัพธ์

fig, ax = plt.subplots()

# Convert from the expectation value of Z to the probability of a transition
y_real_values = [(1 - r.data.evs.item()) / 2 for r in result]

# Use delay_times as x-values
x_real_values = delay_times

# Exponential decay to match theoretical model
t_smooth = np.linspace(0, x_sim_values[19], 100)  # Smooth x-range covering your data
y_decay = np.exp(-t_smooth / (t1))  # y = exp(-t/t1)
ax.plot(t_smooth, y_decay, "k--", linewidth=1, label=f"Perfect Decay (t1={t1:3f} s)")

# Add simulator values
ax.scatter(x_sim_values, y_sim_values, label="Simulator", alpha=0.7)

# Add real QC values
ax.scatter(x_real_values, y_real_values, label="Real", alpha=0.7)

# Add labels and plot
ax.set_xlabel("Idle Time (s)")
ax.set_ylabel("Probability of measuring |1>")
ax.legend()
ax.set_title("T1 Decay")
ax.grid(True)

plt.show()

ดังที่เราเห็น การคลายตัวของสถานะ $|1\rangle$ ตามเวลาสอดคล้องกับทฤษฎี (และนิยามของ $T_1$) นอกจากนี้ ตัวจำลองยังทำได้ค่อนข้างดีในการจับคู่พฤติกรรมของคอมพิวเตอร์ควอนตัมจริงในกรณีนี้ นี่คือสิ่งบางอย่างที่ควรจำไว้เกี่ยวกับการคลายตัวของสถานะนี้:

• เราได้หน่วงเวลาการวัดอย่างประดิษฐ์เป็นระยะเวลาที่ไม่สมจริง การหน่วงเวลานี้สอดคล้องกับสเกลเวลาของวงจรที่ลึกมากซึ่งอาจประกอบด้วยเกตสองคิวบิตนับพัน สิ่งนี้ทำขึ้นเพียงเพื่อแสดงให้เห็นว่าผลกระทบของสัญญาณรบกวนเชิงความร้อนมีอยู่จริง ในวงจรจริงที่ประยุกต์ใช้กับปัญหาในโลกจริง การดำเนินการจะถูกทำบนคิวบิตอื่น ๆ ในขณะที่บางตัวอาจอยู่นิ่งเฉยนานพอที่ข้อผิดพลาดจากการคลายพลังงานจะมีนัยสำคัญ — แต่ข้อผิดพลาดอื่น ๆ จะครอบงำก่อนที่จะถึง $T_1$ เต็มรูปแบบ
• ยังไม่มีการใช้เทคนิคการบรรเทาหรือการระงับข้อผิดพลาดใด ๆ เราสามารถเปลี่ยนแปลงเส้นโค้งการคลายตัวนี้ได้โดยใช้เทคนิคที่เราจะเรียนรู้ในคอร์สนี้
• เราใช้เพียง 100 ช็อตในที่นี้ ซึ่งต่ำผิดปกติเพราะเราต้องการเพียงแสดงให้เห็นว่าผลกระทบนี้มีอยู่จริง ในงานประยุกต์ใช้จริง คุณมักจะใช้มากกว่า 1,000 ช็อต

การแสดงภาพข้อผิดพลาดครั้งแรกนี้แทบไม่ต้องใช้เกตใดเลยนอกจากการหน่วงเวลา (และเกต X เพียงตัวเดียวที่ใช้เตรียมสถานะ $|1\rangle$) ต่อไปให้เราดูตัวอย่างอื่นที่เน้นข้อผิดพลาดของเกต

ข้อผิดพลาดของเกตและการสะสม

เมื่อเราใช้ quantum gate หนึ่งตัว สมมติว่าเป็น $X$ gate ในทางทฤษฎีแล้ว gate นี้จะหมุนสถานะควอนตัมด้วยมุม $\pi$ เรเดียนรอบแกน $X$ บนทรงกลมบลอค (Bloch sphere) โดยแมป $\alpha |0\rangle + \beta |1\rangle$ ไปเป็น $\alpha |1\rangle + \beta |0\rangle$ ผ่านสมการ

$$\begin{aligned} X|\psi\rangle & = R_X(\pi) |\psi\rangle\\ & = \begin{pmatrix} \cos{(\theta/2)} & -i \sin{(\theta/2)} \\ -i \sin{(\theta/2)} & \cos{(\theta/2)} \end{pmatrix}\begin{pmatrix} \alpha \\ \beta \end{pmatrix}\\ & = \begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix}\begin{pmatrix} \alpha \\ \beta \end{pmatrix}\\ & =\begin{pmatrix} \beta \\ \alpha \end{pmatrix}\\ \end{aligned}$$

อย่างไรก็ตาม gate จริงนั้นไม่สมบูรณ์แบบ มันอาจมีการวางแนวที่ไม่สมบูรณ์ (ทำให้การหมุนไม่ได้อยู่รอบแกน X พอดี) หรืออาจทำให้เกิดการหมุนที่มากหรือน้อยกว่าที่ตั้งใจไว้เล็กน้อย ลองสร้างแบบจำลอง error ของ gate ว่าเป็นการหมุนเกินหรือหมุนน้อยไปด้วยมุมเล็ก ๆ $\epsilon$

$$\begin{aligned} X_\epsilon|\psi\rangle & = R_X(\pi+\epsilon) |\psi\rangle\\ & = \begin{pmatrix} \cos{(\theta+\epsilon/2)} & -i \sin{(\theta+\epsilon/2)} \\ -i \sin{(\theta+\epsilon/2)} & \cos{(\theta+\epsilon/2)} \end{pmatrix}\begin{pmatrix} \alpha \\ \beta \end{pmatrix}\\ & \approx \begin{pmatrix} \epsilon & 1-\epsilon^2/2 \\ 1-\epsilon^2/2 & \epsilon \end{pmatrix}\begin{pmatrix} \alpha \\ \beta \end{pmatrix}\\ & =\begin{pmatrix} \epsilon \alpha+(1-\epsilon^2/2)\beta \\ (1-\epsilon^2/2)\alpha+\epsilon \beta \end{pmatrix}\\ \end{aligned}$$

หาก gate ที่ไม่สมบูรณ์แบบถูกใช้ซ้ำหลายครั้ง error เล็ก ๆ $\epsilon$ ก็สามารถสะสมกันได้ บางครั้ง error หลายตัวเหล่านี้ยังทำให้สถานะเลื่อนไปในทิศทางเดียวกันทุกครั้ง (ปรากฏการณ์ที่เรียกว่า "การสะสมแบบ coherent" ซึ่งเราจะกลับมาพูดถึงอีกครั้งด้านล่าง) มาดูกันว่าจะเกิดอะไรขึ้นเมื่อเราใช้ X gate จริงกับ qubit ซ้ำหลายครั้ง

# This took 78 s on penguino1

from qiskit_ibm_runtime import EstimatorV2

# Explicitly use a pass manager with optimization level 0 so that we don't remove the delays
pass_manager = generate_preset_pass_manager(backend=backend, optimization_level=0)

# Use the same bit flips
max_depth = 60
circuits = []
observables = []

for depth in range(max_depth + 1):
    qc = QuantumCircuit(1)
    # Repeat flipping back and forth depth times
    for _ in range(depth):
        #    qc.x(0)
        qc.x(0)
        qc.barrier()
        qc.x(0)
        qc.barrier()
    circuits.append(qc)
    observables.append(Pauli("Z"))

pubs = list(zip(circuits, observables))

estimator = EstimatorV2(mode=backend)
results = estimator.run(pubs=pubs).result()
real_expectations = [pub_res.data.evs for pub_res in results]

# from qiskit_ibm_runtime import QiskitRuntimeService

# service = QiskitRuntimeService()           # uses stored IBM Quantum account
# job_id = "d5immof67pic7386l8eg"

# job = service.job(job_id)                 # retrieve the job
# results = job.result()                        # this is your .result() object

# Convert from the expectation value of Z to the probability of a transition
# y_real_values = [(1-r.data.evs.item())/2 for r in results]

# Create the plot
plt.figure(figsize=(8, 5))
# plt.plot(range(max_depth + 1), y_real_values, 'o-')
# plt.plot(x_real_values, y_real_values, marker='o', linestyle='-', color='blue', label='EV Data')
plt.plot(
    range(max_depth + 1),
    real_expectations,
    marker="o",
    linestyle="-",
    color="blue",
    label="EV Data",
)

plt.xlabel("Number of Flip-Back Cycles")
plt.ylabel("Expectation ⟨Z⟩")
plt.title("Accumulated Gate Noise Effects on Flips")
plt.grid(True)
plt.show()

ค่าคาดหวัง (expectation value) เริ่มต้นที่ประมาณ 1.0 ตามที่คาดไว้ และค่อย ๆ ลดลง แต่มันไม่ได้ลดลงไปที่ศูนย์เฉย ๆ! มันกลายเป็นค่าลบ ถ้านี่เป็นสัญญาณรบกวนจากความร้อนหรือปฏิสัมพันธ์แบบสุ่ม มันจะไม่ทำให้ $|1\rangle$ มีโอกาสถูกวัดมากกว่า $|0\rangle$ ข้อผิดพลาดนี้ชัดเจนว่าแตกต่างออกไป และมันสมเหตุสมผลในบริบทของการพูดคุยเรื่องการหมุนเกินหรือหมุนน้อยไปของเรา ถ้าคู่การหมุนแต่ละคู่ที่ควรจะหักล้างกันกลับกลายเป็นหมุนไปด้วยมุมเล็ก ๆ การทำซ้ำหลาย ๆ ครั้งเช่นนี้ก็จะค่อย ๆ ทำให้สถานะหมุนจาก $|0\rangle$ ไปทาง $|1\rangle$

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

เราสามารถตรวจสอบได้อย่างชัดเจนว่าแบบจำลอง error ของเราเข้ากับข้อมูลการทดลองได้ดีแค่ไหน โดยการสร้าง noise model ขึ้นมาโดยตรงและใช้ simulator ในแบบจำลองด้านล่างนี้ เราสร้าง error ที่สอดคล้องกับ 0.025 เรเดียนเข้าไปโดยตรง ตัวเลขนี้ไม่ใช่ตัวเลขวิเศษอะไร เราแค่ปรับค่า error ไปเรื่อย ๆ จนกว่ามันจะอธิบายการทดลองได้อย่างสมเหตุสมผล

from qiskit_aer.noise import NoiseModel, coherent_unitary_error
from qiskit_aer import AerSimulator
import numpy as np

# For your SINGLE-QUBIT test on qubit 0, just override X error specifically
noise_model = NoiseModel.from_backend(backend, gate_error=True, thermal_relaxation=True)

theta_error = 0.025  # model over-rotation error around 0.01-0.03 radians
U_over = np.array(
    [
        [np.cos(theta_error / 2), -1j * np.sin(theta_error / 2)],
        [-1j * np.sin(theta_error / 2), np.cos(theta_error / 2)],
    ]
)

unitary_error = coherent_unitary_error(U_over)
# Target ONLY qubit 0 (your circuit) - no warning!
noise_model.add_quantum_error(unitary_error, ["x"], [0])

simulator = AerSimulator(noise_model=noise_model)

WARNING: quantum error already exists for instruction "x" on qubits (0,) , appending additional error.

max_depth = 60
circuits = []
observables = []

for depth in range(max_depth + 1):
    qc = QuantumCircuit(1)
    # Repeat flipping back and forth depth times
    for _ in range(depth):
        #    qc.x(0)
        qc.x(0)
        qc.barrier()
        qc.x(0)
        qc.barrier()
    circuits.append(qc)
    observables.append(Pauli("Z"))

pubs = list(zip(circuits, observables))

estimator = EstimatorV2.from_backend(simulator)
results = estimator.run(pubs).result()
expectations = [pub_res.data.evs for pub_res in results]  # no [0], use value directly

ตอนนี้เราสามารถพล็อตกราฟจากข้อมูลจริงและจากการจำลองไว้ด้วยกันได้

fig, ax = plt.subplots()

# Add simulator values
ax.scatter(range(max_depth + 1), expectations, c="blue", label="Simulator", alpha=0.7)

# Add real QC values
ax.scatter(range(max_depth + 1), real_expectations, c="red", label="Real", alpha=0.7)

# Add labels and plot
ax.set_xlabel("Number of Flip-Back Cycles")
ax.set_ylabel("Expectation ⟨Z⟩")
ax.set_title("Accumulated Gate Noise Effects on Flips")
ax.legend()
ax.grid(True)

plt.show()

error ใน circuit จริงถูกอธิบายได้ค่อนข้างดีด้วยแบบจำลอง error แบบหมุนเกินหรือหมุนน้อยไป เห็นได้ชัดว่า noise และ error ประเภทต่าง ๆ จะสะสมตัวแตกต่างกัน และส่งผลให้เกิดผลกระทบที่แตกต่างกันอย่างมากต่อ fidelity ของ quantum circuit ของเรา ดังนั้นจึงเป็นเรื่องสำคัญมากที่จะต้องจัดหมวดหมู่และระบุลักษณะของ error ที่อาจเกิดขึ้นอย่างเป็นทางการมากกว่าที่เราทำมาจนถึงตอนนี้

การระบุลักษณะของ quantum error

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

ความแตกต่างที่สำคัญอีกอย่างหนึ่งคือ error นั้นเป็นแบบ coherent หรือ incoherent สรุปสั้น ๆ (เราจะพูดถึงรายละเอียดเพิ่มเติมด้านล่าง) coherent error มักถูกจำลองด้วย unitary operation และรักษาความบริสุทธิ์ (purity) ของสถานะไว้ ส่วน incoherent error ถูกจำลองด้วย quantum channel แบบ non-unitary และโดยทั่วไปจะลดความบริสุทธิ์ของสถานะลง เราสามารถจินตนาการ incoherent error ได้ง่าย ๆ ว่าเป็นปฏิสัมพันธ์เชิงความร้อนที่ทำให้เกิดการสูญเสียข้อมูลควอนตัม แต่จริง ๆ แล้วมันอาจเกิดจากการเชื่อมต่อแบบสุ่มกับสิ่งแวดล้อมแบบใดก็ได้ ตัวอย่างของ coherent error เช่น สมมติว่ามีความไม่สมบูรณ์ในทิศทางของพัลส์ในการทำ RY gate จนทำให้ $RY(\theta)$ gate กลายเป็น $RY(\theta) \cdot RX(\epsilon)$ จริง ๆ ความไม่สมบูรณ์แบบนี้จะทำให้เกิดการหมุนรอบแกน X ที่ผิดพลาดไปในทิศทางเดียวกันเสมอ นี่จะถือเป็น coherent error

โปรดสังเกตว่า SPAM error ประกอบด้วยทั้ง coherent error ผสมกัน เช่น ความผิดพลาดของการควบคุมแบบเป็นระบบ (systematic control faults) และ incoherent error เช่น การสูญเสียโฟตอนและผลกระทบเชิงความร้อน เนื่องจากสิ่งนี้เกี่ยวข้องกับหลายขั้นตอนและหลายแหล่งที่มาของ error จึงอธิบาย SPAM error ได้ดีที่สุดว่าเป็นการรวมกันของทั้ง coherent error และ incoherent error

SPAM error

ตามชื่อที่บ่งบอก SPAM error เกิดขึ้นในสองขั้นตอนที่แตกต่างกันของการทดลองควอนตัม ได้แก่ การเตรียมสถานะเริ่มต้นและการอ่านค่า/วัดผล error จากการเตรียมสถานะเกิดขึ้นเมื่อฮาร์ดแวร์ไม่สามารถ initialize qubit ให้อยู่ในสถานะเริ่มต้นที่ต้องการได้อย่างน่าเชื่อถือ ($|0\rangle$ สำหรับคอมพิวเตอร์ควอนตัมของ IBM) สาเหตุได้แก่:

• การกระตุ้นด้วยความร้อน (thermal excitation) (qubit จริงไม่ได้ถูกทำให้เย็นอย่างสมบูรณ์แบบ และบางครั้งอาจเริ่มต้นที่ $|1\rangle$ แทนที่จะเป็น $|0\rangle$)
• โฟตอนหรือ noise ที่หลงเหลืออยู่ใน resonator ของ superconducting qubit
• การเลื่อนไหลของการปรับเทียบ (calibration drift) ที่ส่งผลต่อความแม่นยำในการรีเซ็ต qubit

ข้อผิดพลาดจากการวัดเกิดขึ้นระหว่างกระบวนการอ่านค่า เมื่อเครื่องมือวัดระบุสถานะของคิวบิตผิดพลาด แหล่งที่มาได้แก่:

• noise จาก readout amplifier ที่ทำให้เกิดความสับสนระหว่าง $|0\rangle$ และ $|1\rangle$

• การ relax ของ qubit ระหว่างการอ่านค่า (ตัวอย่างเช่น qubit ที่อยู่ใน $|1\rangle$ สลายตัวไปเป็น $|0\rangle$ ก่อนหรือระหว่างการวัด)

• crosstalk ระหว่างสายอ่านค่า (readout lines): การอ่านค่า qubit ตัวหนึ่งมีอิทธิพลเล็กน้อยต่อการอ่านค่า qubit ข้างเคียง

• threshold การแยกแยะ (discrimination) ที่ไม่สมบูรณ์แบบในระบบวัดผลแบบใช้ resonator ของ IBM

SPAM error ส่วนใหญ่เป็นแบบ incoherent error จากการเตรียมสถานะทำงานเหมือนกับส่วนผสมแบบสุ่มของสถานะกระตุ้น (excited state) และสถานะพื้น (ground state) error จากการวัดมีพฤติกรรมเหมือนความสับสนแบบคลาสสิก: ด้วยความน่าจะเป็น $p$ สถานะ $|0\rangle$ ถูกรายงานว่าเป็น $|1\rangle$ หรือในทางกลับกัน สิ่งเหล่านี้แตกต่างจาก coherent unitary error (เช่น gate ที่ปรับเทียบผิดพลาดจนทำให้เกิดการเลื่อนเฟสแบบเป็นระบบ) SPAM error กลับมีลักษณะคล้ายกับ noise แบบคลาสสิกที่สุ่ม แม้ว่าจะมี bias แบบ coherent ที่หายากในการอ่านค่าเกิดขึ้นได้บ้าง

SPAM error อาจก่อปัญหาสำหรับ randomized benchmarking หรือสำหรับ circuit ที่มีความลึกน้อย ซึ่งการเตรียมสถานะและการวัดคิดเป็นสัดส่วนใหญ่ของ error ทั้งหมด ปัญหานี้จะมีผลน้อยลงสำหรับ circuit ที่มีความลึกมาก โดยเฉพาะ circuit ที่มี two-qubit gate จำนวนมาก

ในทางคณิตศาสตร์ ข้อผิดพลาด SPAM สามารถอธิบายได้ว่าเป็นสิ่งที่ก่อให้เกิดการแจกแจง (distribution) ที่มีสัญญาณรบกวน $\vec{p}_\text{noisy}$ ซึ่งสัมพันธ์กับการแจกแจงในอุดมคติ $\vec{p}_\text{ideal}$ ผ่านเมทริกซ์ $A$:

$$\vec{p}_\text{noisy} = A \vec{p}_\text{ideal}$$

ในที่นี้ $p_i$ คือความน่าจะเป็นของการวัดได้ bitstring $i$ และ $A_{ij}$ คือความน่าจะเป็นที่จะได้สถานะ $j$ เมื่อสถานะควรถูกเตรียมไว้เป็นสถานะ $i$ ลองนึกภาพในบริบทของ bitstring ที่สุ่มตัวอย่างมาจาก Sampler การแจกแจงสถานะที่วัดได้ของคุณจะประกอบด้วยการวัดที่แม่นยำจำนวนมาก แต่ก็มีการวัดบางส่วนที่คำสั่งสำหรับการเตรียมสถานะไม่ตรงกับสถานะที่สังเกตได้ ซึ่งหมายความว่าความน่าจะเป็นจะคลาดเคลื่อนไปเล็กน้อย

ในรูปด้านบน ส่วน (a) แสดงการแจกแจงในอุดมคติของสถานะ GHZ ด้วยสีเขียวอมฟ้า (teal) และการวัดจริงด้วยสีม่วง ในส่วน (b) เราเห็นตัวอย่างของเมทริกซ์ $A$ สังเกตว่าเมทริกซ์นี้ไม่ได้สมมาตรอย่างสมบูรณ์รอบแนวทแยง เนื่องจาก qubit แต่ละตัวไม่จำเป็นต้องมีโอกาสคืนค่า 0 ผิดพลาดและคืนค่า 1 ผิดพลาดเท่ากัน ในทางปฏิบัติ มักเป็นเรื่องยากที่จะแยก error จากการเตรียมสถานะและ error จากการอ่านค่าออกจากกัน จึงมักถูกรวมเข้าด้วยกันในการพิจารณาแบบเดียว (นี่จึงเป็นเหตุผลที่นิยมใช้คำว่า SPAM)

วิธีหนึ่งในการแก้ไข SPAM error เหล่านี้คือการใช้ circuit ง่าย ๆ ที่รู้ผลลัพธ์การวัดในอุดมคติอยู่แล้ว แล้วนำไปเปรียบเทียบกับผลลัพธ์ที่วัดได้จริงเมื่อมี SPAM error อยู่ วิธีนี้สามารถใช้ reverse-engineer ผลลัพธ์ในอุดมคติของ circuit ที่ซับซ้อนกว่าได้ สำหรับสถานะที่มีเอนโทรปีสูงโดยทั่วไป วิธีนี้อาจต้องสร้างเมทริกซ์ที่มีความน่าจะเป็นขนาด $2^N\times2^N$ แต่ในกรณีที่ไม่สุดโต่งมากนัก error เหล่านี้ก็สามารถบรรเทาได้

Coherent error เทียบกับ incoherent error

Coherent error คือการหมุนสถานะควอนตัมที่ผิดพลาดแบบเป็นระบบ (systematic) กำหนดแน่นอน (deterministic) และเป็น unitary มันเกิดจาก quantum operation ที่ไม่สมบูรณ์แบบซึ่งเบี่ยงเบนไปในลักษณะที่คาดเดาได้ ตัวอย่างเช่น error เล็กน้อยในการหมุนที่เกิดจาก single-qubit rotation gate รวมถึง error ที่เกิดจาก calibration drift ซึ่งจะทำให้เกิดการหมุนเกินหรือหมุนน้อยไปอย่างสม่ำเสมอ ในทางคณิตศาสตร์ เราสามารถเขียนได้ว่า rotation gate จริง เช่น $\tilde{R_X}(\theta)$ เท่ากับ rotation gate ในอุดมคติบวกกับ error เพิ่มเติมบางอย่าง:

$$\tilde{R_X}(\theta) = R_X(\theta + \epsilon)$$

สำหรับการหมุนน้อยไปหรือหมุนเกินเล็กน้อย $\epsilon$ ค่าหนึ่ง ตัวอย่างอื่น ๆ ได้แก่ two-qubit gate ที่เพิ่มการเลื่อนเฟส (phase shift) เล็กน้อยที่ไม่ต้องการเข้ามา และพัลส์ควบคุมที่เบี่ยงเบนไปจากรูปร่างในอุดมคติแบบเป็นระบบ

คุณลักษณะสำคัญของ coherent error คือมันมีความแน่นอน (deterministic) และสามารถจำลองได้ด้วย unitary gate เอง ด้วยเหตุนี้มันจึงรักษาความบริสุทธิ์ของสถานะควอนตัมไว้ได้: ข้อมูลควอนตัมไม่ได้สูญหายไป เพียงแต่ถูกประมวลผลอย่างไม่สมบูรณ์แบบเท่านั้น อีกจุดสำคัญที่ควรสังเกตคือ coherent error ที่เกิดซ้ำ ๆ จะแทรกสอด (interfere) กันแบบเสริมกัน (constructively) และบางครั้งเติบโตแบบกำลังสองตามจำนวน gate

error เหล่านี้บางครั้งสามารถคาดเดาได้ จึงสามารถปรับเทียบ (calibrate) เพื่อกำจัดออกไปได้ในระดับหนึ่ง แต่ coherent error ที่ยังหลงเหลืออยู่อาจสะสมตัวอย่างรวดเร็ว ทำให้เกิดการเบี่ยงเบนจากสถานะในอุดมคติที่เป็นปัญหา ซึ่งหมายความว่าบางครั้งการจงใจ "ทำให้เป็นสุ่ม" (randomize) coherent error ก็มีข้อดี ขั้นตอนนี้และประโยชน์ของมันจะถูกกล่าวถึงในบทเรียนเรื่อง error mitigation

ทำไมมันถึงเป็นปัญหา

coherent error สามารถ "สะสมพอกพูน" ในรูปแบบที่เป็นอันตราย ทำให้เกิดการเบี่ยงเบนขนาดใหญ่จากสถานะที่ถูกต้อง หากไม่ถูกทำให้เป็นสุ่มหรือแก้ไข

Incoherent error เป็นแบบสุ่ม (stochastic) ไม่แน่นอน และมักเป็น non-unitary มันเกิดจากปฏิสัมพันธ์กับสิ่งแวดล้อมหรือแหล่ง noise ที่ควบคุมไม่ได้ เราได้เห็นตัวอย่างมาบ้างแล้ว: การ relax ของพลังงาน / การสลายตัวแบบ $T_1$ เป็น incoherent เช่นเดียวกับ noise ของ gate แบบสุ่ม thermal noise และ error จากการวัด

คุณลักษณะสำคัญของ incoherent error คือมันไม่เหมือนกันทุกครั้งที่มีการดำเนิน operation มันเป็น non-unitary ดังนั้นจึงไม่สามารถจำลองด้วย unitary quantum gate ง่าย ๆ เหมือนกับที่ coherent error ทำได้ เนื่องจากมันเป็น incoherent มันจึงมักสะสมตัวแบบเชิงเส้น (linear) เหมือน noise แบบสุ่ม ไม่เหมือนกับการหมุนเกินแบบสม่ำเสมอ

incoherent error ทำให้ qubit สูญเสียข้อมูลอย่างไม่สามารถย้อนกลับได้ (สูญเสียความบริสุทธิ์และข้อมูลเฟส)

แล้วแบบไหนแย่กว่ากัน? เหมือนกับเรื่องส่วนใหญ่ในการคอมพิวเตอร์ควอนตัม คำตอบคือ "ขึ้นอยู่กับสถานการณ์" ประเด็นสำคัญคือ coherent error สะสมตัวเร็วกว่าและแบบไม่เชิงเส้น (ซึ่งไม่ดี) แต่มันสามารถถูกปรับเทียบออกไปได้บางส่วน และข้อมูลเฟสยังคงอยู่ในระบบของคุณ หากคุณสามารถหาวิธีดึงมันออกมาได้อย่างถูกต้อง incoherent error สะสมตัวแบบเชิงเส้น ซึ่งเป็นข้อดีด้วยเหตุผลสองประการ คือมันช้ากว่าการสะสมแบบ coherent และค่อนข้างง่ายที่จะเห็นว่าผลกระทบของ incoherent error ปรับสเกลอย่างไรสำหรับกระบวนการอย่าง zero-noise extrapolation (ZNE) ซึ่งจะถูกกล่าวถึงในบทเรียนเรื่อง error mitigation อย่างไรก็ตาม เมื่อ incoherent error เกิดขึ้น ข้อมูลควอนตัมจะสูญหายไปจริง ๆ ไม่ใช่แค่ถูกบดบังเท่านั้น

Density matrix และ quantum channel

ในหัวข้อถัดไป เราจะเจาะลึกเข้าไปในประเภทต่าง ๆ ของ coherent error และ incoherent error เพิ่มเติม และดูว่าสามารถจำลองมันในทางคณิตศาสตร์ได้อย่างไรโดยใช้ quantum channel ก่อนอื่น มาทบทวนสั้น ๆ เกี่ยวกับ density matrix และ quantum channel กันก่อน สำหรับการอธิบายอย่างเข้มงวดและครบถ้วน โปรดดูคอร์สของ John Watrous เรื่อง General formulation of quantum information บน IBM Quantum Learning การอธิบายในที่นี้จะเน้นตัวอย่างเป็นหลักและไม่เป็นทางการมากนัก

Quantum channel คือวิธีที่ทั่วไปที่สุดในการอธิบายว่าระบบควอนตัมวิวัฒนาการ ปฏิสัมพันธ์ และเกิด noise ได้อย่างไร ถ้าคุณคุ้นเคยกับ pure state และ unitary evolution แล้ว quantum channel ก็เป็นขั้นถัดไปที่เป็นธรรมชาติ

ในกลศาสตร์ควอนตัมมาตรฐาน สถานะ "บริสุทธิ์" เขียนแทนด้วย $|\psi\rangle$ ในที่นี้ "บริสุทธิ์" หมายถึงความบริสุทธิ์ของข้อมูลหรือความรู้เกี่ยวกับการเตรียมสถานะนั้น ไม่ได้ หมายถึงสถานะไอเกนของระบบใดระบบหนึ่ง ตัวอย่างเช่นสำหรับคิวบิตตัวหนึ่ง $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ เป็นสถานะบริสุทธิ์ เพราะเรามีความรู้ที่สมบูรณ์เกี่ยวกับแอมพลิจูดสัมพัทธ์และเฟส วิวัฒนาการตามเวลาของสถานะบริสุทธิ์เช่นนี้ถูกกำหนดโดยตัวดำเนินการยูนิทารี $U$:

$$|\psi\rangle \rightarrow U|\psi\rangle$$

ตามสมการชเรอดิงเงอร์ (Schr"odinger equation) ซึ่ง $U = e^{-iHt/\hbar}$ โดย $H$ คือแฮมิลโทเนียนของระบบ และ $\hbar$ คือค่าคงที่พลังค์แบบลดรูป (reduced Planck's constant) ซึ่งมักถูก "กำหนดให้เท่ากับหนึ่ง" หรือกล่าวอย่างเข้มงวดกว่านั้นคือถูกรวมเข้าไปในแฮมิลโทเนียน เพื่อให้พลังงานทั้งหมดถูกกำหนดในหน่วยของ $\hbar$

unitary evolution เป็นแบบย้อนกลับได้ (reversible) กำหนดแน่นอน (deterministic) และแยกโดด (isolated) แต่สิ่งนี้ไม่เพียงพอที่จะอธิบายระบบควอนตัมจริง ในระบบควอนตัมจริง:

• เราทำการวัด ซึ่งทำให้สถานะควอนตัม collapse ไปเป็น eigenstate ของระบบ นี่เป็น non-unitary อย่างชัดเจน
• ระบบมีปฏิสัมพันธ์กับสิ่งแวดล้อม นั่นหมายความว่าระบบไม่ได้แยกโดดอย่างแท้จริง และเนื่องจากไม่สามารถติดตามสิ่งแวดล้อมได้อย่างไม่มีที่สิ้นสุด จึงสอดคล้องกับการสูญเสียข้อมูล
• พูดในเชิงปฏิบัติ: noise ทำให้สถานะเสียหาย และอื่น ๆ อีก

วิวัฒนาการแบบยูนิทารีเพียงอย่างเดียวไม่สามารถอธิบายกระบวนการเหล่านี้ได้ ดังนั้นเราจึงต้องการการแทนค่าที่เป็นทั่วไปมากขึ้นสำหรับสถานะและกระบวนการควอนตัม สถานะผสมอธิบาย การแจกแจงแบบคลาสสิก ของสถานะควอนตัม นั่นคือ เราคุ้นเคยกับข้อเท็จจริงที่ว่าสถานะควอนตัม: $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ มีโอกาส 50% ที่จะถูก วัด (ยุบตัวไปเป็นข้อมูลแบบคลาสสิก) ในสถานะ $|0\rangle$ และมีโอกาส 50% ที่จะถูกวัดได้ $|1\rangle$ แต่ข้ออ้างในที่นี้คือสถานะควอนตัมเริ่มต้นคือ $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ อย่างแน่นอนด้วยความน่าจะเป็น 100% ตอนนี้เราต้องการเพิ่มความน่าจะเป็นแบบคลาสสิกเข้าไปบนความน่าจะเป็นเชิงกลศาสตร์ควอนตัม ตัวอย่างเช่น:

สถานะควอนตัมเริ่มต้นถูกเตรียมไว้ในสถานะ $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ ด้วยความน่าจะเป็นแบบคลาสสิก 25% และถูกเตรียมไว้ในสถานะ $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle-i|1\rangle)$ ด้วยความน่าจะเป็นแบบคลาสสิก 75% (สังเกตเฟสสัมพัทธ์ที่ต่างกัน)

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

mixed state ถูกอธิบายด้วย density operator:

$$\rho = \sum_i p_i |\psi_i\rangle\langle\psi_i|.$$

ในที่นี้ $|\psi_i\rangle$ คือสถานะควอนตัม (ไม่จำเป็นต้องเป็น eigenstate ของ operator ใดโดยเฉพาะ) และ $p_i$ คือความน่าจะเป็นแบบคลาสสิกที่ระบบจะถูกเตรียมไว้ในสถานะ $|\psi_i\rangle$ นี่เป็นวิธีที่ดีในการสร้าง density matrix จากการแจกแจงแบบคลาสสิกของสถานะควอนตัมที่ทราบอยู่แล้ว ในทางกลับกัน เราอาจต้องการทราบว่า เมื่อมีทั้งการแจกแจงแบบคลาสสิกของสถานะควอนตัมและความน่าจะเป็นเชิงกลศาสตร์ควอนตัมของผลลัพธ์การวัดที่แตกต่างกัน ความน่าจะเป็นที่การวัดจะให้สถานะใดสถานะหนึ่งโดยเฉพาะ (เช่น $|0\rangle$ หรือ $|1\rangle$ หรือสถานะอื่น ๆ เมื่อมี qubit มากขึ้น) คืออะไร นี่คือจุดที่ density matrix มีประโยชน์เป็นพิเศษ เรายังสามารถเขียนมันในเบซิส $\{|i\rangle\}$ ได้ดังนี้:

$$\rho = \sum_{i,j} \rho_{ij} |i\rangle\langle j|.$$

ในที่นี้สมาชิกแนวทแยง $\rho_{ii}$​ คือความน่าจะเป็น:

• $\rho_{00}$​ = ความน่าจะเป็นที่ qubit อยู่ในสถานะ $|0\rangle$

• $\rho_{11}$​ = ความน่าจะเป็นที่ qubit อยู่ในสถานะ $|1\rangle$

ค่าเหล่านี้เป็นจำนวนจริง ไม่เป็นลบ และรวมกันได้เท่ากับ 1

สมาชิกนอกแนวทแยง $\rho_{ij}, i \neq j$ คือ coherence: ความสัมพันธ์เชิงเฟสหรือความสามารถในการแทรกสอด (interference) และโดยทั่วไปสอดคล้องกับปริมาณข้อมูลเชิงกลศาสตร์ควอนตัมที่มีอยู่ในสถานะ นี่เป็นข้อความแบบไม่เป็นทางการ แต่มาดูกันว่ามันหมายความว่าอย่างไรในทางปฏิบัติ

ตัวอย่าง

พิจารณา pure state $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ (a) คุณรู้อะไรบ้างเกี่ยวกับความน่าจะเป็นของการวัดและข้อมูลเฟส โดยไม่ต้องคำนวณใด ๆ? (b) สร้าง density matrix และตรวจสอบสัญชาตญาณของคุณ

Solution:

(a) เนื่องจากมันเป็น pure state จึงมีเฟสที่เป็นไปได้เพียงค่าเดียวระหว่าง $|0\rangle$ และ $|1\rangle$ นั่นคือ +1 นี่คือข้อมูลเฟสที่สมบูรณ์แบบ ดังนั้นเราจึงคาดว่าสมาชิกนอกแนวทแยงใน density matrix ของเราจะมีค่ามาก คุณอาจมีสัญชาตญาณมากกว่านั้นเกี่ยวกับสมาชิกนอกแนวทแยง แต่เท่านี้ก็เพียงพอแล้วในตอนนี้ นอกจากนี้ แอมพลิจูดของสถานะเบซิสทั้งสองเท่ากัน ดังนั้นเราจึงคาดว่าจะมีความน่าจะเป็น 50% ในการวัดได้ทั้ง $|0\rangle$ หรือ $|1\rangle$ ดังนั้นเราจึงคาดว่าค่าในแนวทแยงจะเท่ากับ 1/2 (b) โดยใช้นิยามด้านบน:

$$\rho = \sum_i p_i |\psi_i\rangle\langle\psi_i|.$$

$p_i \neq 0$ เฉพาะสำหรับสถานะ $|\psi\rangle$ เท่านั้น ดังนั้นเราจึงเขียนได้ว่า

$$\begin{aligned} \rho & = 1 |\psi\rangle\langle\psi| \\ & = \frac{1}{2}(|0\rangle+|1\rangle)(\langle0|+\langle1|)\\ & =\frac{1}{2}\begin{pmatrix} 1 & 1 \\ 1 & 1\end{pmatrix}. \end{aligned}$$

ค่าในแนวทแยงแต่ละตัวเท่ากับ $1/2$ ตามที่คาดไว้ และสมาชิกนอกแนวทแยงมีค่ามาก (รวมกันได้หนึ่ง)

ทีนี้มาดูกันว่าจะเกิดอะไรขึ้นเมื่อเราไม่มีข้อมูลเฟสที่ดี

ตัวอย่าง

พิจารณากรณีที่คล้ายกัน แต่คราวนี้มีความน่าจะเป็นแบบคลาสสิก 50% ที่จะอยู่ในสถานะ $|\psi_+\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ และความน่าจะเป็นแบบคลาสสิก 50% ที่จะอยู่ในสถานะ $|\psi_-\rangle = \frac{1}{\sqrt{2}}(|0\rangle-|1\rangle)$ คำถามสองข้อเดิม: (a) คุณรู้อะไรบ้างเกี่ยวกับความน่าจะเป็นของการวัดและข้อมูลเฟส โดยไม่ต้องคำนวณใด ๆ? (b) สร้าง density matrix และตรวจสอบสัญชาตญาณของคุณ

Solution:

(a) เช่นเดียวกับก่อนหน้านี้ แอมพลิจูดของสถานะเบซิสทั้งสองเท่ากัน ดังนั้นเราจึงคาดว่าจะมีความน่าจะเป็น 50% ในการวัดได้ทั้ง $|0\rangle$ หรือ $|1\rangle$ ดังนั้นเราจึงคาดว่าค่าในแนวทแยงจะเท่ากับ 1/2 แต่คราวนี้มีความเป็นไปได้ที่ตรงข้ามกันสองแบบสำหรับเฟสระหว่าง $|0\rangle$ และ $|1\rangle$ นั่นคือ +1 และ -1 และแต่ละแบบมีโอกาสเท่ากัน เราอาจคาดได้ว่าเมื่อมีเฟสตรงข้ามกันสองแบบที่มีโอกาสเท่ากัน เราจะมีข้อมูลเฟสน้อยมากหรือแทบไม่มีเลย เราอาจคาดว่าสมาชิกนอกแนวทแยงจะมีค่าน้อย (b) ใช้นิยามด้านบนอีกครั้ง

$$\rho = \sum_i p_i |\psi_i\rangle\langle\psi_i|.$$

$p_i \neq 0$ เฉพาะสำหรับสถานะสองสถานะคือ $|\psi_+\rangle$ และ $|\psi_-\rangle$ เท่านั้น ดังนั้นเราจึงเขียนได้ว่า

$$\begin{aligned} \rho & = \frac{1}{2} |\psi_+\rangle\langle\psi_+| + \frac{1}{2}|\psi_-\rangle\langle\psi_-| \\ & = \frac{1}{4}(|0\rangle+|1\rangle)(\langle0|+\langle1|)+\frac{1}{4}(|0\rangle-|1\rangle)(\langle0|-\langle1|)\\ & =\frac{1}{4}\begin{pmatrix} 1 & 1 \\ 1 & 1\end{pmatrix}+\frac{1}{4}\begin{pmatrix} 1 & -1 \\ -1 & 1\end{pmatrix}\\ & =\frac{1}{2}\begin{pmatrix} 1 & 0 \\ 0 & 1\end{pmatrix}. \end{aligned}$$

สมาชิกนอกแนวทแยงมีค่าน้อย ที่จริงแล้วเป็นศูนย์ ตามที่คาดไว้ สมาชิกในแนวทแยงยังคงเป็น 50% แต่ละตัว ซึ่งสมเหตุสมผลเพราะแต่ละสถานะในส่วนผสมนี้มี $|0\rangle$ และ $|1\rangle$ ที่มีน้ำหนักเท่ากัน

โครงสร้างนี้จะน่าสนใจมากขึ้นเมื่อจำนวน qubit เพิ่มขึ้น ลองสำรวจดูในคำถามด้านล่าง

ตรวจสอบความเข้าใจของคุณ

จงเขียน density matrix สำหรับ pure Bell state $|\Phi_+\rangle = \frac{1}{\sqrt{2}}(|00\rangle+|11\rangle)$

คำตอบ

$$\rho = \sum_i p_i |\psi_i\rangle\langle\psi_i|.$$

$p_i \neq 0$ เฉพาะสำหรับสถานะ $|\Phi_+\rangle$ เท่านั้น ดังนั้นเราจึงเขียนได้ว่า

$$\begin{aligned} \rho & = 1 |\Phi_+\rangle\langle\Phi_+| \\ & = \frac{1}{2}(|00\rangle+|11\rangle)(\langle00|+\langle11|)\\ & =\frac{1}{2}\begin{pmatrix} 1 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 \\ 1 & 0 & 0 & 1 \end{pmatrix}. \end{aligned}$$

จงเขียน density matrix สำหรับความน่าจะเป็นแบบคลาสสิก 25% ของ $|\Phi_\text{+}\rangle = \frac{1}{\sqrt{2}}(|00\rangle+|11\rangle)$ และความน่าจะเป็นแบบคลาสสิก 75% ของ $|\Psi_\text{-}\rangle = \frac{1}{\sqrt{2}}(|01\rangle-|10\rangle)$

คำตอบ

$$\rho = \sum_i p_i |\psi_i\rangle\langle\psi_i|.$$

$p_i \neq 0$ เฉพาะสำหรับสถานะสองสถานะคือ $|\Phi_+\rangle$ และ $|\Psi_-\rangle$ เท่านั้น ดังนั้นเราจึงเขียนได้ว่า

$$\begin{aligned} \rho & = \frac{1}{4} |\Phi_+\rangle\langle\Phi_+| + \frac{3}{4}|\Psi_-\rangle\langle\Psi_+| \\ & = \frac{1}{8}(|00\rangle+|11\rangle)(\langle00|+\langle11|)+\frac{3}{8}(|01\rangle-|10\rangle)(\langle01|-\langle10|)\\ & =\frac{1}{8}\begin{pmatrix} 1 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 \\ 1 & 0 & 0 & 1 \end{pmatrix}+\frac{3}{8}\begin{pmatrix} 0 & 0 & 0 & 0 \\ 0 & 1 & -1 & 0 \\ 0 & -1 & 1 & 0 \\ 0 & 0 & 0 & 0 \end{pmatrix}\\ & =\frac{1}{8}\begin{pmatrix} 1 & 0 & 0 & 1 \\ 0 & 3 & -3 & 0 \\ 0 & -3 & 3 & 0 \\ 1 & 0 & 0 & 1 \end{pmatrix}. \end{aligned}$$

ปรับแก้งานของคุณจากคำถามก่อนหน้าเพื่อเขียน density matrix สำหรับความน่าจะเป็นแบบคลาสสิก 50% ของ $|\Phi_\text{+}\rangle = \frac{1}{\sqrt{2}}(|00\rangle+|11\rangle)$ และความน่าจะเป็นแบบคลาสสิก 50% ของ $|\Psi_\text{-}\rangle = \frac{1}{\sqrt{2}}(|01\rangle-|10\rangle)$ จงทำนายว่าข้อมูลเฟสใดที่ควรจะยังคงอยู่

คำตอบ

$$\rho = \sum_i p_i |\psi_i\rangle\langle\psi_i|.$$

$p_i \neq 0$ เฉพาะสำหรับสถานะสองสถานะคือ $|\Phi_+\rangle$ และ $|\Psi_-\rangle$ เท่านั้น ดังนั้นเราจึงเขียนได้ว่า

$$\begin{aligned} \rho & = \frac{1}{2} |\Phi_+\rangle\langle\Phi_+| + \frac{1}{2}|\Psi_-\rangle\langle\Psi_-| \\ & = \frac{1}{4}(|00\rangle+|11\rangle)(\langle00|+\langle11|)+\frac{1}{4}(|01\rangle-|10\rangle)(\langle01|-\langle10|)\\ & =\frac{1}{4}\begin{pmatrix} 1 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 \\ 1 & 0 & 0 & 1 \end{pmatrix}+\frac{1}{4}\begin{pmatrix} 0 & 0 & 0 & 0 \\ 0 & 1 & -1 & 0 \\ 0 & -1 & 1 & 0 \\ 0 & 0 & 0 & 0 \end{pmatrix}\\ & =\frac{1}{4}\begin{pmatrix} 1 & 0 & 0 & 1 \\ 0 & 1 & -1 & 0 \\ 0 & -1 & 1 & 0 \\ 1 & 0 & 0 & 1 \end{pmatrix}. \end{aligned}$$

พจน์ในแนวทแยงรวมกันได้เท่ากับ 1 ตามที่ควรจะเป็น พจน์นอกแนวทแยงไม่ได้หักล้างกันในที่นี้เหมือนกับที่เกิดขึ้นในตัวอย่างหนึ่ง qubit ก่อนหน้านี้ คุณสามารถเห็นเหตุผลได้จากคณิตศาสตร์ แต่คำอธิบายแบบสั้น ๆ คือตอนนี้เรามีสถานะมากขึ้นใน Hilbert space แม้ว่า Bell state ตัวแรกจะมีเฟสสัมพัทธ์เป็นบวกและตัวที่สองมีเฟสสัมพัทธ์เป็นลบ แต่เฟสเหล่านี้อยู่ระหว่างสถานะเบซิสที่ต่างกัน Bell state ตัวแรกมีเฟสระหว่าง $|00\rangle$ และ $|11\rangle$ ในขณะที่ตัวที่สองมีเฟสสัมพัทธ์ระหว่าง $|01\rangle$ และ $|10\rangle$

Quantum channel

Quantum channel คือการแปลงสถานะควอนตัมที่ได้รับอนุญาตทางฟิสิกส์ที่เป็นทั่วไปที่สุด มันแปลง density matrix เริ่มต้น $\rho$ ไปเป็น density matrix อีกตัวหนึ่ง:

$$\rho \quad \longrightarrow \Phi(\rho)$$

ในที่นี้ $\Phi(\rho)$ หมายถึง quantum channel $\Phi$ ที่กระทำต่อ density matrix $\rho$ ไม่ควรสับสนกับ Bell state $|\Phi_+\rangle$ หรือ $|\Phi_-\rangle$

Quantum channel เป็นแนวคิดที่ทั่วไปมาก มันสามารถรวมถึง:

• วิวัฒนาการแบบยูนิทารี $\Phi(\rho) = U\rho U^\dagger$

• ส่วนผสมเชิงความน่าจะเป็นของ unitary

• Measurements

• Decoherence

• Amplitude damping (การสูญเสียพลังงาน)

• Dephasing (การสูญเสียข้อมูลเฟส)

• ปฏิสัมพันธ์กับสิ่งแวดล้อม และอีกหลายอย่าง

วิธีคิดหนึ่งเกี่ยวกับ quantum channel คือมันมีความสัมพันธ์กับ density matrix เหมือนกับที่ unitary มีความสัมพันธ์กับ pure state แต่ความเป็นทั่วไปของ density matrix ทำให้ quantum channel ที่สอดคล้องกันทั่วไปมากขึ้นและทรงพลังมากขึ้นตามไปด้วย

ข้อจำกัดเดียวของควอนตัมแชนเนลคือมันต้อง:

1. เป็นเชิงเส้น (Linear) ส่วนผสมของสถานะควรวิวัฒนาการอย่างสอดคล้องกัน: $\Phi(p\rho_1 + (1-p)\rho_2) = p\Phi(\rho_1) + (1-p)\Phi(\rho_2)$
2. เป็นบวกอย่างสมบูรณ์ (Completely positive) มันไม่ควรก่อให้เกิดความน่าจะเป็นติดลบ แม้ว่าระบบของคุณจะพัวพัน (entangled) กับสิ่งอื่นก็ตาม
3. รักษาค่าเทรซ (Trace-preserving) ความน่าจะเป็นต้องรวมกันได้เท่ากับ 1 สิ่งเหล่านี้บางครั้งถูกรวบรวมไว้ด้วยกันในตัวย่อ CPTP: Completely Positive Trace-Preserving map

มีการแทนค่า (representation) ของ quantum channel ที่แตกต่างกัน ได้แก่ การแทนค่าแบบ Stinespring, Kraus และ Choi สิ่งเหล่านี้ถูกอธิบายอย่างละเอียดในบทเรียนนี้ เกี่ยวกับ quantum channel ใน General formulation of quantum information และยังแสดงให้เห็นด้วยว่าการแทนค่าเหล่านี้เทียบเท่ากัน เราจะไม่ลงลึกในรายละเอียดของการแทนค่าที่แตกต่างกันเหล่านี้ในที่นี้ พูดสั้น ๆ ก็คือมันคล้ายกับการอธิบายเวกเตอร์โดยใช้กรอบพิกัดที่ต่างกันสามแบบ แต่ละแบบอาจเน้นแง่มุมที่ต่างกันและสร้างสัญชาตญาณในทางที่ต่างกัน แต่ทั้งหมดก็ให้คำตอบที่ถูกต้องแก่คุณ การแทนค่าแบบ Kraus สะดวกสำหรับจุดประสงค์ของเรา มันเสนอวิธีที่สะดวกในเชิงสูตรเพื่อแสดงการกระทำของ channel ผ่านการคูณและบวกเมทริกซ์ โดยเฉพาะอย่างยิ่ง การแทนค่าแบบ Kraus คือการระบุ channel หนึ่งตัว $\Phi$ ในรูปแบบต่อไปนี้

$$\Phi(\rho) = \sum_{k = 0}^{N-1} A_k \rho A_k^{\dagger}$$

ในที่นี้ $A_0,\ldots,A_{N-1}$ คือเมทริกซ์ที่มีมิติเท่ากันทั้งหมด: คอลัมน์ของมันสอดคล้องกับสถานะแบบคลาสสิกของระบบขาเข้า $\mathsf{X}$ และแถวของมันสอดคล้องกับสถานะแบบคลาสสิกของระบบขาออก ไม่ว่าจะเป็น $\mathsf{X}$ หรือระบบอื่น $\mathsf{Y}$ เพื่อให้ $\Phi$ เป็นแชนเนลที่ถูกต้อง เมทริกซ์เหล่านี้ต้องเป็นไปตามเงื่อนไขต่อไปนี้

$$\sum_{k = 0}^{N-1} A_k^{\dagger} A_k = \mathbb{I}_{\mathsf{X}}$$

เมทริกซ์เหล่านี้เรียกว่า เมทริกซ์ Kraus สูตรนี้ใช้ได้ไม่เพียงกับแชนเนลสัญญาณรบกวนเท่านั้น แต่ยังใช้ได้กับกระบวนการและแชนเนลควอนตัมทั่วไป รวมถึงการวัดด้วย มาดูตัวอย่างว่ามันสามารถถูกใช้สร้างแชนเนลในบริบทของสัญญาณรบกวนและข้อผิดพลาดได้อย่างไร

Channel แบบ completely dephasing

พิจารณา channel หนึ่งที่ทำลายข้อมูลเฟสทั้งหมด และเรียกมันว่า completely dephasing channel ซึ่งหมายความว่า channel นี้ควรรับ density matrix ใด ๆ ในรูปแบบ

$$\rho_i = \begin{pmatrix} \rho_{11} & \rho_{12} & \dots & \rho_{1n} \\ \rho_{21} & \rho_{22} & \ddots & \rho_{2n} \\ \vdots & \ddots & \ddots & \vdots \\ \rho_{n1} & \rho_{n2} & \dots & \rho_{nn} \end{pmatrix}$$

และแมปมันไปเป็น

$$\rho_f = \Phi(\rho_i) = \begin{pmatrix} \rho_{11} & 0 & \dots & 0 \\ 0 & \rho_{22} & \ddots & 0 \\ \vdots & \ddots & \ddots & \vdots \\ 0 & 0 & \dots & \rho_{nn} \end{pmatrix}$$

หากเราสมมติว่า density matrix ถูกเขียนไว้ในเบซิสการคำนวณ (computational basis) แล้ว เราสามารถแสดง $\rho_{ij}$ เป็น $\langle i|\rho|j\rangle$ ได้ นี่แนะนำชุดของ Kraus matrix ที่สามารถทำให้เกิดการกระทำของ channel นี้ได้: $A_k = |k\rangle\langle k|$ ลองนำกลยุทธ์นี้ไปใช้กับตัวอย่างกรณีของ qubit ตัวเดียว และดูว่ามันทำงานได้ตามที่เราต้องการหรือไม่:

กำหนดให้ $A_0 = \vert 0\rangle\langle 0\vert$ และ $A_1 = \vert 1\rangle\langle 1\vert$.

$$\begin{aligned} \sum_{k = 0}^1 A_k \rho A_k^{\dagger} & = \vert 0\rangle\langle 0 \vert \rho \vert 0\rangle\langle 0 \vert + \vert 1\rangle\langle 1 \vert \rho \vert 1\rangle\langle 1 \vert \end{aligned}$$

เนื่องจาก $\langle 0 \vert \rho \vert 0\rangle$ เป็นตัวเลข เราจึงสามารถย้ายเวกเตอร์ $\vert 0\rangle$ ผ่านมันไปได้ ซึ่งใช้ได้กับพจน์ที่สองเช่นกัน เราได้ว่า:

$$\begin{aligned} \sum_{k = 0}^1 A_k \rho A_k^{\dagger}& = \langle 0 \vert \rho \vert 0\rangle \, \vert 0\rangle\langle 0 \vert + \langle 1 \vert \rho \vert 1\rangle \, \vert 1\rangle\langle 1 \vert \\[2mm] & = \begin{pmatrix} \langle 0 \vert \rho \vert 0 \rangle & 0 \\[1mm] 0 & \langle 1 \vert \rho \vert 1 \rangle \end{pmatrix} \end{aligned}$$

โปรดสังเกตว่าเมทริกซ์เหล่านี้เป็นไปตามเงื่อนไขที่กำหนด:

$$\sum_{k = 0}^1 A_k^{\dagger} A_k = \vert 0\rangle\langle 0\vert 0\rangle\langle 0\vert + \vert 1\rangle\langle 1\vert 1\rangle\langle 1\vert = \vert 0\rangle\langle 0\vert + \vert 1\rangle\langle 1\vert = \mathbb{I}$$

ควรสังเกตว่าตัวเลือกของเมทริกซ์ Kraus นี้ไม่ได้มีเพียงหนึ่งเดียว

การอธิบายลักษณะของสัญญาณรบกวนในรูปแบบแชนเนล

ในหัวข้อนี้เราจะใช้แบบจำลองทรงกลมบลอค (Bloch sphere) และคณิตศาสตร์ของควอนตัมแชนเนลเพื่อทำความเข้าใจสัญญาณรบกวนและข้อผิดพลาดประเภทต่างๆ ให้ดียิ่งขึ้น

ข้อผิดพลาดแบบไม่โคฮีเรนต์

ให้เรากลับไปที่ข้อผิดพลาดแบบไม่โคฮีเรนต์และสำรวจข้อผิดพลาดจากการคลายพลังงาน (energy relaxation) โดยเฉพาะ จำไว้ว่าสถานะ $|0\rangle$ คือสถานะพื้นของคิวบิต และสถานะ $|1\rangle$ มีพลังงานสูงกว่าเล็กน้อย บางครั้งสถานะควอนตัมก็จะสลายตัวเองจากระดับพลังงานที่สูงกว่าไปยังระดับที่ต่ำกว่าโดยธรรมชาติ กระบวนการปลดปล่อยพลังงานเองนี้เป็นหัวข้อที่ลึกซึ้งและไม่สามารถเข้าใจได้อย่างแท้จริงหากไม่ใช้ทฤษฎีสนามควอนตัม แต่สัญชาตญาณของเรื่องนี้คุ้นเคยกับเราทุกคนดี: การรบกวนแบบสุ่มอาจทำให้ก้อนหินกลิ้งลงเนินได้ แต่จะไม่ทำให้ก้อนหินกลิ้งขึ้นเนิน ระยะเวลาที่คิวบิตยังคงอยู่ในสถานะพลังงานสูงกว่านั้นถูกกำหนดลักษณะด้วยเวลา $T_1$ กล่าวให้ชัดเจนขึ้นคือ ความน่าจะเป็นที่คิวบิตซึ่งเตรียมไว้ในสถานะ $|1\rangle$ จะยังคงอยู่ในสถานะนั้นหลังผ่านเวลา $t$ คือ $e^{-t/T_1}$ หรือกล่าวอีกนัยหนึ่งคือ ความน่าจะเป็น $p$ ของข้อผิดพลาดจากการคลายพลังงานหลังผ่านเวลา $t$ คือ

$$p = 1-e^{-t/T_1}$$

ในการอธิบายสิ่งนี้ด้วยควอนตัมแชนเนลในรูปแบบ Kraus เราต้องการเมทริกซ์ Kraus ที่สอดคล้องกับ

• การปล่อยให้สถานะ $|0\rangle$ ไม่เปลี่ยนแปลง
• การเปลี่ยนสถานะ $|1\rangle$ ไปเป็น $|0\rangle$ ด้วยความน่าจะเป็น p

ให้เรานิยาม

$$\begin{aligned} A_0 & = 1|0\rangle\langle0| + \sqrt{1-p}|1\rangle\langle1|\\ & = \begin{pmatrix} 1 & 0 \\ 0 & \sqrt{1-p}\end{pmatrix}\\ A_1 & = \sqrt{p}|0\rangle\langle1|\\ & = \begin{pmatrix} 0 & \sqrt{p} \\ 0 & 0\end{pmatrix} \end{aligned}$$

ก่อนอื่น ให้เราตรวจสอบว่าสิ่งนี้มีผลตามที่ต้องการต่อเมทริกซ์ความหนาแน่น (density matrix) พิจารณาระบบที่อยู่ในสถานะบริสุทธิ์ $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ เราได้เห็นในตัวอย่างข้างต้นแล้วว่าเมทริกซ์ความหนาแน่นสำหรับกรณีนี้คือ

$$\rho =\frac{1}{2}\begin{pmatrix} 1 & 1 \\ 1 & 1\end{pmatrix}.$$

เมื่อใช้แชนเนลการคลายพลังงานด้วยเมทริกซ์ Kraus เราจะได้เมทริกซ์ความหนาแน่นใหม่ที่ถูกแมปแล้ว:

$$\begin{aligned} \Phi(\rho) & = \sum_{k = 0}^{N-1} A_k \rho A_k^{\dagger}\\ & = A_0 \rho A_0^{\dagger} + A_1 \rho A_1^{\dagger}\\ & = \begin{pmatrix} 1 & 0 \\ 0 & \sqrt{1-p}\end{pmatrix}\frac{1}{2}\begin{pmatrix} 1 & 1 \\ 1 & 1\end{pmatrix}\begin{pmatrix} 1 & 0 \\ 0 & \sqrt{1-p}\end{pmatrix}+\begin{pmatrix} 0 & \sqrt{p} \\ 0 & 0\end{pmatrix}\frac{1}{2}\begin{pmatrix} 1 & 1 \\ 1 & 1\end{pmatrix}\begin{pmatrix} 0 & 0 \\ \sqrt{p} & 0\end{pmatrix}\\ & = \frac{1}{2}\begin{pmatrix} 1+p & \sqrt{1-p} \\ \sqrt{1-p} & 1-p\end{pmatrix} \end{aligned}$$

ให้เราตรวจสอบสิ่งนี้และเปรียบเทียบกับสัญชาตญาณของเรา:

ก่อนอื่น ให้เราตรวจสอบลิมิตเมื่อ $t$ เข้าใกล้ศูนย์ เราจะได้เมทริกซ์ความหนาแน่นเริ่มต้นกลับคืนมา ตามที่ควรจะเป็น:

$$\Phi(\rho,t \rightarrow 0) = \lim_{p\rightarrow 0}{\frac{1}{2}\begin{pmatrix} 1+p & \sqrt{1-p} \\ \sqrt{1-p} & 1-p\end{pmatrix}} = {\frac{1}{2}\begin{pmatrix} 1 & 1 \\ 1 & 1\end{pmatrix}}.$$

เมื่อเวลาผ่านไป เราคาดว่าความน่าจะเป็นในการวัดสถานะ $|0\rangle$ จะเพิ่มขึ้น และความน่าจะเป็นในการวัดสถานะ $|1\rangle$ จะลดลง ซึ่งนี่ก็ตรงกับสิ่งที่เราเห็นจริง เนื่องจาก

$$\begin{aligned} P_{|0\rangle} & = \langle 0 | \rho |0\rangle = \frac{1}{2}(1+p) = 1-\frac{1}{2}e^{-t/T_1}\\ P_{|1\rangle} & = \langle 1 | \rho |1\rangle = \frac{1}{2}(1-p) = \frac{1}{2}e^{-t/T_1} \end{aligned}$$

เรายังสามารถเห็นได้อย่างง่ายดายว่าความน่าจะเป็นในการวัด $|0\rangle$ และ $|1\rangle$ รวมกันได้ 1 ตามที่ควรจะเป็น

การไล่ระดับที่แม่นยำของพจน์โคฮีเรนซ์ (coherence, พจน์นอกแนวทแยง) นั้นอยู่นอกเหนือขอบเขตของการอธิบายนี้ แต่สิ่งที่ชัดเจนคือในตอนแรกเรามีข้อมูลเฟสที่สมบูรณ์แบบ และหลังจากเวลานานมาก จะไม่มีข้อมูลเฟสเหลืออยู่เลย เนื่องจากระบบคลายตัวลงจนหมดเข้าสู่สถานะ $|0\rangle$ อย่างสมบูรณ์ ดังนั้น พจน์โคฮีเรนซ์จะต้องสลายตัวลงเป็นศูนย์เมื่อเวลาผ่านไปนานมาก แท้จริงแล้ว

$$\lim_{p\rightarrow 1}{\sqrt{1-p}} = \lim_{t\rightarrow \infty}{\sqrt{e^{-t/T_1}}} = 0$$

ข้อจำกัดหลายประการของเมทริกซ์ Kraus ของเราได้รับการตรวจสอบโดยนัยผ่านการพิจารณาเชิงสัญชาตญาณเหล่านี้ ผู้อ่านควรตรวจสอบอย่างเข้มงวดว่าข้อจำกัดของแชนเนล (และของเมทริกซ์ Kraus โดยเฉพาะ) เป็นไปตามที่กำหนด แต่เราขอปล่อยให้เป็นแบบฝึกหัดสำหรับผู้อ่าน

ในเชิงกราฟิก แชนเนลประเภทนี้สามารถแสดงได้โดยใช้ทรงกลมบลอค สถานะบริสุทธิ์จะอยู่บนพื้นผิวของทรงกลมบลอค สถานะผสมจะเลื่อนเข้าไปด้านในของทรงกลมและกระจายออกจากจุดเดียว การมีอยู่ของความน่าจะเป็นเชิงคลาสสิกจะเห็นได้จากระยะทางสัมบูรณ์จากจุดกำเนิดไปยังสถานะใดสถานะหนึ่งในกลุ่มผสมที่ลดลง และการกระจายจากจุดเดียวไปเป็นบริเวณหนึ่งบ่งบอกถึงการผสมกันของสถานะที่เป็นไปได้หลายสถานะ ในกรณีพิเศษของแชนเนลการคลายพลังงาน สถานะผสม (เมทริกซ์ความหนาแน่น) หลังจากเวลาที่ไม่น้อยจนละเลยได้ จะมีลักษณะดังภาพด้านล่าง: บริเวณหนึ่งภายในทรงกลมบลอค ที่เลื่อนขึ้นไปทางขั้ว $|0\rangle$ และหดตัวทั้งตามแกน $Z$ และระนาบ $XY$ แม้ว่าจะน้อยกว่าตามแกน $Z$ ก็ตาม

โปรดสังเกตว่าบริเวณนี้ไม่ใช่ "หมวก" (cap) ของทรงกลมบลอค ตามที่บางครั้งปรากฏในการเรนเดอร์แบบเปอร์สเปกทีฟ ดังที่เห็นได้ชัดเจนในวิดีโอ มันคือทรงกลมรี (oblate spheroid) ที่หดตัวและเลื่อนไปทางสถานะ $|0\rangle$ แชนเนลสัญญาณรบกวน (และแชนเนลโดยทั่วไป) นั้นแน่นอนว่าใช้ได้กับระบบทุกขนาด แต่การแสดงผลด้วยภาพ (เช่นด้วยทรงกลมบลอค) จะทำได้ยากขึ้นเมื่อจำนวนสถานะที่ตั้งฉากกันในปริภูมิฮิลเบิร์ตเพิ่มขึ้น

ตรวจสอบความเข้าใจของคุณ

จงพิสูจน์ว่าเมทริกซ์ Kraus ที่ใช้ในแชนเนลการคลายพลังงานข้างต้นเป็นไปตามเงื่อนไขเอกลักษณ์:

$$\sum_{k = 0}^{N-1} A_k^{\dagger} A_k = \mathbb{I}_{\mathsf{X}}$$

คำตอบ

$$\begin{aligned} \sum_{k = 0}^{N-1} A_k^{\dagger} A_k & = A_0^\dagger A_0 + A_1^\dagger A_1\\ & = \begin{pmatrix} 1 & 0 \\ 0 & \sqrt{1-p}\end{pmatrix}\begin{pmatrix} 1 & 0 \\ 0 & \sqrt{1-p}\end{pmatrix} + \begin{pmatrix} 0 & 0 \\ \sqrt{p} & 0\end{pmatrix}\begin{pmatrix} 0 & \sqrt{p} \\ 0 & 0\end{pmatrix}\\ & = \begin{pmatrix} 1 & 0 \\ 0 & 1-p\end{pmatrix} + \begin{pmatrix} 0 & 0 \\ 0 & p\end{pmatrix}\\ & = \mathbb{I} \end{aligned}$$

เราจะนำเสนอแชนเนลสัญญาณรบกวนแบบไม่โคฮีเรนต์อีกสองประเภท แต่เราจะปล่อยให้การตีความและการพิสูจน์ส่วนใหญ่เป็นแบบฝึกหัด ประเภทถัดไปคือ dephasing channel ซึ่งอธิบายการสูญเสียข้อมูลเฟส แต่ยังคงรักษาแอมพลิจูดไว้ แม้ว่าจะยังคงมีความน่าจะเป็นทั้งเชิงคลาสสิกและเชิงกลศาสตร์ควอนตัมเกี่ยวข้องกับความน่าจะเป็นในการวัดโดยรวม แต่การสูญเสียข้อมูลเฟสมักถูกอธิบายว่าเป็นการสูญเสียข้อมูลควอนตัม หรือระบบกลายเป็นแบบคลาสสิกมากขึ้น

ในลักษณะเดียวกับที่การคลายพลังงานถูกอธิบายด้วยเวลาลักษณะเฉพาะ $T_1$ ข้อผิดพลาดจากการเสียเฟส (dephasing) ก็ถูกอธิบายด้วยพารามิเตอร์เวลาตัวที่สอง $T_2$ ความน่าจะเป็นของข้อผิดพลาดจากการเสียเฟสหลังผ่านเวลา $t$ กำหนดโดย

$$p = 1-e^{-t/T_2}$$

ชุดเมทริกซ์ Kraus สำหรับแชนเนลการเสียเฟสบนคิวบิตเดี่ยว ในรูปของความน่าจะเป็นนี้ มีดังนี้:

$$\begin{aligned} A_0 & = \sqrt{1-p}\mathbb{I}\\ & = \begin{pmatrix} \sqrt{1-p} & 0 \\ 0 & \sqrt{1-p}\end{pmatrix}\\ A_1 & = \sqrt{p}Z\\ & = \begin{pmatrix} \sqrt{p} & 0 \\ 0 & -\sqrt{p}\end{pmatrix}\\ \end{aligned}$$

ผลลัพธ์ของแชนเนลการเสียเฟสนี้ถูกแสดงเป็นภาพโดยใช้ทรงกลมบลอคในภาพด้านล่าง

โปรดสังเกตว่าแอมพลิจูดไม่เปลี่ยนแปลง ดังนั้นสถานะใดๆ ที่ตกอยู่พอดีที่ขั้ว ($|0\rangle$ หรือ $|1\rangle$) จะไม่ได้รับผลกระทบและยังคงถูกแมปไปยังพื้นผิวของทรงกลมในบริเวณที่แรเงาไว้ แต่ข้อมูลเฟสจะสูญหายไป ซึ่งสอดคล้องกับการหดตัวของบริเวณที่แรเงาบนระนาบ $XY$ วิธีทำความเข้าใจเรื่องนี้คือ: สถานะควอนตัมที่เป็นไปได้ใดๆ อาจยังคงมีเฟสที่กำหนดไว้ชัดเจน แต่เนื่องจากมีความน่าจะเป็นเชิงคลาสสิกที่จะพบสถานะหลายสถานะที่มีเฟสที่กำหนดไว้ชัดเจนแตกต่างกัน ความน่าจะเป็นโดยรวมของเฟสที่กำหนดไว้ชัดเจนใดๆ หนึ่งเฟสจึงลดลง

ตรวจสอบความเข้าใจของคุณ

จงพิสูจน์ว่าเมทริกซ์ Kraus ที่นิยามไว้ข้างต้นสำหรับแชนเนลการเสียเฟสเป็นไปตามเงื่อนไขเอกลักษณ์:

$$\sum_{k = 0}^{N-1} A_k^{\dagger} A_k = \mathbb{I}_{\mathsf{X}}$$

คำตอบ

$$\begin{aligned} \sum_{k = 0}^{N-1} A_k^{\dagger} A_k & = A_0^\dagger A_0 + A_1^\dagger A_1\\ & = \begin{pmatrix} \sqrt{1-p} & 0 \\ 0 & \sqrt{1-p}\end{pmatrix}\begin{pmatrix} \sqrt{1-p} & 0 \\ 0 & \sqrt{1-p}\end{pmatrix} + \begin{pmatrix} \sqrt{p} & 0 \\ 0 & -\sqrt{p}\end{pmatrix}\begin{pmatrix} \sqrt{p} & \\ 0 & -\sqrt{p}\end{pmatrix}\\ & = \begin{pmatrix} 1-p & 0 \\ 0 & 1-p\end{pmatrix} + \begin{pmatrix} p & 0 \\ 0 & p\end{pmatrix}\\ & = \mathbb{I} \end{aligned}$$

เริ่มต้นด้วยสถานะบริสุทธิ์ของคิวบิตเดี่ยวที่คุณเลือกเอง โดยมีเฟสที่กำหนดไว้ชัดเจนระหว่าง $|0\rangle$ และ $|1\rangle$ เขียนมันในรูปเมทริกซ์ความหนาแน่น จากนั้นใช้แชนเนลการเสียเฟสโดยใช้ตัวดำเนินการ Kraus ที่แนะนำไว้ข้างต้น และตีความเมทริกซ์ความหนาแน่นที่ถูกแมปที่ได้

คำตอบ

ให้เราเลือกสถานะ $|\psi\rangle = \frac{4}{5}|0\rangle -i\frac{3}{5} |1\rangle$ เมทริกซ์ความหนาแน่น $\rho$ ที่สอดคล้องกันคือ

$$\begin{aligned} \rho & = \sum_i p_i |\psi_i\rangle\langle\psi_i|\\ & = 1\left(\frac{4}{5}|0\rangle -i\frac{3}{5} |1\rangle\right) \left( \frac{4}{5}|0\langle +i\frac{3}{5} |1\langle\right)\\ & = \frac{16}{25}\begin{pmatrix} 1 & 0 \\ 0 & 0\end{pmatrix}+\frac{12i}{25}\begin{pmatrix} 0 & 1 \\ 0 & 0\end{pmatrix}-\frac{12i}{25}\begin{pmatrix} 0 & 0 \\ 1 & 0\end{pmatrix}+\frac{9}{25}\begin{pmatrix} 0 & 0 \\ 0 & 1\end{pmatrix}\\ & = \frac{1}{25}\begin{pmatrix} 16 & 12i \\ -12i & 9\end{pmatrix} \end{aligned}$$

ตอนนี้เราจะใช้แชนเนลการเสียเฟสกับเมทริกซ์ความหนาแน่นนี้โดยใช้ตัวดำเนินการ Kraus

$$\begin{aligned} \Phi(\rho) & = \sum_{k = 0}^{N-1} A_k \rho A_k^{\dagger}\\ & = A_0 \rho A_0^\dagger + A_1 \rho A_1^\dagger\\ & = \begin{pmatrix} \sqrt{1-p} & 0 \\ 0 & \sqrt{1-p}\end{pmatrix} \frac{1}{25}\begin{pmatrix} 16 & 12i \\ -12i & 9\end{pmatrix} \begin{pmatrix} \sqrt{1-p} & 0 \\ 0 & \sqrt{1-p}\end{pmatrix} + \begin{pmatrix} \sqrt{p} & 0 \\ 0 & -\sqrt{p}\end{pmatrix} \frac{1}{25}\begin{pmatrix} 16 & 12i \\ -12i & 9\end{pmatrix} \begin{pmatrix} \sqrt{p} & \\ 0 & -\sqrt{p}\end{pmatrix}\\ & = \frac{1}{25}\begin{pmatrix} 16(1-p) & 12i(1-p) \\ -12i(1-p) & 9(1-p)\end{pmatrix} + \frac{1}{25}\begin{pmatrix} 16p & -12ip \\ 12ip & 9p\end{pmatrix}\\ & = \frac{1}{25}\begin{pmatrix} 16 & 12i(1-2p) \\ -12i(1-2p) & 9\end{pmatrix} \end{aligned}$$

ประการแรก เราสังเกตว่าผลรวมของสมาชิกในแนวทแยงเท่ากับหนึ่งจริง ๆ ตามที่ควรจะเป็น ประการที่สอง สังเกตว่าสมาชิกนอกแนวทแยงในตอนแรกมีค่ามาก โดยมีผลรวมเท่ากับ 24/25 ซึ่งบ่งบอกถึงโคฮีเรนซ์ที่แข็งแรง สังเกตว่าเมื่อความน่าจะเป็นของข้อผิดพลาดจากการเสียเฟส $p$ เพิ่มขึ้น สมาชิกนอกแนวทแยงเหล่านี้จะลดลง ซึ่งก็ตรงกับที่เราคาดไว้เช่นกัน มีจุดที่ละเอียดอ่อนอยู่จุดหนึ่ง: สังเกตว่าเกิดอะไรขึ้นเมื่อ $p\rightarrow 1$ โคฮีเรนซ์กลับแข็งแรงขึ้นอีกครั้ง! สิ่งนี้ดูเหมือนจะขัดกับสัญชาตญาณในตอนแรก เพราะความน่าจะเป็นสูงของข้อผิดพลาดจากการเสียเฟสน่าจะทำให้เฟสของเรายุ่งเหยิง ใช่ไหม? ประเด็นสำคัญคือ ถ้าเรามั่นใจ 100% ว่าเกิดข้อผิดพลาดของเฟสขึ้น เราก็จะมีข้อมูลที่ชัดเจนเกี่ยวกับเฟสอีกครั้ง เพียงแต่เฟสถูกพลิกกลับไปเท่านั้น ด้วยความเข้าใจนี้ เราอาจคาดว่าข้อมูลเฟสที่แย่ที่สุดจะสอดคล้องกับโอกาส 50-50 ที่จะเกิดข้อผิดพลาดของเฟส และนั่นก็คือสิ่งที่เราพบจริง ๆ

ตัวอย่างสุดท้ายของแชนเนลสัญญาณรบกวนที่อธิบายข้อผิดพลาดแบบไม่โคฮีเรนต์คือ Pauli noise channel แชนเนลนี้อธิบายการเกิดข้อผิดพลาดสามประเภทด้วยความน่าจะเป็นที่เป็นอิสระต่อกัน:

• ข้อผิดพลาดแบบพลิกบิต (bit-flip, X error) ด้วยความน่าจะเป็น $p_x$
• ข้อผิดพลาดแบบพลิกเฟส (phase-flip, Z error) ด้วยความน่าจะเป็น $p_z$
• การรวมกันของ X และ Z (Y error) ด้วยความน่าจะเป็น $p_y$ โดยที่ $0\leq p_j \leq 1$ สำหรับทุก $j$ ผลสืบเนื่องคือความน่าจะเป็นที่จะไม่เกิดข้อผิดพลาดเลยคือ $p_I = 1-p_x-p_y-p_z$

ตัวดำเนินการ Kraus สำหรับแชนเนลนี้คือ:

$$\begin{aligned} A_0 & = \sqrt{p_I}I\\ A_1 & = \sqrt{p_X}X\\ A_2 & = \sqrt{p_Y}Y\\ A_3 & = \sqrt{p_Z}Z \end{aligned}$$

ในกรณีของ Pauli noise channel การเขียนแชนเนลนี้ออกมาโดยตรงเป็นสิ่งที่มีประโยชน์:

$$\Phi(\rho) = p_I I\rho I + p_X X\rho X+p_Y Y \rho Y + p_Z Z \rho Z$$

จากรูปแบบนี้เราจะเห็นว่า Pauli noise channel ทำให้เกิดข้อผิดพลาดหนึ่งอย่างหรือมากกว่านั้นซึ่งสอดคล้องกับการกระทำของเมทริกซ์ Pauli $P_j$ แต่ละตัวด้วยความน่าจะเป็น $p_j$

การรวมกันของความน่าจะเป็นในการพลิกแบบต่าง ๆ จะให้ภาพแสดงผลที่แตกต่างกัน ในที่นี้เราจะแสดงกรณีพิเศษที่ $p_X = p_Y = p_Z$ ซึ่งเรียกอีกอย่างว่า depolarizing channel

การจำลองข้อผิดพลาดแบบโคฮีเรนต์

ควอนตัมแชนเนลสามารถแสดงข้อผิดพลาดได้ทั้งแบบโคฮีเรนต์และไม่โคฮีเรนต์ แต่ในทางปฏิบัติมักถูกใช้เป็นหลักกับข้อผิดพลาดแบบไม่โคฮีเรนต์ เนื่องจากข้อผิดพลาดแบบโคฮีเรนต์จะจำลองได้ดีกว่าในรูปของการปรับเทียบยูนิทารีที่ผิดพลาด (unitary miscalibration) หรือแปลงเป็นแชนเนลสุ่ม (stochastic channel) เพื่อให้วิเคราะห์ได้ง่ายขึ้น ในหัวข้อนี้เราจะนำเสนอแนวทางที่เหมาะสมกว่าสำหรับข้อผิดพลาดแบบโคฮีเรนต์

ข้อผิดพลาดแบบโคฮีเรนต์สามารถจำลองได้ด้วยเกตยูนิทารีที่ไม่ต้องการ ตัวอย่างง่าย ๆ ได้แก่ การหมุนที่ไม่ตรงแนว หรือการหมุนน้อยเกินไป/มากเกินไป ในภาพด้านล่าง เราแสดงการหมุนที่ไม่ตรงแนวเป็นการหมุน $Y$ เพิ่มเติมด้วยปริมาณเล็กน้อย $\epsilon$ นอกเหนือจากการหมุนตามแกน $X$ ที่ต้องการ การหมุนมากเกินไปถูกอธิบายด้วยการหมุน $X$ ที่ต้องการ บวกกับการหมุนเพิ่มเติมรอบแกนเดียวกัน $X_\epsilon$

ข้อผิดพลาดของสองคิวบิตและกรวยแสงที่แรเงา

เกตคิวบิตเดี่ยวจะหมุนคิวบิตที่แยกโดดเดี่ยว เกตสองคิวบิตจะทำงานตามตรรกะที่อาศัยคิวบิตสองตัว แต่ไม่สามารถวัดคิวบิตตัวใดตัวหนึ่งได้โดยตรง จึงต้องเปิดใช้งานอันตรกิริยา (interaction) ระหว่างคิวบิต อันตรกิริยานี้เป็นเหตุผลที่ทำให้เราสามารถสร้างการพัวพัน (entanglement) ได้ และยังเป็นแหล่งที่มาส่วนใหญ่ของสัญญาณรบกวน การรบกวนข้าม (crosstalk) และความยากลำบากในการปรับเทียบ อันตรกิริยาระหว่างคิวบิตนี้ยังทำให้ข้อผิดพลาดสามารถแพร่กระจายได้ด้วย หากคิวบิตหนึ่งมีข้อผิดพลาดบางอย่าง และทำหน้าที่เป็นคิวบิตควบคุมสำหรับคิวบิตเป้าหมายอีกตัวหนึ่ง ข้อผิดพลาดนั้นก็สามารถส่งต่อไปยังเป้าหมายได้ ในบทเรียนนี้เราจะทบทวนว่าเกตสองคิวบิตหมายความว่าอย่างไรต่ออัตราข้อผิดพลาดและการแพร่กระจายของข้อผิดพลาดภายในวงจร

เกต Echoed Cross-Resonance

สถาปัตยกรรมฮาร์ดแวร์และตระกูลเกตที่แตกต่างกันจะออกแบบอันตรกิริยานั้นด้วยวิธีที่แตกต่างกัน คอมพิวเตอร์ควอนตัมของ IBM ใช้เกตสองคิวบิตเชิงนามธรรมอย่าง CZ หรือ CX โดยอาศัยเกต echoed cross-resonance (ECR) ที่เป็นแบบดั้งเดิมของฮาร์ดแวร์ เกต ECR สร้างอันตรกิริยา $ZX$ ที่มีผลจริงโดยใช้การขับด้วยไมโครเวฟ เกตที่เกี่ยวข้องอย่าง CNOT ถูกสร้างขึ้นจาก $ZX$ โดยการเพิ่มการหมุนของคิวบิตเดี่ยว

คิวบิตแต่ละตัวมีความถี่เรโซแนนซ์ต่างกัน (ความถี่ที่คิวบิตตอบสนองอย่างรุนแรง) การดำเนินการมาตรฐานอาจใช้ความถี่เรโซแนนซ์นั้นเพื่อกระตุ้นให้เกิดการเปลี่ยนสถานะในคิวบิต แต่จะเกิดอะไรขึ้นถ้าคุณขับคิวบิต C ที่ความถี่เรโซแนนซ์ของคิวบิต T ที่อยู่ติดกัน? คิวบิตที่อยู่ติดกันเชื่อมโยงกันด้วยอันตรกิริยาแบบคาปาซิทีฟหรือผ่านตัวสะท้อนที่คงที่ เนื่องจากการมีคัปปลิ้งนี้ การขับที่คิวบิต C จึง "รั่วไหล" เข้าไปในแฮมิลโทเนียนของคิวบิต T ความแรงและทิศทางของการขับที่มีผลจริงนี้ขึ้นอยู่กับสถานะของคิวบิต C ($|0\rangle$ หรือ $|1\rangle$) ในที่นี้ คิวบิต C คือตัวควบคุม (control) และคิวบิต T คือเป้าหมาย (target)

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

$$H_{eff} \approx \Omega Z_C X_T +\text{other terms}$$

อันตรกิริยา ZX นี้คือสิ่งที่คุณต้องการพอดีในการสร้าง CNOT แต่พจน์อื่น ๆ อาจรวมถึงข้อผิดพลาดบางอย่าง และแทบจะแน่นอนว่ารวมถึงคัปปลิ้งแบบคาปาซิทีฟระหว่างคิวบิต C และ T ซึ่งสอดคล้องกับพจน์ ZZ

$$H_\mathrm{CR} = \underbrace{\Omega \, Z_C X_T}_{\text{desired}} + \underbrace{\alpha\, I_C X_T + \beta\, Z_C I_T + \gamma\, I_C Z_T + \delta\, Z_C Z_T + \dots}_{\text{undesired}}.$$

เราสามารถคิดถึงพจน์เพิ่มเติมเหล่านี้ได้ในลักษณะต่อไปนี้:

• IX = เป้าหมายถูกขับโดยไม่ตั้งใจ

• ZI = คิวบิตควบคุมได้รับการหมุน Z ที่ไม่ต้องการ

• IZ = คิวบิตเป้าหมายได้รับการหมุน Z ที่ไม่ต้องการ

• ZZ = การเลื่อนเฟสที่ขึ้นอยู่กับสถานะแบบคงที่

• อื่น ๆ = อันตรกิริยา XY, XX และอันดับสูงกว่าที่มีขนาดเล็ก

เกต ECR เป็นเพียงการหมุนแบบมีเงื่อนไข (controlled rotation) บวกกับพัลส์เอคโค (echo pulse) ที่เลือกอย่างระมัดระวังบนคิวบิตควบคุม เอคโคจะพลิกเครื่องหมายของพจน์ที่ไม่ต้องการหลายพจน์ ในขณะที่ยังคงรักษาปฏิสัมพันธ์ ZX ไว้ กระบวนการนี้จะหักล้างข้อผิดพลาด IX และ ZI ได้ค่อนข้างดี และบางครั้งก็หักล้างพจน์อันดับสูงกว่าบางพจน์ด้วย แต่การเอคโคไม่สามารถหักล้างคัปปลิ้ง ZZ แบบคงที่ได้ เนื่องจากมันสลับที่ (commute) กับพัลส์เอคโค ยังมีปฏิสัมพันธ์อื่น ๆ ที่จะไม่ถูกหักล้างในกระบวนการนี้: ความไม่เป็นเชิงเส้นที่หลงเหลืออยู่และผลของคิวบิตข้างเคียง (spectator qubit) การรั่วไหล (leakage) และการปนเปื้อนของการขับในระยะไกล บวกกับอีกเล็กน้อย — แต่พจน์ ZZ มีความสำคัญเป็นพิเศษ

กระบวนการนี้มักต้องใช้เวลาขับที่นานกว่าเกตคิวบิตเดี่ยวเป็นลำดับขนาด (order of magnitude) การรวมกันของเวลาขับที่ยาวนานขึ้น พจน์ ZZ ที่ยังคงอยู่ในแฮมิลโทเนียน และความไม่สมบูรณ์แบบของคัปปลิ้ง ทำให้เกตสองคิวบิตเป็นแหล่งที่มาหลักของข้อผิดพลาดของเกต โปรดสังเกตด้วยว่าหากต้องการอันตรกิริยาในวงจรระหว่างคิวบิตที่ไม่อยู่ติดกัน เกต SWAP ที่จำเป็นก็เห็นได้ชัดว่าเป็นเกตสองคิวบิตเช่นกัน นี่คือเหตุผลที่ตัวชี้วัดความลึกมาตรฐานคือ ความลึกสองคิวบิตหลัง transpile (two-qubit, transpiled depth) เราสนใจเกตสองคิวบิตเป็นหลักเพราะมันครอบงำข้อผิดพลาดของเกต และเราจำเป็นต้องพิจารณาวงจรหลัง transpile เพราะการ transpile มักจะเพิ่มเกตสองคิวบิตเพิ่มเติมจำนวนมากในรูปแบบของเกต SWAP

ตรวจสอบความเข้าใจของคุณ

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

คำตอบ

เกตสองคิวบิตมีอัตราข้อผิดพลาดสูงกว่าเกตคิวบิตเดี่ยวมาก เกตคิวบิตเดี่ยวก็ไม่ได้สมบูรณ์แบบเช่นกัน จึงอาจมีบางกรณีที่การพิจารณาความลึกของคิวบิตเดี่ยวก็มีประโยชน์ด้วย แต่ความลึกของเกตสองคิวบิตมักจะครอบงำพฤติกรรมข้อผิดพลาดของวงจร เราต้องพิจารณาวงจรหลัง transpile คอมพิวเตอร์ควอนตัมสมัยใหม่ไม่มีการเชื่อมต่อคิวบิตแบบทุกตัวถึงทุกตัว คอมพิวเตอร์ควอนตัมของ IBM ใช้โครงตาข่ายแบบสี่เหลี่ยมจัตุรัสหรือโครงตาข่ายแบบ "heavy hex" ซึ่งหมายความว่าคิวบิตมีเพื่อนบ้านที่ใกล้ที่สุด 2, 3 หรือ 4 ตัวที่สามารถคัปเปิลกันได้โดยตรงด้วยเกตสองคิวบิตเพียงตัวเดียว การพัวพันใด ๆ กับคิวบิตอื่นที่ไม่อยู่ติดกันต้องการการเคลื่อนย้ายข้อมูลไปมาบนคอมพิวเตอร์ควอนตัมโดยใช้เกต SWAP สองคิวบิต ดังนั้น การ transpile จึงมักจะเพิ่มความลึกของเกตสองคิวบิต สำหรับวงจรที่มีการพัวพันสูง การเพิ่มขึ้นนี้อาจมีขนาดใหญ่มาก

กรวยแสงที่แรเงา

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

แม้คุณอาจไม่เคยคิดในลักษณะนี้มาก่อน แต่นี่ก็คือแผนภาพกาลอวกาศ (spacetime diagram) ชนิดหนึ่ง แกนตั้งของวงจรควอนตัมแสดงถึงคิวบิตต่าง ๆ ที่จัดเรียงอยู่ในอวกาศ แกนนอนแสดงถึงเวลาที่ลำดับของเกตถูกนำมาใช้ หากยืมภาษาจากทฤษฎีสัมพัทธภาพมาใช้ กรวยแสง (light cone) แสดงถึงบริเวณของกาลอวกาศที่สามารถเข้าถึงได้จากจุดหนึ่งผ่านปฏิสัมพันธ์เชิงเหตุภาพ (causal interactions)

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

อย่างไรก็ตาม ข้อผิดพลาดบนเกต Z ของคิวบิต 0 (ไม่จำเป็นต้องเป็น Z-error เพียงแค่ข้อผิดพลาดบางอย่างที่ตำแหน่งนั้น) สามารถแพร่กระจายไปยังคิวบิตอื่นได้: คิวบิต 1 ผ่านทาง CNOT สุดท้ายที่ใช้คิวบิต 0 เป็นตัวควบคุมและคิวบิต 1 เป็นเป้าหมาย ดังแสดงในส่วน (b) ตามที่คุณอาจคาดไว้ ข้อผิดพลาดที่เกิดขึ้นก่อนหน้าในวงจรมักจะมีโอกาสแพร่กระจายไปยังคิวบิตได้มากกว่า ส่วน (c) แสดงให้เห็นว่าข้อผิดพลาดในการเตรียมสถานะเริ่มต้นของคิวบิต 0 สามารถแพร่กระจายไปยังคิวบิตทุกตัวยกเว้นคิวบิต 4 ซึ่งถูกแยกโดดเดี่ยว

การจัดวางนี้แสดงให้เห็นว่าข้อผิดพลาดสามารถแพร่กระจายไปข้างหน้าตามเวลาเพื่อส่งผลต่อการวัดได้อย่างไร แต่คุณยังสามารถตรวจสอบคำถามในทิศทางตรงกันข้ามได้: สำหรับการวัดคิวบิตเดี่ยวหนึ่งค่าที่เจาะจง ส่วนใดของวงจรของฉันที่อาจก่อให้เกิดข้อผิดพลาดบางอย่างต่อมันได้บ้าง? ในกรณีนั้น คุณเพียงแค่เริ่มต้นจากการวัดหรือจุดที่สนใจอื่น ๆ แล้วย้อนกลับ (ตามเวลา) ผ่านวงจร โดยตามวงจรที่มีการพัวพันใด ๆ ดังแสดงในส่วน (d) และยังแสดงจุดที่เลือกแบบสุ่มบางจุดสำหรับข้อผิดพลาดที่อาจเกิดขึ้นด้วย

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

หากข้อผิดพลาดบนเป้าหมายสลับที่ (commute) กับคัปปลิ้ง ZZ ได้ ข้อผิดพลาดนั้นจะไม่สามารถแพร่กระจายไปยังคิวบิตควบคุมได้ เราสามารถเห็นสิ่งนี้ได้ผ่านกลไกทางฟิสิกส์ที่เกิดขึ้น วิธีที่รวดเร็วในการเห็นสิ่งนี้คือ ถ้าข้อผิดพลาด $E$ สลับที่กับ $ZZ$ ได้ ลำดับของทั้งสองก็สามารถสลับกันได้โดยไม่ส่งผลต่อผลลัพธ์ อย่างไรก็ตาม หาก $E$ ที่เกิดขึ้นก่อนคัปปลิ้ง $ZZ$ ให้ผลเช่นเดียวกับที่มันกระทำหลังคัปปลิ้ง $ZZ$ มันก็ไม่สามารถส่งผลต่อตัวควบคุมได้ เนื่องจากในกรณีหลังนี้ ข้อผิดพลาดจะต้องเคลื่อนที่ย้อนเวลากลับไป หากข้อผิดพลาดไม่สลับที่กับคัปปลิ้ง ZZ มันก็อาจแพร่กระจายจากเป้าหมายกลับไปยังตัวควบคุมได้จริง ดังนั้น ในกรณีของเกต ECR ข้อผิดพลาด Z จะไม่สามารถแพร่กระจายจากเป้าหมายไปยังตัวควบคุมได้ แต่ข้อผิดพลาด X หรือ Y สามารถทำได้

ตรวจสอบความเข้าใจของคุณ

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

คำตอบ

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

เริ่มต้นด้วยเวอร์ชันที่ไม่มีข้อผิดพลาดของวงจรในแผนภาพด้านบน ให้ติดตามการแพร่กระจายที่เป็นไปได้ของข้อผิดพลาดในเกต Hadamard ตัวแรกที่กระทำกับคิวบิต 2 ระบุคิวบิตทั้งหมดที่อาจได้รับผลกระทบเมื่อสิ้นสุดวงจร หากข้อผิดพลาดเป็น (a) การพลิกเฟส (phase flip) และ (b) การพลิกบิต (bit flip) คำใบ้: ลองคิดว่าข้อมูลบนคิวบิตแต่ละตัวถูกใช้งานอย่างไร

คำตอบ

(a) คิวบิต 3 อาจได้รับผลกระทบ รวมถึงคิวบิต 2 เองอย่างชัดเจน ไม่มีคิวบิตอื่นอีก! หากคุณระบุคิวบิต 0 และ 1 ไว้ โปรดสังเกตว่าคิวบิต 2 เป็นเป้าหมายของ ECR ที่พัวพันมันกับคิวบิต 1 ไม่มีการเปลี่ยนแปลงใด ๆ เกิดขึ้นกับคิวบิต 1 ในเกตนั้น (b) คิวบิต 0-3 อาจได้รับผลกระทบ ข้อผิดพลาดแบบพลิกบิตหรือชนิด X ไม่สลับที่กับคัปปลิ้ง ZZ ในเกต ECR และจึงสามารถแพร่กระจายจากเป้าหมายไปยังตัวควบคุมได้

การแพร่กระจายของข้อผิดพลาด

ในหัวข้อก่อนหน้า เราได้อภิปรายเรื่องการแพร่กระจายของข้อผิดพลาดโดยไม่ได้ให้นิยามอย่างเป็นทางการ ต่อจากนี้ไป:

สำหรับข้อผิดพลาด $E$ ที่เกิดขึ้นก่อนส่วนหนึ่งของงานตรรกะ (logical payload) ของวงจร $U$ การแพร่กระจายของข้อผิดพลาดหมายถึงการหาตัวดำเนินการเทียบเท่า $E'$ ที่ให้ผลลัพธ์ที่ผิดพลาดเหมือนกันเมื่อถูกนำไปใช้หลัง $U$ แทนที่จะเป็นก่อนหน้า

$$\boxed{ \text{An error } E \text{ propagates through a unitary } U \text{ as } E' = U E U^\dagger }$$ $$\boxed{ U\,E\,|\psi\rangle = E'\,U\,|\psi\rangle }$$

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

ให้ตัวควบคุมเป็นคิวบิต 0 และเป้าหมายเป็นคิวบิต 1 พิจารณาข้อผิดพลาด X และ Z บนคิวบิตควบคุมและเป้าหมาย ($X_c$, $Z_c$, $X_t$, และ $Z_t$ ตามลำดับ) การเลื่อนข้อผิดพลาดเหล่านี้ผ่าน $\text{CNOT}_{0\to1}$ ทำให้ข้อผิดพลาดกลายเป็น:

$$\begin{aligned} X_c &\to X_c X_t\\ Z_c &\to Z_c\\ X_t &\to X_t\\ Z_t &\to Z_c Z_t \end{aligned}$$

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

ตัวควบคุมเริ่มต้น	เป้าหมายเริ่มต้น	ข้อผิดพลาด	สุดท้าย	ข้อผิดพลาดเทียบเท่าหลัง CNOT
$\alpha\vert 0\rangle+\beta \vert 1\rangle$	$\gamma \vert 0\rangle+\delta \vert 1\rangle$	ไม่มี	$\alpha\gamma \vert 00\rangle+\alpha\delta \vert 10\rangle + \beta\gamma \vert 11\rangle +\beta\delta \vert 01\rangle$	ไม่เกี่ยวข้อง
$\alpha\vert 0\rangle+\beta \vert 1\rangle$	$\gamma \vert 0\rangle+\delta \vert 1\rangle$	X บนตัวควบคุม	$\alpha\gamma \vert 11\rangle+\alpha\delta \vert 01\rangle + \beta\gamma \vert 10\rangle +\beta\delta \vert 00\rangle$	$X_c X_t$
$\alpha\vert 0\rangle+\beta \vert 1\rangle$	$\gamma \vert 0\rangle+\delta \vert 1\rangle$	Z บนตัวควบคุม	$\alpha\gamma \vert 00\rangle+\alpha\delta \vert 10\rangle - \beta\gamma \vert 11\rangle -\beta\delta \vert 01\rangle$	$Z_c$
$\alpha\vert 0\rangle+\beta \vert 1\rangle$	$\gamma \vert 0\rangle+\delta \vert 1\rangle$	X บนเป้าหมาย	$\alpha\gamma \vert 10\rangle+\alpha\delta \vert 00\rangle + \beta\gamma \vert 01\rangle +\beta\delta \vert 11\rangle$	$X_t$
$\alpha\vert 0\rangle+\beta \vert 1\rangle$	$\gamma \vert 0\rangle+\delta \vert 1\rangle$	Z บนเป้าหมาย	$\alpha\gamma \vert 00\rangle-\alpha\delta \vert 10\rangle + \beta\gamma \vert 11\rangle -\beta\delta \vert 01\rangle$	$Z_c Z_t$

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

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

มี Qiskit addon ตัวหนึ่งชื่อว่า Shaded Lightcones addon shaded lightcones (SLC) วิเคราะห์การแพร่กระจายของข้อผิดพลาดในวงจรควอนตัมโดยใช้การแพร่กระจายของ Pauli เพื่อระบุว่าส่วนใดของวงจรที่สามารถส่งผลต่อ observable เป้าหมายได้จริง มันถูกออกแบบมาเป็นหลักเพื่อให้การบรรเทาข้อผิดพลาด (error mitigation) มีประสิทธิภาพมากขึ้น โดยเฉพาะสำหรับเวิร์กโฟลว์การหักล้างข้อผิดพลาดเชิงความน่าจะเป็น (probabilistic error cancellation, PEC) เราจะสำรวจเครื่องมือนี้เพียงสังเขปในที่นี้ และจะใช้งานอย่างกว้างขวางมากขึ้นในบริบทของเทคนิคการบรรเทาข้อผิดพลาดในบทเรียนถัดไป มันใช้การแพร่กระจายของตัวดำเนินการ Pauli เพื่อทำแผนที่การแพร่กระจายของข้อผิดพลาดประเภทต่าง ๆ โดยสร้างกรวยแสงสำหรับข้อผิดพลาดชนิด X, Y, และ Z

Shaded lightcones (SLC) ไปไกลกว่านั้น โดยใช้การจำลองแบบคลาสสิกเพื่อจำกัดขอบเขตความไวต่อข้อผิดพลาดตลอดทั้งวงจรให้แน่นขึ้น วิธีนี้แลกเวลา QPU บางส่วนกับเวลา CPU และลดภาระการสุ่มตัวอย่าง (sampling overhead) ที่จำเป็นสำหรับการปรับค่า renormalize ของ bias แทนที่จะใช้ค่าตัดขาดแบบ hard cutoff ข้อผิดพลาดที่อาจเกิดขึ้นแต่ละจุดในวงจรจะถูกกำหนด “เฉดสี” (shade) แบบไล่ระดับที่เป็นขอบเขตบนของความอ่อนไหวของ observable ต่อข้อผิดพลาดนั้น การกำหนดลักษณะที่ละเอียดขึ้นนี้ช่วยให้สามารถประยุกต์ใช้ PEC ได้อย่างมีประสิทธิภาพและตรงเป้าหมายมากขึ้นโดยมีความแปรปรวนลดลง พร้อมทั้งให้ผู้ใช้สามารถปรับ bias ในการประมาณค่า observable ได้อย่างควบคุมได้ ดูรายละเอียดเพิ่มเติมได้ที่ Lightcone shading for classically accelerated quantum error mitigation

เราจะไม่นำเสนอ workflow แบบเต็มรูปแบบที่นี่ เราเพียงแสดงให้เห็นด้วยแผนภาพว่า workflow นี้นำวงจรเข้ามาอย่างไร:

workflow นี้แบ่งวงจรออกเป็น "boxes" ที่มีประโยชน์สำหรับการเรียนรู้พฤติกรรมของ noise:

สุดท้าย มันใช้ operator propagation และ noise learning เพื่อสร้างแผนที่แบบไล่เฉดสี (shaded map) ของความอ่อนไหวต่อข้อผิดพลาดตลอดทั้งวงจร:

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

สังเกตบริเวณสีม่วงทางด้านขวาของแต่ละแผนที่ ข้อผิดพลาดที่ layer เดียวกับการวัด แต่อยู่บน qubit ต่างกัน ไม่สามารถส่งผลต่อการวัดได้ผ่านการเชื่อมต่อของวงจรที่แสดงไว้ ในทำนองเดียวกัน ข้อผิดพลาดที่ย้อนไปหนึ่ง layer ในเวลา (หนึ่ง layer ทางด้านซ้าย) สามารถแพร่กระจายไปยัง qubit ที่อยู่ติดกันในขั้นตอนถัดไปได้เท่านั้น เนื่องจากโครงสร้างของ entangling layer และเป็นเช่นนี้ต่อไปเรื่อยๆ ดังนั้นรูปทรงกรวย (cone shape) ทางด้านขวาจึงเป็นลักษณะทั่วไปเมื่อมี qubit จำนวนค่อนข้างน้อยที่เกี่ยวข้องกับการวัดที่สนใจ

ทดสอบความเข้าใจของคุณ

คุณคิดว่าการสร้างแผนที่ shaded lightcone ควรทำก่อนหรือหลังการทำ transpilation? เพราะเหตุใด?

คำตอบ

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