เราสามารถเร่งอัลกอริทึมของโกรเวอร์ด้วยการรันกระบวนการแบบขนานได้หรือไม่?

ในการคำนวณแบบคลาสสิกเราสามารถรันการค้นหาคีย์ (เช่น AES) โดยการเรียกใช้โหนดการคำนวณแบบขนานให้มากที่สุด

เป็นที่ชัดเจนว่าเราสามารถใช้อัลกอริทึมของ Grover ได้เช่นกัน

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

classical-computing grovers-algorithm cryptography

คำตอบ:

แน่นอน! ลองนึกภาพคุณ $K=2^k$ สำเนาของ oracle การค้นหา $U_S$ ที่คุณสามารถใช้ โดยปกติคุณจะต้องค้นหาซ้ำการกระทำ

H^{\otimes n} (I_{n} - 2 | 0 ⟩ ⟨ 0 |^{\otimes n}) H^{\otimes n} U_{S},

$H^{\otimes n}(\mathbb{I}_n-2|0\rangle\langle 0|^{\otimes n})H^{\otimes n}U_S,$ เริ่มต้นจากสถานะเริ่มต้น

(H | 0 ⟩)^{\otimes n}

$(H|0\rangle)^{\otimes n}$ . ต้องใช้เวลา

Θ (\sqrt{N})

$\Theta(\sqrt{N})$ . (ฉันกำลังใช้

I_{n}

$\mathbb{I}_n$ เพื่อแสดงถึง

2^{n} \times 2^{n}

$2^n\times 2^n$ เมทริกซ์เอกลักษณ์.)

คุณสามารถแทนที่ด้วย $2^k$ สำเนาแบบขนานซึ่งแต่ละดัชนีโดย $x\in\{0,1\}^k$ ใช้งาน

(I_{k} \otimes H^{\otimes (n - k)}) I_{k} \otimes (I_{n - k} - 2 | 0 ⟩ ⟨ 0 |^{\otimes (n - k)}) (I_{k} \otimes H^{\otimes (n - k)}) U_{S}

$\left(\mathbb{I}_k\otimes H^{\otimes (n-k)}\right)\mathbb{I}_k\otimes(\mathbb{I}_{n-k}-2|0\rangle\langle 0|^{\otimes (n-k)})\left(\mathbb{I}_k\otimes H^{\otimes (n-k)}\right)U_S$ และเริ่มจากรัฐ

| x ⟩ (H | 0 ⟩)^{\otimes (n - k)}

$|x\rangle(H|0\rangle)^{\otimes(n-k)}$ เวลาที่ใช้ในการรันสิ่งเหล่านี้จะลดลงเป็น

O (\sqrt{N / K})

$O(\sqrt{N/K})$ ในราคาที่กำหนด

K

$K$ เพิ่มพื้นที่ว่าง

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

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

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

x

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

— glS

N

$N$ ไปที่อินฟินิตี้ แต่

K

$K$ ไม่. ปัญหาของคุณเริ่มใหญ่ขึ้น แต่ทรัพยากรของคุณยังน้อยอยู่

— AHusain

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

K

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

— Niel de Beaudrap

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

คุณยอมรับว่าเราต้องการ $\sqrt{N}$ การดำเนินงานสำหรับกรณีที่ไม่ขนาน สมมติว่าเรามีสองโหนดและเราแยกรายการองค์ประกอบ N เป็นสองขนาดรายการ $N_1,N_2$ . การค้นหาในรายการย่อยจะเกิดขึ้น $\sqrt{N_1},\sqrt{N_2}$ .

อย่างไรก็ตามเรามีสิ่งนั้น

\sqrt{N} = \sqrt{N_{1} + N_{2}} \leq \sqrt{N_{1}} + \sqrt{N_{2}}

$\sqrt{N} = \sqrt{N_1+N_2} \le \sqrt{N_1} + \sqrt{N_2}$

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

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

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

สำหรับ N1 = N2 ยังคงเป็นความไม่เท่าเทียมกัน: sqrt (2) * sqrt (N1) <2 * sqrt (N1)

— Mariia Mykhailova

โอ้จริง ๆ ในหัวของฉัน $ \ sqrt {a b} = \ sqrt {a} \ sqrt {b} $ ฉันคิดว่า ฉันควรหยุดตอบคำถามที่นี่ตอนเที่ยงคืนและเมื่อเหนื่อย ขอบคุณสำหรับการชี้ให้เห็นว่า

— cnada

@cnada: มีแนวคิดที่ซับซ้อนแตกต่างกันอย่างน้อยสองประการซึ่งทั้งสองอย่างนี้เกี่ยวข้องกับการเร่งความเร็ว หนึ่งคือความซับซ้อนของขนาดและหนึ่งคือความซับซ้อนเชิงลึก เว้นแต่ระบุไว้เป็นอย่างอื่นเรามักจะพิจารณาความซับซ้อนของขนาด แต่ความซับซ้อนเชิงลึกยังคงเป็นสิ่งที่น่าสนใจอย่างมากในความซับซ้อนของการคำนวณควอนตัมเช่นใน MBQC [arXiv: quant-ph / 0301052 , arXiv: 0704.1736 ] และผลลัพธ์ล่าสุด การแยกความลึกแบบไม่มีเงื่อนไข[arXiv: 1704.00690 ]

— Niel de Beaudrap

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

— cnada

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

k \in O (1)

$k \in O(1)$ กระบวนการโกรเวอร์แบบขนาน แต่เป็นคำตอบของ DaftWullie แนะนำ (และพิจารณาโพสต์โพรเซสซิง - คลาสสิก) ความซับซ้อนที่ลึกลงไป

\sqrt{N}

$\sqrt N$ ถึง

\log (k) \sqrt{N / k}

$\log(k) \sqrt{N/k}$ สำหรับ

k (N) \in Ω (1)

$k(N) \in \Omega(1)$ กระบวนการโกรเวอร์แบบขนานซึ่งเป็นการปรับปรุงโดยปัจจัย

\sqrt{k} / \log (k)

$\sqrt{k}/\!\!\;\log(k)$ (ปัจจัยบันทึกมาจากการระบุว่าหากกระบวนการใดพบวิธีแก้ปัญหา)

— Niel de Beaudrap