ग्रोवर का एल्गोरिथ्म: एक वास्तविक जीवन उदाहरण?

13

मैं इस बारे में काफी उलझन में हूं कि ग्रोवर के एल्गोरिदम का उपयोग कैसे किया जा सकता है और मैं एक उदाहरण के माध्यम से स्पष्टीकरण पर मदद मांगना चाहता हूं।

आइए मान लें कि तत्व डेटाबेस जिसमें रंग लाल, नारंगी, पीला, हरा, सियान, नीला, इंडिगो और वायलेट शामिल हैं, और इस क्रम में जरूरी नहीं है। मेरा लक्ष्य डेटाबेस में रेड ढूंढना है। $N=8$

ग्रोवर के एल्गोरिथ्म के लिए इनपुट क्विट है, जहां 3 क्विट्स डेटासेट के इंडेक्स को एनकोड करते हैं। मेरा भ्रम यहां आता है (परिसर के बारे में भ्रमित हो सकता है, इसलिए यहां भ्रम की स्थिति कहो), जैसा कि मैं समझता हूं, वास्तव में ओरेकल डेटासेट के सूचकांकों में से एक के लिए खोज करता है (3 qubits के सुपरपोजिशन द्वारा प्रतिनिधित्व), और इसके अलावा। ओरेकल "हार्डकोड" है जिसके लिए यह सूचकांक देखना चाहिए। $n = \log_2(N=8) = 3$

मेरे प्रश्न हैं:

मुझे यहाँ क्या गलत लगता है?
यदि दैवज्ञ वास्तव में डेटाबेस के सूचकांकों में से एक की तलाश कर रहा है, तो इसका मतलब है कि हम पहले से ही जानते हैं कि हम किस सूचकांक की तलाश कर रहे हैं, इसलिए खोज क्यों?
रंगों के साथ उपरोक्त स्थितियों को देखते हुए, क्या कोई इसे इंगित कर सकता है कि क्या ग्रोवर के साथ एक असंरचित डेटासेट में रेड की तलाश करना संभव है?

के लिए एक ओरेकल के साथ ग्रोवर के एल्गोरिदम के लिए कार्यान्वयन हैं । 111>, उदाहरण के लिए (या नीचे एक ही आर का कार्यान्वयन देखें): /quantum//a/2205 $n=3$

फिर से, मेरा भ्रम है, यह देखते हुए कि मैं डेटासेट में तत्वों की स्थिति नहीं जानता , एल्गोरिथ्म मुझे एक स्ट्रिंग की खोज करने की आवश्यकता है जो तत्वों की स्थिति को एनकोड करता है । मुझे कैसे पता चलेगा कि डेटासेट के असंरचित होने पर मुझे किस स्थिति की तलाश करनी चाहिए? $N$ $N$

