गणना की लंबाई के साथ सार्वभौमिक गेट्स पैमाने के माध्यम से फाटकों को कैसे अनुमानित किया जाता है?

मैं समझता हूं कि एक रचनात्मक सबूत है कि मनमाने ढंग से गेट्स को एक परिमित सार्वभौमिक गेट सेट द्वारा अनुमानित किया जा सकता है, जो कि सोलोवे-कितेव प्रमेय है ।
हालांकि, सन्निकटन एक त्रुटि का परिचय देता है, जो एक लंबी गणना में फैलता और जमा होता है। यह निश्चित रूप से गणना की लंबाई के साथ बुरी तरह से पैमाने पर होगा? संभवतः एक पूरे सर्किट के लिए एक पूरे फाटक के लिए सन्निकटन एल्गोरिदम को लागू किया जा सकता है, एक भी गेट पर नहीं। लेकिन यह पैमाने गणना की लंबाई के साथ कैसे होता है (अर्थात द्वार के आयाम के साथ अनुमानित पैमाने कैसे होता है)? गेट सन्निकटन गेट संश्लेषण से कैसे संबंधित है? क्योंकि मैं सोच सकता था कि यह गणना की अंतिम लंबाई को प्रभावित करता है?
मेरे लिए और भी अधिक परेशान: यदि गेट अनुक्रम संकलित किए जाने के समय गणना की लंबाई ज्ञात नहीं है तो क्या होगा?

— एम। स्टर्न
स्रोत

$A$ $\left\lVert A\right\rVert$ $A$ $A$ $\epsilon$

O (\log^{c} \frac{1}{ϵ})

$\mathcal O\left(\log^c\frac 1\epsilon\right)$

c < 4

$c<4$

पहले भाग के लिए:

सन्निकटन एक त्रुटि का परिचय देता है, जो एक लंबी गणना में फैलता और जमा होता है

खैर, यह प्रेरण द्वारा दिखाया जा सकता है कि एक मैट्रिक्स का उपयोग करके किसी दूसरे को अनुमानित करने के माध्यम से जमा होने वाली त्रुटियां सबडिटिव हैं (उदाहरण के लिए एंड्रयू चाइल्ड के व्याख्यान नोट )। यानी, एकतरफा मैट्रिसेस के लिए और , । $U_i$ $V_i$ $\left\lVert U_i - V_i\right\rVert < \epsilon\,\forall\, i \in \left\lbrace1, 2, \ldots, t\right \rbrace\implies \left\lVert U_t\ldots U_2U_1 - V_t\ldots V_2V_1\right\rVert \leq t\epsilon$

कार्यान्वयन के संदर्भ में इसका मतलब यह है कि, एक समग्र त्रुटि के लिए को प्राप्त करने से अधिक नहीं है, प्रत्येक गेट को , या के भीतर सन्निकट किए जाने की आवश्यकता है $\epsilon$ $\epsilon/t$

सर्किट के लिए एक पूरे के रूप में सन्निकटन लागू करना

प्रत्येक व्यक्ति के द्वार के लिए सन्निकटन लागू करने के समान है, प्रत्येक एक व्यक्तिगत त्रुटि के साथ जो फाटकों की संख्या से विभाजित किए गए पूरे सर्किट से अधिक नहीं है।

गेट संश्लेषण के संदर्भ में, नया गेट सेट बनाने के लिए गेट सेट उत्पादों को ले कर एल्गोरिदम का प्रदर्शन किया जाता है, जो एक लिए नेट बनाता है (के लिए कोई भी ) मौजूद है। पहचान से शुरू करते हुए, एक नए एकात्मक को नए गेट सेट से पुनरावर्ती पाया जाता है ताकि लक्ष्य एकात्मक को एक तंग नेट दौर मिल सके। अजीब तरह से पर्याप्त है, इस ऑपरेशन को करने के लिए एक शास्त्रीय एल्गोरिथ्म का समय भी , जो उप-बहुपद समय है। हालांकि , प्रति के रूप में $\Gamma$ $\Gamma_0$ $\epsilon^2$ $\operatorname{SU}\left(d\right)$ $A \in \operatorname{SU}\left(d\right),\, \exists U\in\Gamma_0\, s.t. \left\lVert A-U\right\rVert\leq\epsilon^2$ $\mathcal O\left(\mathit{poly} \log 1/\epsilon\right)$ हैरो, Recht, चुआंग , में -dimensions, त्रिज्या का एक गेंद के रूप में के आसपास एक मात्रा है , तेजी से इस तराजू में आयामों के एक गैर निश्चित संख्या के लिए। $d$ $\epsilon$ $\operatorname{SU}\left(d\right)$ $\propto \epsilon^{d^2-1}$ $d^2$

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

