ทำไมโปรโตคอลการแก้ไขข้อผิดพลาดจะทำงานเฉพาะเมื่ออัตราความผิดพลาดต่ำมากที่จะเริ่มต้นด้วย?

15

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

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

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

ทำไมนี้ ทำไมจึงเป็นไปไม่ได้ที่จะลดอัตราความผิดพลาดที่ยังไม่เริ่มต้นให้ต่ำ

error-correction fault-tolerance

— แอลเอส
แหล่งที่มา

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

— กิ้งก่าไม่ต่อเนื่อง

1

@Discretelizard ไม่มากที่อาจจะมีทั้งหมด แต่เกณฑ์มักจะต่ำมาก (หรือสูงในแง่ของความจงรักภักดี) เหตุผลที่เป็นเช่นนั้น?

— glS

4

เราต้องการที่จะเปรียบเทียบรัฐเอาท์พุทกับรัฐในอุดมคติบางอย่างเพื่อให้ได้ตามปกติ, ความจงรักภักดี, ถูกนำมาใช้เช่นนี้เป็นวิธีที่ดีที่จะบอกวิธีที่ดีที่ผลการวัดที่เป็นไปได้ของเปรียบเทียบกับผลการวัดที่เป็นไปได้ของที่เป็นรัฐที่เอาท์พุทที่เหมาะและคือการประสบความสำเร็จ (อาจผสม) รัฐหลังจากกระบวนการเสียงบาง ในขณะที่เรากำลังเปรียบเทียบรัฐนี้เป็น $F\left(\left|\psi\right>, \rho\right)$ $\rho$ $\left|\psi\right>$ $\left|\psi\right>$ $\rho$

F (| ψ ⟩, ρ) = \sqrt{⟨ ψ | ρ | ψ ⟩} .

$F\left(\left|\psi\right>, \rho\right) = \sqrt{\left<\psi\right|\rho\left|\psi\right>}.$

อธิบายทั้งเสียงและความผิดพลาดในกระบวนการแก้ไขโดยใช้ผู้ประกอบการ Kraus ที่เป็นช่องทางเสียงกับผู้ประกอบการ Kraus และเป็นช่องทางในการแก้ไขข้อผิดพลาดกับ Kraus ผู้ประกอบการรัฐหลังจากที่เสียงเป็นและสถานะหลังจากทั้งเสียงรบกวนและการแก้ไขข้อผิดพลาดคือ $\mathcal N$ $N_i$ $\mathcal E$ $E_j$