आर कोड:

 #START
 a = TensorProd(TensorProd(Hadamard(I2),Hadamard(I2)),Hadamard(I2))
 # 1st CNOT
 a1= CNOT3_12(a)
 # 2nd composite
 # I x I x T1Gate
 b = TensorProd(TensorProd(I2,I2),T1Gate(I2)) 
 b1 = DotProduct(b,a1)
 c = CNOT3_02(b1)
 # 3rd composite
 # I x I x TGate
 d = TensorProd(TensorProd(I2,I2),TGate(I2))
 d1 = DotProduct(d,c)
 e = CNOT3_12(d1)
 # 4th composite
 # I x I x T1Gate
 f = TensorProd(TensorProd(I2,I2),T1Gate(I2))
 f1 = DotProduct(f,e)
 g = CNOT3_02(f1)
 #5th composite
 # I x T x T
 h = TensorProd(TensorProd(I2,TGate(I2)),TGate(I2))
 h1 = DotProduct(h,g)
 i = CNOT3_01(h1)
 #6th composite
 j = TensorProd(TensorProd(I2,T1Gate(I2)),I2)
 j1 = DotProduct(j,i)
 k = CNOT3_01(j1)
 #7th composite
 l = TensorProd(TensorProd(TGate(I2),I2),I2)
 l1 = DotProduct(l,k)
 #8th composite
 n = TensorProd(TensorProd(Hadamard(I2),Hadamard(I2)),Hadamard(I2))
 n1 = DotProduct(n,l1)
 n2 = TensorProd(TensorProd(PauliX(I2),PauliX(I2)),PauliX(I2))
 a = DotProduct(n2,n1)
 #repeat the same from 2st not gate
 a1= CNOT3_12(a)
 # 2nd composite
 # I x I x T1Gate
 b = TensorProd(TensorProd(I2,I2),T1Gate(I2))
 b1 = DotProduct(b,a1)
 c = CNOT3_02(b1)
 # 3rd composite
 # I x I x TGate
 d = TensorProd(TensorProd(I2,I2),TGate(I2))
 d1 = DotProduct(d,c)
 e = CNOT3_12(d1)
 # 4th composite
 # I x I x T1Gate
 f = TensorProd(TensorProd(I2,I2),T1Gate(I2))
 f1 = DotProduct(f,e)
 g = CNOT3_02(f1)
 #5th composite
 # I x T x T
 h = TensorProd(TensorProd(I2,TGate(I2)),TGate(I2))
 h1 = DotProduct(h,g)
 i = CNOT3_01(h1)
 #6th composite
 j = TensorProd(TensorProd(I2,T1Gate(I2)),I2)
 j1 = DotProduct(j,i)
 k = CNOT3_01(j1)
 #7th composite
 l = TensorProd(TensorProd(TGate(I2),I2),I2)
 l1 = DotProduct(l,k)
 #8th composite
 n = TensorProd(TensorProd(PauliX(I2),PauliX(I2)),PauliX(I2))
 n1 = DotProduct(n,l1)
 n2 = TensorProd(TensorProd(Hadamard(I2),Hadamard(I2)),Hadamard(I2))
 n3 = DotProduct(n2,n1)
 result=measurement(n3)
 plotMeasurement(result)

grovers-algorithm

— 01000001
स्रोत

3

ग्रोवर के एल्गोरिथ्म की

— DaftWullie

यह भी संबंधित: quantumcomputing.stackexchange.com/q/175/55

— glS

5