के लिए द्वार, समग्र (समय और गेट) जटिलता तो है $t$ ।

O (t p o l y \log \frac{t}{ϵ})

$\mathcal O\left(t\, \mathit{poly} \log \frac t\epsilon\right)$

मध्यस्थ माप के बिना एकात्मक सर्किट मॉडल का उपयोग करते समय , लागू होने वाले फाटकों की संख्या हमेशा गणना से पहले जानी जाएगी। हालांकि, यह मान लेना संभव है कि जब मध्यस्थ माप का उपयोग किया जाता है तो ऐसा नहीं होता है, इसलिए जब आप अनुमान लगाना चाहते हैं कि कितने द्वार अज्ञात हैं, तो यह कह रहा है कि अज्ञात है। और यदि आप नहीं जानते कि क्या है, तो आप स्पष्ट रूप से प्रत्येक गेट को एक त्रुटि अनुमानित नहीं कर सकते । यदि आप गेट्स की संख्या पर एक बाउंड जानते हैं (कहते हैं, ), तो आप समग्र त्रुटि प्राप्त करने के लिए प्रत्येक गेट को भीतर अनुमानित कर सकते हैं। $t$ $t$ $\epsilon/t$ $t_{\text{max}}$ $\epsilon/t_{\text{max}}$ $\leq\epsilon$ और जटिलता हालाँकि यह संख्या पर कोई ऊपरी सीमा नहीं है गेट्स को ज्ञात है , तो प्रत्येक गेट को कुछ (छोटे) लिए अनुमानित किया जाएगा , जिसके परिणामस्वरूप कार्यान्वित गेटों की संख्या के लिए एक समग्र त्रुटि (जो शुरू में अज्ञात है) , के साथ समग्र जटिलता

O (t p o l y \log \frac{t_{max}}{ϵ}),

$\mathcal O\left(t\, \mathit{poly} \log \frac {t_{\text{max}}}{\epsilon}\right),$

ϵ^{'}

$\epsilon'$

\leq t^{'} ϵ

$\leq t'\epsilon$

t^{'}

$t'$

O (t^{'} p o l y \log \frac{1}{ϵ^{'}}) .

$\mathcal O\left(t'\, \mathit{poly} \log \frac {1}{\epsilon'}\right).$

बेशक, इस की कुल त्रुटि अभी भी निर्बाध है, इसलिए त्रुटि को बांधे रखने का एक सरल ¹ तरीका यह होगा कि हर बार, कारक, , के कारक द्वारा त्रुटि को कम किया जाए, ताकि गेट होगा त्रुटि साथ लागू किया गया । जटिलता तब एक समग्र (अब बहुपद) जटिलता हालांकि यह एक बंधी हुई त्रुटि की गारंटी का लाभ है। $2$ $n^{th}$ $\epsilon/2^n$

O (p o l y \log \frac{2^{n}}{ϵ^{'}}) = O (p o l y n \log \frac{1}{ϵ^{'}}),

$\mathcal O\left(\mathit{poly} \log \frac {2^n}{\epsilon'}\right) = \mathcal O\left(\mathit{poly}\, n\log \frac {1}{\epsilon'}\right),$

O (p o l y t \log \frac{1}{ϵ}),

$\mathcal O\left(\mathit{poly}\, t \log \frac {1}{\epsilon}\right),$

यह बहुत बुरा नहीं है , इसलिए मुझे उम्मीद है कि (जब फाटकों की संख्या अज्ञात है) शास्त्रीय कंप्यूटर कम से कम सही फाटकों के साथ आने में सक्षम रहेंगे, क्योंकि क्वांटम प्रोसेसर को उनकी आवश्यकता होगी। यदि वर्तमान में नहीं है, तो उम्मीद है कि एक बार क्वांटम प्रोसेसर काफी अच्छा हो जाएगा कि यह वास्तव में एक समस्या बन जाएगा!

^{1 हालांकि, संभवतः सबसे कुशल नहीं है}

— Mithrandir24601
स्रोत