content/ex2/ex2-hi.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# व्यायाम २ - शोर का एल्गोरिथम\n",
    "## ऐतिहासिक पृष्ठभूमि\n",
    "\n",
    "कंप्यूटिंग में, हम अक्सर एक एल्गोरिथ्म के प्रदर्शन को मापते हैं कि यह इनपुट समस्या के आकार के साथ कैसे बढ़ता है। उदाहरण के लिए, जोड़ में एक एल्गोरिथम होता है जो हमारे द्वारा जोड़ी जा रही संख्याओं के आकार के साथ रैखिक रूप से बढ़ता है। कुछ कंप्यूटिंग समस्याएं हैं जिनके लिए सबसे अच्छा एल्गोरिदम हमने इनपुट के आकार के साथ तेजी से विकसित किया है, और इसका मतलब है कि अपेक्षाकृत मामूली आकार वाले इनपुट पृथ्वी पर किसी भी कंप्यूटर का उपयोग करके हल करने के लिए बहुत बड़े हैं। हम इसके बारे में बहुत आश्वस्त हैं, इंटरनेट की अधिकांश सुरक्षा कुछ समस्याओं के समाधान न होने पर निर्भर करती है।\n",
    "\n",
    "1994 में, पीटर शोर ने दिखाया कि क्वांटम कंप्यूटर पर कुशलता से किसी संख्या को उसके अभाज्य संख्याओं में कारक बनाना संभव है।[1] यह बड़ी खबर है, जैसा कि हम जानते हैं कि सबसे अच्छा शास्त्रीय एल्गोरिदम इन एल्गोरिदम में से एक है जो तेजी से बढ़ता है। और वास्तव में, [आरएसए एन्क्रिप्शन](https://en.wikipedia.org/wiki/RSA_(cryptosystem)) बड़ी पर्याप्त संख्या के अव्यवहारिक होने के गुणनखंड पर निर्भर करता है। हमारे वर्तमान शास्त्रीय कंप्यूटरों के लिए बहुत बड़े पूर्णांकों को कारक करने के लिए लाखों क्वैबिट और गेट्स की आवश्यकता होगी, और ये सर्किट आज के क्वांटम कंप्यूटरों पर सफलतापूर्वक चलने के लिए बहुत बड़े हैं।\n",
    "\n",
    "तो लिवेन एम.के. वांडर्सिपेन, मैथियास स्टीफ़न, ग्रेगरी ब्रेटा, कोस्टेंटिनो एस. यानोनी, मार्क एच. शेरवुड और आइज़ैक एल. चुआंग 2001 ने क्वांटम कंप्यूटर पर कारक 15 का प्रबंधन कैसे किया?![2]\n",
    "\n",
    "शोर के एल्गोरिथ्म के लिए सर्किट बनाने में कठिनाई एक सर्किट बना रही है जो एक नियंत्रित की गणना करता है $ay \\bmod N$. जबकि हम जानते हैं कि इन सर्किटों को बहुपद संख्या में फाटकों का उपयोग करके कैसे बनाया जाता है, ये आज के कंप्यूटरों के लिए अभी भी बहुत बड़े हैं। सौभाग्य से, अगर हम समस्या के बारे में कुछ जानकारी को प्राथमिकता से जानते हैं, तो हम कभी-कभी 'धोखा' दे सकते हैं और अधिक कुशल सर्किट बना सकते हैं।\n",
    "\n",
    "इस सर्किट को उनके लिए उपलब्ध हार्डवेयर पर चलाने के लिए, उपरोक्त पेपर के लेखकों को एक बहुत ही सरल सर्किट मिला जिसने प्रदर्शन किया $7y \\bmod 15$. इसने सर्किट को उनके हार्डवेयर पर चलाने के लिए काफी छोटा बना दिया। इस अभ्यास के अंत तक, आप एक सर्किट बनालेंगे $35y \\bmod N$ जिसका उपयोग शोर के एल्गोरिथम में किया जा सकता है और `ibmq_santiago` पर चल सकता है।\n",
    "\n",
    "यदि आप यह समझना चाहते हैं कि इस अभ्यास में क्या हो रहा है, तो आपको [शोर के एल्गोरिथम पर किस्किट पाठ्यपुस्तक पृष्ठ](https://qiskit.org/textbook/ch-algorithms/shor.html) देखना चाहिए, लेकिन यदि यह भी है आपके लिए शामिल है, आप इसके बिना व्यायाम पूरा कर सकते हैं।\n",
    "\n",
    "### संदर्भ\n",
    "1. शोर, पीटर डब्ल्यू। \"क्वांटम गणना के लिए एल्गोरिदम: असतत लघुगणक और फैक्टरिंग।\" कंप्यूटर विज्ञान की नींव पर 35 वीं वार्षिक संगोष्ठी की कार्यवाही। आईईई, 1994।\n",
    "2. वेंडर्सिपेन, लिवेन एमके, एट अल। \"परमाणु चुंबकीय अनुनाद का उपयोग करके शोर के क्वांटम फैक्टरिंग एल्गोरिदम का प्रायोगिक अहसास।\" प्रकृति ४१४.६८६६ (२००१): ८८३-८८७।"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## टीएल; डॉ: शोर का एल्गोरिदम\n",
    "\n",
    "एक एल्गोरिथ्म है जिसे कहा जाता है [_क्वांटम चरण अनुमान_](https://qiskit.org/textbook/ch-algorithms/quantum-phase-estimation.html) \n",
    "जो हमें उस चरण के बारे में बताता है जो एक गेट एक निश्चित प्रकार की अवस्था का परिचय देता है। उदाहरण के लिए, चरण अनुमान एल्गोरिदम के इनपुट राज्य हो सकते हैं $|1\\rangle$ और गेट $Z$. अगर $Z$-gate राज्य $|1\\rangle$ पर कार्य करता है, हम $\\pi$ के एक अतिरिक्त वैश्विक चरण के साथ उसी स्थिति को वापस प्राप्त करते हैं:\n",
    "\n",
    "$$\n",
    "Z|1\\rangle = -|1\\rangle = e^{i\\pi} |1\\rangle\n",
    "$$\n",
    "\n",
    "और क्वांटम चरण अनुमान एल्गोरिथ्म हमारे लिए यह काम कर सकता है। आप एक और उदाहरण देख सकते हैं [यहां](https://qiskit.org/textbook/ch-algorithms/quantum-phase-estimation.html#2.-Example:-T-gate-).\n",
    "\n",
    "शोर ने दिखाया कि यदि हम गेट पर चरण अनुमान करते हैं, $U$, जिसका व्यवहार है $U|y\\rangle = |a y\\bmod N\\rangle$, हम जल्दी से $N$'s के कारकों के बारे में कुछ जानकारी प्राप्त कर सकते हैं।"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## समस्या\n",
    "\n",
    "इस अभ्यास में, हम $13y \\bmod 35$ को लागू करने वाले सर्किट पर चरण अनुमान करके 35 का कारक करेंगे। अभ्यास एक सर्किट बनाने के लिए है जो ऐसा करता है, और इतना छोटा भी है कि `ibmq_santiago` पर चल सकता है! यह कोई आसान काम नहीं है, इसलिए पहली चीज जो हम करने जा रहे हैं वह है धोखा।\n",
    "\n",
    "शोर के एल्गोरिदम का एक विवरण यह है कि हमारे सर्किट को केवल उन राज्यों पर काम करने की ज़रूरत है जिन्हें हम $U$ को शुरुआती राज्य $|1\\rangle$ पर लागू करके पहुंच सकते हैं। अर्थात। हम _any_ सर्किट का उपयोग कर सकते हैं जिसका व्यवहार है: \n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "U|1\\rangle &= |13\\rangle \\\\\n",
    "UU|1\\rangle &= |29\\rangle \\\\\n",
    "UUU|1\\rangle &= |27\\rangle \\\\\n",
    "UUUU|1\\rangle &= |1\\rangle \\\\\n",
    "\\end{aligned}\n",
    "$$\n",
    "\n",
    "तो हम इसे हमारे लिए कैसे आसान बना सकते हैं? चूंकि हमें केवल 4 अलग-अलग राज्यों को सही ढंग से बदलने की जरूरत है, हम इन्हें दो क्वैबिट में एन्कोड कर सकते हैं। इस अभ्यास के लिए, हम 2-क्यूबिट कम्प्यूटेशनल आधार राज्यों को इस तरह की संख्याओं से मैप करना चुनेंगे:\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "|1\\rangle &\\rightarrow |00\\rangle \\\\\n",
    "|13\\rangle &\\rightarrow |01\\rangle \\\\\n",
    "|29\\rangle &\\rightarrow |10\\rangle \\\\\n",
    "|27\\rangle &\\rightarrow |11\\rangle \\\\\n",
    "\\end{aligned}\n",
    "$$\n",
    "\n",
    "यह \"धोखा\" क्यों है? ठीक है, इस अनुकूलन का लाभ उठाने के लिए, हमें उन सभी राज्यों को जानना होगा जो $U$ को प्रभावित करने जा रहे हैं, जिसका अर्थ है कि हमें $ay \\bmod N$ की गणना तब तक करनी होगी जब तक कि हम फिर से 1 पर वापस नहीं आ जाते, और इसका मतलब है कि हम जानते हैं $a^x \\bmod N$ की अवधि और इसलिए $N$ के गुणनखंड प्राप्त कर सकते हैं। इस तरह का कोई भी अनुकूलन, जिसमें हम ऐसी जानकारी का उपयोग करते हैं जो हमें $r$ मान बताएगी, स्पष्ट रूप से उन समस्याओं के पैमाने पर नहीं जा रही है जिन्हें शास्त्रीय कंप्यूटर हल नहीं कर सकते।\n",
    "\n",
    "लेकिन इस अभ्यास का उद्देश्य सिर्फ यह सत्यापित करना है कि शोर का एल्गोरिदम वास्तव में इरादा के अनुसार काम करता है, और हम इस तथ्य के बारे में चिंता करने वाले नहीं हैं कि हमने $U$ के लिए एक सर्किट प्राप्त करने के लिए धोखा दिया।\n",
    "\n",
    "<div id='u-definition'></div>\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "\n",
    "**Exercise 2a:** एक सर्किट बनाएं ($U$) जो परिवर्तन करता है:\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "U|00\\rangle &= |01\\rangle \\\\\n",
    "U|01\\rangle &= |10\\rangle \\\\\n",
    "U|10\\rangle &= |11\\rangle \\\\\n",
    "U|11\\rangle &= |00\\rangle \\\\\n",
    "\\end{aligned}\n",
    "$$\n",
    "\n",
    "और एक अन्य क्यूबिट द्वारा नियंत्रित किया जाता है। सर्किट 'लक्ष्य' नामक 2-क्यूबिट लक्ष्य रजिस्टर पर कार्य करेगा, और 'कंट्रोल' नामक एक अन्य सिंगल-क्विबिट रजिस्टर द्वारा नियंत्रित किया जाएगा। आपको अपना तैयार सर्किट वेरिएबल '`cu'' को असाइन करना चाहिए।\n",
    "    \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 175.827x204.68 with 1 Axes>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit import QuantumCircuit\n",
    "from qiskit import QuantumRegister, QuantumCircuit\n",
    "c = QuantumRegister(1, 'control')\n",
    "t = QuantumRegister(2, 'target')\n",
    "cu = QuantumCircuit(c, t, name=\"Controlled 13^x mod 35\")\n",
    "\n",
    "# इन पंक्तियों के बीच अपना कोड लिखें - स्टार्ट\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# इन पंक्तियों के बीच अपना कोड लिखें - एन्ड \n",
    "\n",
    "cu.draw('mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "और अपना उत्तर जांचने के लिए नीचे दिए गए सेल को चलाएँ:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "ModuleNotFoundError",
     "evalue": "No module named 'qc_grader'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-2-a103d8ab6e1e>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# निम्नलिखित कोड का उपयोग करके अपना उत्तर जांचें\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[1;32mfrom\u001b[0m \u001b[0mqc_grader\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mgrade_ex2a\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      3\u001b[0m \u001b[0mgrade_ex2a\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcu\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mModuleNotFoundError\u001b[0m: No module named 'qc_grader'"
     ]
    }
   ],
   "source": [
    "# निम्नलिखित कोड का उपयोग करके अपना उत्तर जांचें\n",
    "from qc_grader import grade_ex2a\n",
    "grade_ex2a(cu)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "बधाई हो! आपने कठिन हिस्सा पूरा कर लिया है।\n",
    "\n",
    "हम क्यूबिट्स को मापकर चरण अनुमान एल्गोरिथ्म के आउटपुट को पढ़ते हैं, इसलिए हमें यह सुनिश्चित करने की आवश्यकता होगी कि हमारे 'गिनती' रजिस्टर में $r$ को पढ़ने के लिए पर्याप्त क्यूबिट्स हों। हमारे मामले में, $r = 4$, जिसका अर्थ है कि हमें केवल $\\log_2(4) = 2$ क्यूबिट्स (फिर से धोखा देना क्योंकि हम $r$ पहले से जानते हैं) की आवश्यकता है, लेकिन चूंकि सैंटियागो में 5 क्यूबिट्स हैं, और हमने केवल उपयोग किया है 2 'टारगेट' रजिस्टर के लिए, हम अपने काउंटिंग रजिस्टर के रूप में शेष सभी 3 क्यूबिट्स का उपयोग करेंगे।\n",
    "\n",
    "$U$ पर चरण अनुमान करने के लिए, हमें सर्किट बनाने की आवश्यकता है जो हमारे रजिस्टर में प्रत्येक qubit (इंडेक्स $x$ के साथ) के लिए $U^{2^x}$ ($U$ दोहराया $2^x$ बार) का प्रदर्शन करते हैं $n$ गिनती qubits। हमारे मामले में इसका मतलब है कि हमें तीन सर्किट की आवश्यकता है जो लागू हों:\n",
    "\n",
    "$$ U, \\; U^2, \\; \\text{and} \\; U^4 $$\n",
    "\n",
    "तो अगला कदम एक सर्किट बनाना है जो $U^2$ (यानी एक सर्किट $U$ को दो बार लागू करने के बराबर) करता है।\n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "\n",
    "**Exercise 2b:** एक सर्किट बनाएं ($U^2$) जो परिवर्तन करता है:\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "U|00\\rangle &= |10\\rangle \\\\\n",
    "U|01\\rangle &= |11\\rangle \\\\\n",
    "U|10\\rangle &= |00\\rangle \\\\\n",
    "U|11\\rangle &= |01\\rangle \\\\\n",
    "\\end{aligned}\n",
    "$$\n",
    "\n",
    "और एक अन्य क्यूबिट द्वारा नियंत्रित किया जाता है। सर्किट 'लक्ष्य' नामक 2-क्यूबिट लक्ष्य रजिस्टर पर कार्य करेगा, और 'कंट्रोल' नामक एक अन्य सिंगल-क्विबिट रजिस्टर द्वारा नियंत्रित किया जाएगा। आपको अपना तैयार सर्किट वेरिएबल '`cu2'' को असाइन करना चाहिए।\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "c = QuantumRegister(1, 'control')\n",
    "t = QuantumRegister(2, 'target')\n",
    "cu2 = QuantumCircuit(c, t)\n",
    "\n",
    "# इन पंक्तियों के बीच अपना कोड लिखें - स्टार्ट\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# इन पंक्तियों के बीच अपना कोड लिखें - एन्ड \n",
    "\n",
    "cu2.draw('mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "और अपना उत्तर जांचने के लिए नीचे दिए गए सेल को चलाएँ:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# निम्नलिखित कोड का उपयोग करके अपना उत्तर जांचें\n",
    "from qc_grader import grade_ex2b\n",
    "grade_ex2b(cu2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "अंत में, हमें एक ऐसे सर्किट की भी आवश्यकता है जो $U$ को चार बार लागू करने के बराबर हो (यानी हमें सर्किट $U^4$ की आवश्यकता है)।  \n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "    \n",
    "**Exercise 2c:** एक सर्किट बनाएं ($U^4$) जो परिवर्तन करता है:\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "U|00\\rangle &= |00\\rangle \\\\\n",
    "U|01\\rangle &= |01\\rangle \\\\\n",
    "U|10\\rangle &= |10\\rangle \\\\\n",
    "U|11\\rangle &= |11\\rangle \\\\\n",
    "\\end{aligned}\n",
    "$$\n",
    "\n",
    "और एक अन्य क्यूबिट द्वारा नियंत्रित किया जाता है। सर्किट 'लक्ष्य' नामक 2-क्यूबिट लक्ष्य रजिस्टर पर कार्य करेगा, और 'कंट्रोल' नामक एक अन्य सिंगल-क्विबिट रजिस्टर द्वारा नियंत्रित किया जाएगा। आपको अपना तैयार सर्किट वेरिएबल '`cu4'' को असाइन करना चाहिए। _संकेत: सबसे अच्छा समाधान बहुत आसान है।_\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "c = QuantumRegister(1, 'control')\n",
    "t = QuantumRegister(2, 'target')\n",
    "cu4 = QuantumCircuit(c, t)\n",
    "\n",
    "# इन पंक्तियों के बीच अपना कोड लिखें - स्टार्ट\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# इन पंक्तियों के बीच अपना कोड लिखें - एन्ड \n",
    "\n",
    "cu4.draw('mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "और अपना उत्तर जांचने के लिए नीचे दिए गए सेल को चलाएँ:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# निम्नलिखित कोड का उपयोग करके अपना उत्तर जांचें\n",
    "from qc_grader import grade_ex2c\n",
    "grade_ex2c(cu4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "\n",
    "**Exercise 2 final:** अब हमने $U$, $U^2$ and $U^4$ को नियंत्रित कर लिया है, हम इसे एक सर्किट में जोड़ सकते हैं जो शोर के एल्गोरिथम के क्वांटम भाग को पूरा करता है।\n",
    "\n",
    "आरंभीकरण भाग आसान है: हमें गिनती रजिस्टर को राज्य में रखना होगा |+++ put (जो हम तीन H-गेट्स के साथ कर सकते हैं) और हमें राज्य में होने के लिए लक्ष्य रजिस्टर की आवश्यकता है |1⟩ (जिसे हमने मैप किया है) कम्प्यूटेशनल आधार स्थिति के लिए |00⟩ , इसलिए हमें यहां कुछ भी करने की आवश्यकता नहीं है)। हम आपके लिए यह सब करेंगे।\n",
    "\n",
    "आपका काम एक सर्किट बनाना है जो नियंत्रित करता है- s, जिसका उपयोग इनिशियलाइज़ेशन और व्युत्क्रम क्वांटम फूरियर ट्रांसफ़ॉर्म के बीच में किया जाएगा। अधिक औपचारिक रूप से, हम एक सर्किट चाहते हैं:\n",
    "\n",
    "\n",
    "$$\n",
    "CU_{c_0 t}CU^2_{c_1 t}CU^4_{c_2 t}\n",
    "$$\n",
    "\n",
    "जहां $c_0$, $c_1$ और $c_2$ 'गिनती' रजिस्टर में तीन qubits हैं, $t$ 'target' रजिस्टर है, और $U$ <a href=\"#u-definition\"> के रूप में है इस अभ्यास के पहले भाग में परिभाषित किया गया है</a>। इस संकेतन में, $CU_{a b}$ का अर्थ है $CU$ को $a$ द्वारा नियंत्रित किया जाता है और $b$ पर कार्य करता है। इसका एक आसान उपाय यह है कि आप ऊपर बनाए गए सर्किट `cu`, `cu2` और `cu4` को जोड़ दें, लेकिन आपको एक अधिक कुशल सर्किट मिलेगा जिसमें समान व्यवहार हो!\n",
    "    \n",
    "</div>\n",
    "<div class=\"alert alert-block alert-danger\">\n",
    "    \n",
    "आपके सर्किट में केवल [CNOTs](https://qiskit.org/documentation/stubs/qiskit.circuit.library.CXGate.html) और सिंगल क्यूबिट [U-gates](https://qiskit.org/documentation/) हो सकते हैं। स्टब्स/qiskit.circuit.library.UGate.html)। आपका स्कोर आपके द्वारा उपयोग किए जाने वाले CNOTs की संख्या होगी (कम बेहतर है), क्योंकि मल्टी-क्विबिट गेट्स आमतौर पर सिंगल-क्विबिट गेट्स की तुलना में हार्डवेयर पर अधिक कठिन होते हैं। यदि आप इस आवश्यकता से जूझ रहे हैं, तो हमने सबमिशन के आगे कोड की एक पंक्ति शामिल की है जो आपके सर्किट को इस फ़ॉर्म में बदल देगी, हालाँकि आपके हाथ से बेहतर करने की संभावना है।\n",
    "    \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# आपके पिछले समाधानों को आपके अंतिम सबमिशन में संयोजित करने के लिए कोड\n",
    "cqr = QuantumRegister(3, 'control')\n",
    "tqr = QuantumRegister(2, 'target')\n",
    "cux = QuantumCircuit(cqr, tqr)\n",
    "solutions = [cu, cu2, cu4]\n",
    "for i in range(3):\n",
    "    cux = cux.compose(solutions[i], [cqr[i], tqr[0], tqr[1]])\n",
    "cux.draw('mpl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# निम्नलिखित कोड का उपयोग करके अपना उत्तर जांचें\n",
    "from qc_grader import grade_ex2_final\n",
    "# यदि आपको अपने सर्किट को CNOTs और सिंगल-क्यूबिट गेट्स में बदलने की आवश्यकता है, तो नीचे दी गई दो पंक्तियों को अनकम्मेंट करें\n",
    "#from qiskit import transpile\n",
    "#cux = transpile(cux, basis_gates=['cx','u'])\n",
    "grade_ex2_final(cux)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "एक बार जब आप सर्किट से खुश हो जाते हैं, तो आप इसे नीचे सबमिट कर सकते हैं:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# अपना उत्तर सबमिट करें। आप किसी भी समय पुनः सबमिट कर सकते हैं।\n",
    "from qc_grader import submit_ex2_final\n",
    "submit_ex2_final(cux)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "बधाई हो! आपने अभ्यास समाप्त कर लिया है। यह देखने के लिए पढ़ें कि आपका सर्किट कारक 35 का उपयोग करता है, और देखें कि यह कैसा प्रदर्शन करता है।\n",
    "\n",
    "## 35 को गुणनखंड करने के लिए अपने सर्किट का उपयोग करना\n",
    "\n",
    "नीचे दिया गया कोड सेल अभ्यास के लिए आपका सबमिशन लेता है और इसका उपयोग एक सर्किट बनाने के लिए करता है जो हमें $\\tfrac{s}{r}$ देगा, जहां $s$ $0$ और $r-1$ के बीच एक यादृच्छिक पूर्णांक है, और $r$ फ़ंक्शन की अवधि है $f(x) = 13^x \\bmod 35$।"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from qiskit.circuit.library import QFT\n",
    "from qiskit import ClassicalRegister\n",
    "# सर्किट ऑब्जेक्ट बनाएं\n",
    "cr = ClassicalRegister(3)\n",
    "shor_circuit = QuantumCircuit(cqr, tqr, cr)\n",
    "\n",
    "# क्यूबिट्स को इनिशियलाइज़ करें\n",
    "shor_circuit.h(cqr)\n",
    "\n",
    "# अपना सर्किट जोड़ें\n",
    "shor_circuit = shor_circuit.compose(cux)\n",
    "\n",
    "# उलटा QFT करें और आउटपुट निकालें\n",
    "shor_circuit.append(QFT(3, inverse=True), cqr)\n",
    "shor_circuit.measure(cqr, cr)\n",
    "shor_circuit.draw('mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "आइए इस सर्किट को ट्रांसपाइल करें और देखें कि यह कितना बड़ा है, और यह कितने CNOT का उपयोग करता है:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from qiskit import Aer, transpile\n",
    "from qiskit.visualization import plot_histogram\n",
    "qasm_sim = Aer.get_backend('aer_simulator')\n",
    "tqc = transpile(shor_circuit, basis_gates=['u', 'cx'], optimization_level=3)\n",
    "print(f\"circuit depth: {tqc.depth()}\")\n",
    "print(f\"circuit contains {tqc.count_ops()['cx']} CNOTs\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "और देखते हैं कि हमें क्या मिलता है:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "counts = qasm_sim.run(tqc).result().get_counts()\n",
    "plot_histogram(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "यह मानते हुए कि सब कुछ सही ढंग से काम कर रहा है, हमें $0$, $2$, $4$ और $8$ संख्याओं को मापने की समान संभावना देखनी चाहिए। ऐसा इसलिए है क्योंकि चरण अनुमान हमें $2^n \\cdot \\tfrac{s}{r}$ देता है, जहां $n$ हमारे गिनती रजिस्टर में qubits की संख्या है (यहां $n = 3$, $s$ एक यादृच्छिक पूर्णांक है $0$ और $r-1$ के बीच, और $r$ वह संख्या है जिसकी हम गणना करने का प्रयास कर रहे हैं)। आइए इन्हें भिन्नों में परिवर्तित करें जो हमें $s/r$ बताते हैं (यह कुछ ऐसा है जिसे हम आसानी से शास्त्रीय रूप से गणना कर सकते हैं):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from fractions import Fraction\n",
    "n = 3  # n हमारे 'गिनती' रजिस्टर में qubits की संख्या है\n",
    "# प्रत्येक माप स्ट्रिंग के माध्यम से साइकिल\n",
    "for measurement in counts.keys():\n",
    "    # बाइनरी स्ट्रिंग को 'int' में बदलें, और 2^n . से विभाजित करें\n",
    "    decimal = int(measurement, 2)/2**n\n",
    "    # a/b के रूप में कनवर्ट करने के लिए निरंतर भिन्न एल्गोरिथम का उपयोग करें\n",
    "    print(Fraction(decimal).limit_denominator())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "हम देख सकते हैं कि कुछ परिणामों का हर हमें सही उत्तर $r = 4$ बताएगा। हम जल्दी से $r=4$ सत्यापित कर सकते हैं:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "13**4 % 35"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "तो हम इससे कारक कैसे प्राप्त करते हैं? फिर इस बात की बहुत अधिक संभावना है कि $N$ और या तो $a^{r/2}-1$ या $a^{r/2}+1$ का सबसे बड़ा सामान्य भाजक $N$ का एक गुणनखंड हो, और सबसे बड़ा सामान्य भाजक भी कुछ ऐसा है जिसे हम आसानी से शास्त्रीय रूप से गणना कर सकते हैं।"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from math import gcd # महत्तम सामान्य भाजक\n",
    "for x in [-1, 1]:\n",
    "    print(f\"Guessed factor: {gcd(13**(4//2)+x, 35)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "हमें केवल एक कारक खोजने की आवश्यकता है, और दूसरे कारक को खोजने के लिए $N$ को विभाजित करने के लिए इसका उपयोग कर सकते हैं। लेकिन इस मामले में, _both_ $a^{r/2}-1$ या $a^{r/2}+1$ हमें $35$ के गुणक देते हैं। हम फिर से सत्यापित कर सकते हैं कि यह सही है:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "7*5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `ibmq_santiago` पर चल रहा है\n",
    "\n",
    "हमने वादा किया था कि यह सैंटियागो पर चलेगा, इसलिए यहां हम आपको दिखाएंगे कि यह कैसे करना है। इस उदाहरण में हम सुविधा के लिए एक नकली सैंटियागो डिवाइस का उपयोग करेंगे, लेकिन आप चाहें तो इसे वास्तविक डिवाइस के लिए स्विच आउट कर सकते हैं:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from qiskit.test.mock import FakeSantiago\n",
    "from qiskit import assemble\n",
    "from qiskit.visualization import plot_histogram\n",
    "santiago = FakeSantiago()\n",
    "real_device = False\n",
    "\n",
    "## वास्तविक डिवाइस पर चलने के लिए इस कोड ब्लॉक को अनकम्मेंट करें\n",
    "#from qiskit import IBMQ\n",
    "#IBMQ.load_account()\n",
    "#provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main')\n",
    "#santiago = provider.get_backend('ibmq_santiago')\n",
    "#real_device = True\n",
    "\n",
    "# हमें सैंटियागो के लिए आगे बढ़ने की जरूरत है\n",
    "tqc = transpile(shor_circuit, santiago, optimization_level=3)\n",
    "\n",
    "if not real_device:\n",
    "    tqc = assemble(tqc)\n",
    "\n",
    "# सर्किट चलाएँ और काउंट प्रिंट करें\n",
    "counts = santiago.run(tqc).result().get_counts()\n",
    "plot_histogram(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "यदि आपका स्कोर काफी कम था, तो आपको यह देखना चाहिए कि हमारे पास $0$, $2$, $4$ या $8$ को मापने की उच्च संभावना है जैसा कि हमने सही सिमुलेशन के साथ देखा। प्रोसेसर में अशुद्धियों और हमारी क्वैबिट्स के साथ बातचीत करने वाली अवांछित चीजों के कारण आपको कुछ अतिरिक्त परिणाम दिखाई देंगे। यह 'शोर' हमारे सर्किट के लंबे समय तक खराब हो जाता है, क्योंकि लंबे समय तक गणना समय का मतलब अवांछित बातचीत के लिए अधिक समय है, और अधिक गेट्स का मतलब अधिक संभावित त्रुटियां हैं। यही कारण है कि हमें सबसे छोटा सर्किट संभव बनाने के लिए धोखा देने की जरूरत है।\n",
    "\n",
    "निकट भविष्य में, हमारे क्वांटम सिस्टम में इतना सुधार होगा कि हम इन समस्याओं को दूर करने के लिए और अधिक उन्नत त्रुटि शमन तकनीकों का उपयोग करना शुरू कर सकते हैं, जिसका अर्थ यह होगा कि हम बड़े पर्याप्त सर्किट चला सकते हैं जो हम [बिना धोखा दिए शोर का एल्गोरिदम निष्पादित कर सकते हैं](https:// arxiv.org/pdf/quant-ph/0205095.pdf)।"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## अतिरिक्त जानकारी\n",
    "\n",
    "**के द्वारा बनाई गई:** फ्रैंक हार्किंस\n",
    "\n",
    "**संस्करण:** 1.0.0"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  },
  "nbdime-conflicts": {
   "local_diff": [
    {
     "diff": [
      {
       "diff": [
        {
         "key": 0,
         "length": 1,
         "op": "removerange"
        }
       ],
       "key": "version",
       "op": "patch"
      }
     ],
     "key": "language_info",
     "op": "patch"
    }
   ],
   "remote_diff": [
    {
     "diff": [
      {
       "diff": [
        {
         "diff": [
          {
           "key": 4,
           "op": "addrange",
           "valuelist": "8"
          },
          {
           "key": 4,
           "length": 1,
           "op": "removerange"
          }
         ],
         "key": 0,
         "op": "patch"
        }
       ],
       "key": "version",
       "op": "patch"
      }
     ],
     "key": "language_info",
     "op": "patch"
    }
   ]
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}