क्या हम समानांतर प्रक्रियाओं को चलाकर ग्रोवर के एल्गोरिथ्म को गति दे सकते हैं?

शास्त्रीय कंप्यूटिंग में, हम यथासंभव कम से कम समानांतर कंप्यूटिंग नोड्स चलाकर महत्वपूर्ण खोज (उदाहरण के लिए एईएस) चला सकते हैं।

यह स्पष्ट है कि हम कई ग्रोवर के एल्गोरिदम भी चला सकते हैं।

मेरा सवाल है ; शास्त्रीय कंप्यूटिंग में एक से अधिक ग्रोवर के एल्गोरिथ्म का उपयोग करना संभव है?

classical-computing grovers-algorithm cryptography

— kelalaka
स्रोत

जवाबों:

निश्चित रूप से! आप कल्पना कीजिए $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$ ), और यह स्केलिंग नहीं बदलता है। लेकिन यह मूलभूत समय को बदल देता है। हम जानते हैं कि ग्रोवर का एल्गोरिथ्म बिल्कुल इष्टतम है। यह एक एकल ओरेकल के साथ पूर्ण न्यूनतम समय संभव लेता है। तो, यह जानकर कि आपको ए $\sqrt{K}$ समय के साथ सुधार विशिष्ट मान के उस मानक मान के संबंध में उपयोगी है, जिसके विशिष्ट मूल्य पर $N$ ।

— DaftWullie
स्रोत

लेकिन अगर आप ऐसा करते हैं, तो शास्त्रीय प्रदर्शन के साथ तुलना इसके कुछ अर्थ खो देती है, है ना? आखिरकार, आप ऑपरेशन को चलाकर शास्त्रीय खोज को गति दे सकते हैं जो किसी दिए जाने पर जांच करता है

x

$x$ सभी इनपुट पर समानांतर में लक्ष्य है। उपलब्ध संसाधनों पर स्पष्ट रूप से अतिरिक्त मान्यताओं की आवश्यकता है, लेकिन आपके तर्क में एक ही तरह की धारणाएं बनी हुई हैं

— glS

N

$N$ अनंत को जाता है लेकिन

K

$K$ नहीं करता। आपकी समस्या बड़ी हो गई है लेकिन आपके संसाधन कम हैं।

— AHusain

यह उत्तर सही है (हालांकि यह इष्टतम नहीं हो सकता है, क्योंकि DaftWullie चेतावनी देता है)। यह समानुपातीकरण के समान है जो शास्त्रीय सर्किट जटिलता में लेता है। यदि आप समानांतरकरण के कारण एक गति-अप चाहते हैं, तो आप सर्किट की गहराई को देखते हैं (क्योंकि कई प्रक्रियाओं का समन्वय करना कुल कार्य को कम करने वाला नहीं है )। यह भी अगर कोई फर्क नहीं पड़ता

K

$K$ स्थिर है --- या तो आप समानांतर से गहराई में सुधार में रुचि रखते हैं, या आप नहीं हैं। क्वांटम संगणना के साथ ही, अधिक कंप्यूटर को एक समस्या पर फेंकने से जादुई रूप से सब कुछ तेज नहीं होता है!

— नील डी बेउड्राप

एक अर्थ में, अगर हम इसे अलग-अलग नोड्स पर समानांतर में कर रहे थे, तो आप दौड़ने के लिए समय बचा सकते हैं। लेकिन अगर हम जटिलता के बारे में बात करते हैं (जो कि हम आम तौर पर स्पीडअप का उल्लेख करते हैं), तो हमें थोड़ा विश्लेषण की आवश्यकता है।

आप सहमत हैं कि हमें इसकी आवश्यकता है $\sqrt{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$ अंकन।

हालाँकि, यह तब भी दिलचस्प होगा, खासकर अगर हमें हार्डवेयर को क्लस्टर करना है क्योंकि हम क्विट या अन्य सीमाओं की संख्या में सीमित हैं।

— cnada
स्रोत

N1 = N2 के लिए यह अभी भी एक असमानता है: sqrt (2) * sqrt (N1) <2 * sqrt (N1)

— मरिआ मायखेलोवा

ओह वास्तव में। मेरे सिर में $ \ sqrt {a } = \ sqrt {a} \ sqrt {b} $ मैंने सोचा था। मुझे आधी रात को यहाँ जवाब देना बंद कर देना चाहिए और थक जाने पर। यह बात बताने के लिए धन्यवाद।

— cnada

@cnada: जटिलता की कम से कम दो अलग-अलग धारणाएं हैं, दोनों गति-गति के लिए प्रासंगिक हैं। एक आकार जटिलता है, और एक गहराई जटिलता है। जब तक अन्यथा निर्दिष्ट नहीं किया जाता है, हम अक्सर आकार जटिलता पर विचार करना पसंद करते हैं, लेकिन गहराई जटिलता अभी भी कुछ है जो क्वांटम कम्प्यूटेशनल जटिलता में बहुत रुचि रखती है, उदाहरण के लिए MBQC [arXiv: quant-ph / 0301052 , arviv: 0704.1736 ] और हाल ही में आए परिणाम बिना शर्त गहराई से पृथक्करण [arXiv: 1704.00690 ]।

— कील डी ब्यूड्रैप

@ नीलदेब्यूप्रैप मुझे लगा कि लोग गहराई की जटिलता को देखते हैं। लेकिन ग्रोवर के लिए, आकार और गहराई की जटिलता एक ही क्रम के बारे में है। यह समस्या के आकार में द्विघात है (आमतौर पर एन तत्वों की सूची के आकार के रूप में देखा जाता है)। क्या आपको लगता है कि यहां मेरा दृष्टिकोण सही नहीं है?

— cnada

आप कुछ भी गलत नहीं कह रहे हैं , मैं केवल यह इंगित कर रहा हूं कि आप आकार की जटिलता पर जोर दे रहे हैं और वास्तव में जटिलता को गहराई तक लाभ पहुंचाने के लिए काम नहीं कर रहे हैं। बहुत दिलचस्प नहीं होता है यदि आप केवल करते हैं

k \in O (1)

$k \in O(1)$ समानांतर ग्रोवर प्रक्रियाएं, लेकिन जैसा कि दफ्तुल्ली का जवाब बताता है (और शास्त्रीय पोस्ट-प्रोसेसिंग पर विचार करते हुए), गहराई जटिलता से जाती है

\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)$ (लॉग फैक्टर यह पहचानने से आता है कि अगर किसी प्रक्रिया में कोई समाधान मिला है)।

— नील डी ब्यूड्रैप