एक डेटाबेस के उपयोग के भीतर कुशल होने के लिए एक मुख्य धारणा यह है कि आप एक रैम से पते के डेटा के सुपरपोजिशन के साथ लोड कर सकते हैं, जिसे QRAM भी कहा जाता है (देखें https://arxiv.org/abs/0708.1879 )। फिर मान लें कि आपके पास पते के लिए एक राज्य, मूल्य के लिए एक राज्य और लोड ऑपरेशन है, जो संबंधित पते के मूल्य को मूल्य रजिस्टर में लोड करता है। इसलिए लोड ऑपरेशन चरण को करेगा

| x ⟩_{address} | 0 ⟩_{value} \to | x ⟩_{address} | load (x) \oplus 0 ⟩_{value} = | x ⟩_{address} | load (x) ⟩_{value} .

$|x\rangle_{\text{address}}|0\rangle_{\text{value}} \rightarrow |x\rangle_{\text{address}}|\textrm{load}(x)\oplus 0\rangle_{\text{value}} = |x\rangle_{\text{address}}|\textrm{load}(x)\rangle_{\text{value}}.$

पहले चरण में आप पता रजिस्टर पर हैडमार्ड गेट्स को लागू करते हैं और फिर दोनों रजिस्टरों पर लोड ऑपरेशन लागू करते हैं। तब आपके पास डेटाबेस में सभी मानों का एक सुपरपोजिशन होगा जो एक मूल्य रजिस्टर है। इसके बाद आप ग्रोवर एल्गोरिदम को किसी भी ओरेकल के साथ मूल्य रजिस्टर पर लागू करते हैं, जिसे आप किसी प्राइम या विशिष्ट मूल्य की तलाश में चाहते हैं। हम बाद जानते हैं

H_{address}^{\otimes n} | 0 ⟩_{address} | 0 ⟩_{value} = \frac{1}{2^{n / 2}} \sum_{x = 0}^{2^{n} - 1} | x ⟩_{address} | 0 ⟩_{value}

$H^{\otimes n}_{\text{address}} |0\rangle_{\text{address}}|\textrm0\rangle_{\text{value}}=\frac1{2^{n/2}}\sum_{x=0}^{2^n-1} |x\rangle_{\text{address}}|\textrm0\rangle_{\text{value}}$

apply load \to \frac{1}{2^{n / 2}} \sum_{x = 0}^{2^{n} - 1} | x ⟩_{address} | load (x) ⟩_{value}

$\text{apply load}\rightarrow \frac1{2^{n/2}}\sum_{x=0}^{2^n-1} |x\rangle_{\text{address}}|\textrm{load}(x)\rangle_{\text{value}}$

O (\sqrt{N})

$O(\sqrt{N})$ सही उत्तर पुनरावृत्तियों को उच्च संभावना के साथ मापा जाएगा। इस प्रकार, सही समाधान के रजिस्टर एड्रेस के साथ सही समाधान बहुत संभावित मापा जाएगा

x^{*}

$x^*$

| x^{*} ⟩_{address} | load (x^{*}) ⟩_{value} .

$|x^*\rangle_{\text{address}}|\textrm{load}(x^*)\rangle_{\text{value}}.$

हो सकता है कि आपके पास मुख्य समस्या डेटाबेस को समझने में है न कि ग्रोवर एल्गोरिथम। आप इसके लिए अध्याय 6.5 नीलसन एंड चुआंग में अधिक विस्तृत विवरण देख सकते हैं।

मुझे यह भी लगता है कि ग्रोवर एल्गोरिथम का सबसे उपयोगी अनुप्रयोग डेटाबेस अनुप्रयोग नहीं है, लेकिन किसी भी क्वांटम एल्गोरिथ्म पर आयाम प्रवर्धन ( https://arxiv.org/abs/quant-ph/0005055 देखें ) के रूप में इसका सामान्यीकरण है।

संपादित करें: मैंने सोचा था कि समस्या glS का उत्तर पहले से ही थोड़ा सा है: यदि हम एक ओरेकल बना सकते हैं, तो क्या समस्या पहले से ही हल नहीं हुई है? क्योंकि ओरेकल का निर्माण करने के लिए, हमें यह जानना होगा कि सही समाधान कैसा दिखता है। और अगर आपके पास कंप्यूटर विज्ञान में कोई पृष्ठभूमि नहीं है, तो यह प्रश्न आपके द्वारा उत्तर देना कठिन होगा। हालांकि, मान्यताओं के तहत अधिकांश वैज्ञानिक मानते हैं (NP P), यह पूरी तरह से NP- पूर्ण समस्याओं (जिन लोगों के पास अनुमानित सन्निकटन विधियाँ नहीं हैं) के सबसेट के लिए मामला है। हम एक ओरेकल का निर्माण कर सकते हैं, जो यह जांच सकता है कि क्या एक समाधान बहुपद समय में सही है, लेकिन एक ओरेकल का निर्माण करने के लिए, जो सही समाधान को ढूंढता है, कुशलता से गणना करने योग्य नहीं लगता है। $\neq$

— एलेक्स गो
स्रोत

मुझे नहीं लगता कि आपको इसके लिए P NP को होगा। उदाहरण के लिए, एक ऐसे मामले पर विचार करें, जिसमें आपके पास एक उच्च-आयामी qudit है जिसे एक qubit के साथ युग्मित किया गया है, इसलिए फ़ॉर्म । यह "एक फोन बुक" (संख्याओं की श्रृंखला) जैसी किसी चीज को एनकोड कर सकता है, प्रत्येक नंबर के साथ एक रिकॉर्ड (यहां बाइनरी)। आपका लक्ष्य उस को खोजना है जो से जुड़ा है । तब आप ग्रोवर के एल्गोरिथ्म को लागू कर सकते हैं, जो केवल आंतरिक डॉफ पर अभिनय करते हैं और सूचकांक को अछूता छोड़ देते हैं। बनाना आसान है: बस कुछ ऐसा बनाएँ जो ।

\neq

$\neq$

\sum_{k} | k ⟩ \otimes | s_{k} ⟩

$\sum_k |k\rangle\otimes|s_k\rangle$

k

$k$

s_{k} = + 1

$s_k=+1$

s_{k}

$s_k$

— glS

हां यह उदाहरण शायद पहले उदाहरण के रूप में समझना आसान है। लेकिन मुझे लगता है कि यह समझने के लिए कि ग्रोवर एल्गोरिथ्म महत्वपूर्ण समस्याओं के एक व्यापक वर्ग पर एक आवेदन के लिए उपयोगी है, P NP के पीछे का विचार महत्वपूर्ण है।

\neq

$\neq$

— एलेक्स गो

4

इस संबंधित प्रश्न में यह पहले से ही आंशिक रूप से चर्चा में है , लेकिन मैं यहां आपके द्वारा उठाए जाने वाले कुछ मुद्दों को विशेष रूप से संबोधित करने का प्रयास करूंगा।

आम तौर पर इस धारणा है कि एक एक प्रदर्शन करने में सक्षम है पर बात करते हुए ग्रोवर एल्गोरिथ्म टिकी हुई क्वेरी फार्म के आपरेशन जहां में सूचकांक है डेटाबेस, और जो भी जानकारी के लिए डेटाबेस देता ।

| i ⟩ \mapsto (- 1)^{f (x_{i})} | i ⟩,

$|i\rangle\mapsto(-1)^{f(x_i)}|i\rangle,$

i

$i$

x_{i}

$x_i$

i

$i$

आप के बारे में " के बारे में एक प्रश्न पूछ सकते हैं " के बारे में सोच सकते हैं । उदाहरण के लिए, " है अभाज्य संख्या? ", या " करता है संपत्ति है ?", जहां मतलब हो सकता है "लाल जा रहा है"। $f(x_i)$ $x_i$ $x_i$ $x_i$ $P$ $P$

यह ध्यान रखना महत्वपूर्ण है कि एक प्रश्न पूछ सकता है जो पूरी तरह से चिह्नित नहीं करता है । इसका मतलब यह है कि जब मैं एल्गोरिथ्म चलाता हूं और पुनर्प्राप्त करता , और इस प्रकार इसके साथ , मैं भी ज्ञान प्राप्त करता हूं जिसका उपयोग ऑरेकल बनाने के लिए नहीं किया गया था। $f$ $x_i$ $i$ $x_i$

हालांकि, ग्रोवर के एल्गोरिथ्म के सिद्धांत कार्यान्वयन के कई प्रमाणों में, जैसा कि आप दिखाते हैं, ऐसा नहीं है। दरअसल, इन प्रदर्शनों में सवाल है कि कहा जा रहा है, "तुच्छ" है इस अर्थ में कि में , और प्रश्न फार्म की है " है 3 के बराबर ?"। $x_i=i$ $x_i$

ऐसे मामले में, एल्गोरिथ्म वास्तव में विशेष रूप से उपयोगी नहीं है कि जवाब को ओरेकल में हार्डकोड किया जाना है, लेकिन यह सामान्य रूप से मामला नहीं है।

— GLS
स्रोत

आपके जवाब के लिए धन्यवाद! शायद यह एक वास्तविक जीवन उदाहरण प्रदान करना संभव होगा जहां ग्रोवर का "उपयोगी" कुछ वास्तविक डेटा पर लागू होता है जिसे प्रस्तुत किया गया है? उदाहरण के लिए, यह प्राइम और नॉन प्राइम के साथ 8 एलिमेंट डेटाबेस के साथ कैसे काम करेगा?

— 01000001

1

@ 01000001 मुझे विश्वास है कि cstheory.SE पर संबंधित प्रश्न पर यह उत्तर उत्तीर्ण हो सकता है। यह ग्रोवर का एक अच्छा उदाहरण है जिसका उपयोग एक nontrivial लिए किया जा रहा है । उनके मामले में, कोडित करता है कि क्या किसी बूलियन फॉर्मूला इनपुट से संतुष्ट है। एल्गोरिथ्म का उत्पादन इस प्रकार एक बूलियन फार्मूला को संतुष्ट करने वाला है

f

$f$

f

$f$

x

$x$

— glS