ρ^{'} = N (| ψ ⟩ ⟨ ψ |) = \sum_{i} N_{i} | ψ ⟩ ⟨ ψ | N_{i}^{†}

$\rho' = \mathcal N\left(\left|\psi\rangle\langle\psi\right|\right) = \sum_iN_i\left|\psi\rangle\langle\psi\right|N_i^\dagger$

ρ = E \circ N (| ψ ⟩ ⟨ ψ |) = \sum_{i, j} E_{j} N_{i} | ψ ⟩ ⟨ ψ | N_{i}^{†} E_{j}^{†} .

$\rho = \mathcal E\circ\mathcal N\left(\left|\psi\rangle\langle\psi\right|\right) = \sum_{i, j}E_jN_i\left|\psi\rangle\langle\psi\right|N_i^\dagger E_j^\dagger.$

ความจงรักภักดีของเรื่องนี้จะได้รับจาก

\begin{aligned} F (| ψ ⟩, ρ) & = \sqrt{⟨ ψ | ρ | ψ ⟩} \\ = \sqrt{\sum_{i, j} ⟨ ψ | E_{j} N_{i} | ψ ⟩ ⟨ ψ | N_{i}^{†} E_{j}^{†} | ψ ⟩} \\ = \sqrt{\sum_{i, j} ⟨ ψ | E_{j} N_{i} | ψ ⟩ ⟨ ψ | E_{j} N_{i} {| ψ ⟩}^{*}} \\ = \sqrt{\sum_{i, j} | ⟨ ψ | E_{j} N_{i} | ψ ⟩ |^{2}} . \end{aligned}

$\begin{align}F\left(\left|\psi\right>, \rho\right) &= \sqrt{\left<\psi\right|\rho\left|\psi\right>} \\ &= \sqrt{\sum_{i, j}\left<\psi\right|E_jN_i\left|\psi\rangle\langle\psi\right|N_i^\dagger E_j^\dagger\left|\psi\right>} \\&= \sqrt{\sum_{i, j}\left<\psi\right|E_jN_i\left|\psi\rangle\langle\psi\right|E_jN_i\left|\psi\right>^*} \\ &= \sqrt{\sum_{i, j}\lvert\left<\psi\right|E_jN_i\left|\psi\right\rangle\rvert^2}.\end{align}$

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

F (| ψ ⟩, ρ) > F (| ψ ⟩, ρ^{'}) .

$F\left(\left|\psi\right>, \rho\right) > F\left(\left|\psi\right>, \rho'\right).$

ในฐานะที่เป็นความจงรักภักดีเป็นบวกนี้สามารถเขียนใหม่เป็น

\sqrt{\sum_{i, j} | ⟨ ψ | E_{j} N_{i} | ψ ⟩ |^{2}} > \sqrt{\sum_{i} | ⟨ ψ | N_{i} | ψ ⟩ |^{2}} .

$\sqrt{\sum_{i, j}\lvert\left<\psi\right|E_jN_i\left|\psi\right\rangle\rvert^2} > \sqrt{\sum_i\lvert\left<\psi\right|N_i\left|\psi\right\rangle\rvert^2}.$

\sum_{i, j} | ⟨ ψ | E_{j} N_{i} | ψ ⟩ |^{2} > \sum_{i} | ⟨ ψ | N_{i} | ψ ⟩ |^{2} .

$\sum_{i, j}\lvert\left<\psi\right|E_jN_i\left|\psi\right\rangle\rvert^2 > \sum_i\lvert\left<\psi\right|N_i\left|\psi\right\rangle\rvert^2.$

แยกเข้าไปในส่วนหนึ่ง correctable, ซึ่งและส่วนที่ไม่ใช่ correctable, ซึ่ง σแสดงถึงความน่าจะเป็นของข้อผิดพลาดที่สามารถแก้ไขได้เช่น $\mathcal N$ $\mathcal N_c$ $\mathcal E\circ\mathcal N_c\left(\left|\psi\rangle\langle\psi\right|\right) = \left|\psi\rangle\langle\psi\right|$ $\mathcal N_{nc}$ $\mathcal E\circ\mathcal N_{nc}\left(\left|\psi\rangle\langle\psi\right|\right) = \sigma$ $\mathbb P_c$ และไม่สามารถแก้ไขได้ (เช่นเกิดข้อผิดพลาดมากเกินไปในการสร้างสถานะอุดมคติ) เมื่อให้ที่เท่าเทียมกันจะได้รับการสันนิษฐานโดยสมมติ $\mathbb P_{nc}$

\sum_{i, j} | ⟨ ψ | E_{j} N_{i} | ψ ⟩ |^{2} = P_{c} + P_{n c} ⟨ ψ | σ | ψ ⟩ \geq P_{c},

$\sum_{i, j}\lvert\left<\psi\right|E_jN_i\left|\psi\right\rangle\rvert^2 = \mathbb P_c + \mathbb P_{nc}\left<\psi\vert\sigma\vert\psi\right> \geq \mathbb P_c,$

⟨ ψ | σ | ψ ⟩ = 0

$\left<\psi\vert\sigma\vert\psi\right> = 0$ . นั่นคือ 'การแก้ไข' ที่ผิดพลาดซึ่งจะฉายลงบนผลลัพธ์มุมฉากเป็นค่าที่ถูกต้อง

สำหรับ qubits โดยมีความน่าจะเป็นของข้อผิดพลาดในแต่ละ qubit เป็น ( หมายเหตุ : นี่ไม่เหมือนกับพารามิเตอร์สัญญาณรบกวนซึ่งจะต้องใช้ในการคำนวณความน่าจะเป็นของข้อผิดพลาด) ความน่าจะเป็นที่มี แก้ไขข้อผิดพลาดได้ (สมมติว่า qubits ถูกใช้เพื่อเข้ารหัส qubits อนุญาตให้เกิดข้อผิดพลาดได้ถึง qubits กำหนดโดย Singleton bound ) คือ $n$ $p$ $n$ $k$ $t$ $n-k\geq 4t$ )

\begin{aligned} P_{c} & = \sum_{j}^{t} (\binom{n}{j}) p^{j} {(1 - p)}^{n - j} \\ = {(1 - p)}^{n} + n p {(1 - p)}^{n - 1} + \frac{1}{2} n (n - 1) p^{2} {(1 - p)}^{n - 2} + O (p^{3}) \\ = 1 - (\binom{n}{t + 1}) p^{t + 1} + O (p^{t + 2}) \end{aligned}

$\begin{align} \mathbb P_c &=\sum_j^t {n\choose j}p^j\left(1-p\right)^{n-j}\\ &= \left(1-p\right)^n + np\left(1-p\right)^{n-1} + \frac 12n\left(n-1\right)p^2\left(1-p\right)^{n-2} + \mathcal O\left(p^3\right) \\ &= 1 - {n\choose{t+1}}p^{t+1} + \mathcal O\left(p^{t + 2}\right)\end{align}$

$N_i = \sum_j\alpha_{i, j}P_j$ $P_j$ $\chi_{j, k} = \sum_i\alpha_{i, j}\alpha^*_{i, k}$

\sum_{i} | ⟨ ψ | N_{i} | ψ ⟩ |^{2} = \sum_{j, k} χ_{j, k} ⟨ ψ | P_{j} | ψ ⟩ ⟨ ψ | P_{k} | ψ ⟩ \geq χ_{0,, 0},

$\sum_i\lvert\left<\psi\right|N_i\left|\psi\right\rangle\rvert^2 = \sum_{j, k}\chi_{j, k}\left<\psi\right|P_j\left|\psi\right\rangle\left<\psi\right|P_k\left|\psi\right\rangle\geq\chi_{0, ,0},$

χ_{0, 0} = {(1 - p)}^{n}

$\chi_{0, 0} = \left(1-p\right)^n$

1 - (\binom{n}{t + 1}) p^{t + 1} ⪆ {(1 - p)}^{n} .

$1 - {n\choose{t+1}}p^{t+1} \gtrapprox\left(1-p\right)^n.$

ρ ≪ 1

$\rho \ll 1$

p

$p$

p^{t + 1}

$p^{t+1}$

p

$p$

$p$ $p^{t+1}$ $p$ $n=5$ $t=1$ $p\approx 0.29$

แก้ไขจากความคิดเห็น:

$\mathbb P_c + \mathbb P_{nc} = 1$

\sum_{i, j} | ⟨ ψ | E_{j} N_{i} | ψ ⟩ |^{2} = ⟨ ψ | σ | ψ ⟩ + P_{c} (1 - ⟨ ψ | σ | ψ ⟩) .

$\sum_{i, j}\lvert\left<\psi\right|E_jN_i\left|\psi\right\rangle\rvert^2 = \left<\psi\vert\sigma\vert\psi\right> + \mathbb P_c\left(1-\left<\psi\vert\sigma\vert\psi\right>\right).$

1 - (1 - ⟨ ψ | σ | ψ ⟩) (\binom{n}{t + 1}) p^{t + 1} ⪆ {(1 - p)}^{n},

$1-\left(1-\left<\psi\vert\sigma\vert\psi\right>\right){n\choose{t+1}}p^{t+1} \gtrapprox\left(1-p\right)^n,$

$1$

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

— Mithrandir24601
แหล่งที่มา

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

— เอ็มสเติร์น

@ M.Stern ดังนั้นนี่คือการประมาณการ (หยาบมาก) เมื่อการแก้ไขข้อผิดพลาด 'ลดข้อผิดพลาด' (เช่นเพิ่มความน่าเชื่อถือด้วยจำนวนเล็กน้อยหลังจากใช้เสียงรบกวน) ดังนั้นจึงไม่ใช่เกณฑ์การยอมรับข้อบกพร่องที่แน่นอน การดำเนินการแก้ไขข้อผิดพลาดอาจเพิ่มความเที่ยงตรงหลังจากเสียงรบกวนไปบ้าง แต่ก็ไม่ได้รีเซ็ตหรืออะไรก็ตามดังนั้นความเที่ยงตรงจะลดลง (และข้อผิดพลาด) เผยแพร่แม้ว่าการแก้ไขข้อผิดพลาดจะถูกนำไปใช้อย่างต่อเนื่องแสดงการแก้ไขข้อผิดพลาด ด้วยตัวมันเองไม่เพียงพอสำหรับการยอมรับความผิด

— Mithrandir24601

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

— เอ็มสเติร์น

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

— Mithrandir24601

4

มีคำตอบทางคณิตศาสตร์ที่ดีอยู่แล้วดังนั้นฉันจะลองและให้คำตอบที่เข้าใจง่าย

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

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

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

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

— 3244611user
แหล่งที่มา

4

รุ่นคลาสสิก

คิดเกี่ยวกับกลยุทธ์ง่ายๆของการแก้ไขข้อผิดพลาดแบบคลาสสิก คุณมีบิตที่คุณต้องการเข้ารหัส

0 \mapsto 00000 1 \mapsto 11111

$0\mapsto 00000\qquad 1\mapsto 11111$ ฉันเลือกที่จะเข้ารหัสมันเป็น 5 บิต แต่เลขคี่ใด ๆ ที่ทำ (ยิ่งดี) ทีนี้สมมติว่ามีข้อผิดพลาดแบบฟลิปบิตเกิดขึ้นดังนั้นสิ่งที่เรามีคือ

01010

$01010.$ สิ่งนี้เคยเป็นรหัสที่เข้ารหัส 0 หรือ 1 หรือไม่? ถ้าเราสมมติว่าความน่าจะเป็นของความผิดพลาดต่อบิต

p

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

ในทางกลับกันถ้าเรารู้ว่า $p>\frac12$ เรายังสามารถแก้ไขได้ คุณต้องการลงคะแนนเสียงข้างน้อย! อย่างไรก็ตามประเด็นก็คือคุณต้องทำสิ่งที่ตรงกันข้ามทั้งหมด มีเกณฑ์ที่คมชัดที่แสดงอย่างน้อยที่สุดคุณต้องรู้ว่าคุณกำลังทำงานอยู่ในระบอบการปกครองใด

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

เวอร์ชั่นควอนตัม

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

ลองนึกภาพคุณมีสถานะของ qubit ตรรกะเดียวที่เก็บไว้ในรหัสแก้ไขข้อผิดพลาดของควอนตัม $|\psi\rangle$ ข้าม $N$ qubits ทางกายภาพ ไม่สำคัญว่ารหัสนั้นคืออะไรนี่เป็นอาร์กิวเมนต์ทั่วไปที่สมบูรณ์ ตอนนี้จินตนาการว่ามีเสียงรบกวนมากจนทำลายสถานะควอนตัม $\lceil N/2\rceil$ qubits ("เสียงดังมาก" จริง ๆ แล้วหมายความว่าข้อผิดพลาดเกิดขึ้นกับความน่าจะเป็น 50:50 ซึ่งไม่ใกล้เคียงกับ 100% ซึ่งดังที่เราได้กล่าวไปแล้วว่าสามารถแก้ไขได้) เป็นไปไม่ได้ที่จะแก้ไขข้อผิดพลาดนั้น ฉันจะรู้ได้อย่างไร ลองนึกภาพฉันมีรุ่นที่ไม่มีเสียงอย่างสมบูรณ์และฉันเก็บ $\lfloor N/2\rfloor$ qubits และมอบ qubits ที่เหลือให้คุณ เราแต่ละคนแนะนำ qubits ว่างเปล่าเพียงพอเพื่อให้เราได้รับ $N$ ทั้งหมดใน qubits และเราทำการแก้ไขข้อผิดพลาด หากเป็นไปได้ที่จะทำการแก้ไขข้อผิดพลาดผลลัพธ์ก็คือเราทั้งคู่จะมีสถานะดั้งเดิม $|\psi\rangle$ . เราจะโคลนตรรกะบิต แต่การโคลนนั้นเป็นไปไม่ได้ดังนั้นการแก้ไขข้อผิดพลาดจะต้องเป็นไปไม่ได้

— DaftWullie
แหล่งที่มา

2

สำหรับฉันดูเหมือนว่าจะมีสองส่วนของคำถามนี้ (อีกหนึ่งเกี่ยวข้องกับชื่ออีกหนึ่งที่เกี่ยวข้องกับคำถามตัวเอง):

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

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

ในวันที่ 1)

การแก้ไขข้อผิดพลาดใช้งานได้กับอัตราข้อผิดพลาดขนาดใหญ่ (เล็กกว่า $1/2$ ) ยกตัวอย่างรหัสการทำซ้ำ 3 ควิบิตอย่างง่าย อัตราความผิดพลาดเชิงตรรกะเป็นเพียงความน่าจะเป็นที่เสียงส่วนใหญ่โหวตผิด (เส้นสีส้มคือ $f(p)=p$ สำหรับการเปรียบเทียบ):

ดังนั้นเมื่อใดก็ตามที่อัตราความผิดพลาดทางกายภาพ $p$ อยู่ด้านล่าง $1/2$ อัตราข้อผิดพลาดเชิงตรรกะมีขนาดเล็กกว่า $p$ . อย่างไรก็ตามโปรดทราบว่ามีประสิทธิภาพโดยเฉพาะอย่างยิ่งสำหรับขนาดเล็ก $p$ เนื่องจากรหัสจะเปลี่ยนอัตราจาก $\mathcal{O}(p)$ เพื่อ $\mathcal{O}(p^2)$ พฤติกรรม.

ในวันที่ 2)

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

— M. Stern
แหล่งที่มา

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

— glS

@glS ฉันสงสัยว่ามี "universal lower threshold" เช่นค่าความผิดพลาดด้านบนซึ่งไม่มีโปรโตคอลการแก้ไขข้อผิดพลาดที่ยอมรับได้ อย่างไรก็ตามค่าควรขึ้นอยู่กับทั้งชุดเกตและรุ่นข้อผิดพลาดของคุณ ผู้คนมักจะสนใจผลลัพธ์ในเชิงบวกมากขึ้นที่นี่ (แสดงการมีอยู่ของโปรโตคอลการยอมรับความผิดที่ดี) อาจเป็นเรื่องที่น่าสนใจที่จะค้นหาขอบเขตบนเพื่อดู "เหลือพื้นที่เท่าไร" เพื่อทำให้แผนการทนต่อความผิดของเราดีขึ้น ฉันเดาว่าห้องเหลือไม่มาก

— Jalex Stark

@glS คุณถูกต้องการคำนวณเชิงปริมาณจริงจะช่วยปรับปรุงคำตอบนี้ ฉันคิดว่าการคำนวณเหล่านี้มักจะทำตัวเลข? แต่ฉันก็อยากรู้เกี่ยวกับสิ่งนี้

— เอ็มสเติร์น

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

— M. Stern

@M.Stern I don't have any theorem-based evidence, and I'm not an expert in the area. I was just guessing based on the amount of work done and on how large the best thresholds are.

— Jalex Stark

2

You need a surprisingly large number of quantum gates to implement a quantum error correcting code in a fault-tolerant manner. One part of the reason is that there are many errors to detect since a code that can correct all single qubit errors already requires 5 qubits and each error can be of three kinds (corresponding to unintentional X, Y, Z gates). Hence to even just correct any single qubit error, you already need logic to distinguish between these 15 errors plus the no-error situation: $XIIII$ , $YIIII$ , $ZIIII$ , $IXIII$ , $IYIII$ , $IZIII$ , $IIXII$ , $IIYII$ , $IIZII$ , $IIIXI$ , $IIIYI$ , $IIIZI$ , $IIIIX$ , $IIIIY$ , $IIIIZ$ , $IIIII$ where $X$ , $Y$ , $Z$ are the possible single qubit errors and $I$ (identity) denotes the no-error-for-this-qubit situation.

The main part of the reason is, however, that you cannot use straight-forward error detection circuitry: Every CNOT (or every other nontrivial 2 or more qubit gate) forwards errors in one qubit to another qubit which would be disastrous for the most trivial case of a single qubit error correcting code and still very bad for more sophisticated codes. Hence a fault-tolerant (useful) implementation of needs even more effort than one might naively think.

With many gates per error correcting step, you can only permit a very low error rate per step. Here yet another problem arises: Since you may have coherent errors, you must be ready for the worst case that an error $\epsilon$ propagates not as $N \epsilon$ after N single qubit gates but as $N^2 \epsilon$ . This value must remain sufficiently low such that you overall gain after correcting some (but not all) errors, for example single qubit errors only.

An example for a coherent error is an implementation of a gate $G$ that does, to first order, not simply $G$ but $G + \sqrt{\epsilon} X$ which you might call an error of $\epsilon$ because that is the probability corresponding to the probability amplitude $\sqrt{\epsilon}$ and hence the probability that a measurement directly after the gate reveals that it acted as the error $X$ . After $N$ applications of this gate, again to first order, you have actually applied $G^N + N \sqrt{\epsilon} G^N X$ (if G and X commute, otherwise a more complicated construct that has $N$ distinct terms proportional to $\sqrt{\epsilon}$ ). Hence you would, if measuring then, find an error probability of $N^2 \epsilon$ .

Incoherent errors are more benign. Yet if one must give a single value as an error threshold, then one cannot choose to only assume benign errors!

— pyramids
แหล่งที่มา

thanks for the answer, but I would appreciate if you could expand the answer to say more about some of the points here. In particular, 1) what do you mean exactly by saying that you need many gates in the error correcting code because there are "many errors to detect"? 2) What do you mean with "straight-forward logical construct"? 3) Why do "coherent errors" imply an error propagation scaling like

N^{2} ϵ

$N^2 \epsilon$ instead of

N ϵ

$N\epsilon$ ?

— glS

@glS I have substantially expanded the answer to address all your questions. Did I manage to do that?

— pyramids