Python on kenji.blog

Qiskit का उपयोग करके क्वांटम प्रोग्रामिंग का परिचय

Fri, 11 Sep 2026 20:00:00 +0900

1. परिचय

आधुनिक कंप्यूटर (शास्त्रीय कंप्यूटर) ने हमारे जीवन को नाटकीय रूप से बदल दिया है और अपनी उच्च गणना क्षमताओं के साथ समाज के हर पहलू का समर्थन करते हैं। हालांकि, कुछ विशिष्ट समस्याओं (जैसे, बहुत बड़ी संख्याओं का अभाज्य गुणनखंडन, जटिल आणविक संरचनाओं का सिमुलेशन, और अनुकूलन समस्याएं) के लिए, यह ज्ञात है कि वर्तमान के सबसे उन्नत सुपर कंप्यूटरों को भी ब्रह्मांड की आयु से अधिक समय की आवश्यकता होगी।

इन “शास्त्रीय कंप्यूटरों की सीमाओं” को तोड़ने की क्षमता रखने वाले कंप्यूटर को क्वांटम कंप्यूटर (Quantum Computer) कहा जाता है। क्वांटम यांत्रिकी के रहस्यमय गुणों (सुपरपोज़िशन और क्वांटम एंटैंगलमेंट) को कम्प्यूटेशनल संसाधनों के रूप में उपयोग करके, यह माना जाता है कि कुछ विशिष्ट समस्याओं को नाटकीय रूप से तेज किया जा सकता है।

इस लेख में, हम IBM द्वारा प्रदान किए गए एक ओपन-सोर्स क्वांटम कंप्यूटिंग फ्रेमवर्क, Qiskit (किस्किट) का उपयोग करके क्वांटम प्रोग्रामिंग की दुनिया में अपना पहला कदम रखेंगे। यह एक बहुत ही विस्तृत परिचयात्मक मार्गदर्शिका है जो भौतिकी और गणित की बुनियादी बातों से लेकर पायथन में कोड लिखने और एक सिम्युलेटर पर क्वांटम सर्किट चलाने तक की पूरी प्रक्रिया को कवर करती है।

2. क्वांटम गणना का समर्थन करने वाले भौतिकी और गणित की बुनियादी बातें

क्वांटम प्रोग्रामिंग को समझने के लिए, सबसे पहले क्वांटम यांत्रिकी की बुनियादी अवधारणाओं को समझना आवश्यक है। यहाँ हम तीन महत्वपूर्ण स्तंभों: क्वांटम बिट्स, सुपरपोज़िशन, और क्वांटम एंटैंगलमेंट की व्याख्या करेंगे।

2.1 शास्त्रीय बिट्स और क्वांटम बिट्स (Qubit)

शास्त्रीय कंप्यूटरों की सूचना इकाई “बिट (Bit)” है। एक बिट हमेशा 0 या 1 की अवस्था में होता है।

दूसरी ओर, क्वांटम कंप्यूटरों में सूचना की सबसे छोटी इकाई को क्वांटम बिट (Qubit: Quantum bit) कहा जाता है। क्वांटम बिट्स न केवल 0 और 1 की अवस्था ले सकते हैं, बल्कि इन दोनों अवस्थाओं को एक साथ बनाए रखना भी संभव है।

गणितीय रूप से, क्वांटम बिट की अवस्था $|\psi\rangle$ को आधार अवस्थाओं $|0\rangle$ और $|1\rangle$ के रैखिक संयोजन (सुपरपोज़िशन) के रूप में व्यक्त किया जाता है।

$$ |\psi\rangle = \alpha|0\rangle + \beta|1\rangle $$

यहाँ, $\alpha$ और $\beta$ सम्मिश्र संख्याएँ हैं, जो क्रमशः अवस्था $|0\rangle$ और $|1\rangle$ को देखने के प्रायिकता आयामों को दर्शाती हैं। क्वांटम यांत्रिकी के मूल सिद्धांतों के आधार पर, प्रायिकताओं का योग 1 होना चाहिए, इसलिए निम्नलिखित सामान्यीकरण शर्त पूरी होती है:

$$ |\alpha|^2 + |\beta|^2 = 1 $$

graph LR A["शास्त्रीय बिट (Classical Bit)"] --> B["निश्चित अवस्था: 0 या 1"] C["क्वांटम बिट (Qubit)"] --> D["सुपरपोज़िशन: 0 और 1 दोनों"] D --> E["माप द्वारा अवस्था संभाव्य रूप से निर्धारित होती है"]

2.2 सुपरपोज़िशन (Superposition)

जैसा कि पहले उल्लेख किया गया है, उस अवस्था को जहाँ $|0\rangle$ और $|1\rangle$ अवस्थाएँ मिश्रित होती हैं, सुपरपोज़िशन (Superposition) कहा जाता है।

उदाहरण के लिए, यदि एक क्वांटम बिट पूरी तरह से समान सुपरपोज़िशन अवस्था में है, तो $\alpha = \frac{1}{\sqrt{2}}$ और $\beta = \frac{1}{\sqrt{2}}$ होगा।

$$ |\psi\rangle = \frac{1}{\sqrt{2}}|0\rangle + \frac{1}{\sqrt{2}}|1\rangle $$

जब इस अवस्था को मापा जाता है, तो $|0\rangle$ और $|1\rangle$ दोनों को 50% की प्रायिकता के साथ देखा जाता है। यदि आपके पास 2 क्वांटम बिट्स हैं, तो आप 4 अवस्थाओं: $|00\rangle, |01\rangle, |10\rangle, |11\rangle$ का एक सुपरपोज़िशन बना सकते हैं। यदि आपके पास $n$ क्वांटम बिट्स हैं, तो आप एक ही समय में $2^n$ अवस्थाओं को व्यक्त कर सकते हैं, जो क्वांटम कंप्यूटरों की समानांतर प्रसंस्करण शक्ति के स्रोतों में से एक है।

2.3 क्वांटम एंटैंगलमेंट (Entanglement)

क्वांटम गणना में सबसे शक्तिशाली और रहस्यमय गुण क्वांटम एंटैंगलमेंट (Entanglement) है। आइंस्टीन ने इस घटना को “दूरी पर डरावनी कार्रवाई (spooky action at a distance)” कहा था। यह एक ऐसी संपत्ति है जहाँ दो या दो से अधिक क्वांटम बिट्स एक-दूसरे से मजबूती से जुड़े होते हैं, और एक बार जब एक क्वांटम बिट की अवस्था निर्धारित हो जाती है, तो दूसरे क्वांटम बिट की अवस्था तुरंत निर्धारित हो जाती है, भले ही वे भौतिक रूप से कितनी भी दूर हों।

सबसे प्रसिद्ध क्वांटम एंटैंगलमेंट अवस्थाओं में से एक “बेल अवस्था (Bell State)” $\Phi^+$ अवस्था है, जिसे इस प्रकार व्यक्त किया जाता है:

$$ |\Phi^+\rangle = \frac{|00\rangle + |11\rangle}{\sqrt{2}} $$

इस अवस्था में, $|01\rangle$ और $|10\rangle$ अवस्थाएँ मौजूद नहीं हैं। इसलिए, यदि पहले क्वांटम बिट को मापा जाता है और वह $|0\rangle$ है, तो निश्चित रूप से यह निर्धारित होता है कि दूसरा भी $|0\rangle$ है, बिना दूसरे क्वांटम बिट को मापने की आवश्यकता के। इसके विपरीत, यदि पहला $|1\rangle$ है, तो दूसरा भी हमेशा $|1\rangle$ होगा।

3. क्वांटम लॉजिक गेट्स (Quantum Logic Gates)

जिस तरह शास्त्रीय कंप्यूटर गणना करने के लिए AND, OR, और NOT जैसे लॉजिक गेट्स का उपयोग करते हैं, उसी तरह क्वांटम कंप्यूटर क्वांटम बिट्स की अवस्थाओं में हेरफेर करने के लिए क्वांटम गेट्स का उपयोग करते हैं। चूंकि क्वांटम अवस्थाएँ वैक्टर हैं, इसलिए क्वांटम गेट्स को उन वैक्टरों पर काम करने वाले “यूनिटरी मैट्रिसेस (Unitary Matrices)” के रूप में दर्शाया जाता है।

3.1 पाउली गेट्स (Pauli-X, Y, Z)

पाउली गेट्स एक क्वांटम बिट पर बुनियादी संचालन हैं।

・Pauli-X गेट (NOT गेट) यह शास्त्रीय NOT गेट के बराबर है। यह $|0\rangle$ को $|1\rangle$ में और $|1\rangle$ को $|0\rangle$ में उलट देता है। (बलोच क्षेत्र में X अक्ष के चारों ओर 180-डिग्री का घुमाव)

$$ X = \begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix} $$

・Pauli-Y गेट यह Y अक्ष के चारों ओर 180-डिग्री का घुमाव करता है। इसका प्रभाव चरण (Phase) और बिट दोनों को उलटने में होता है।

$$ Y = \begin{pmatrix} 0 & -i \\ i & 0 \end{pmatrix} $$

・Pauli-Z गेट (फेज फ्लिप गेट) यह $|0\rangle$ की अवस्था को अपरिवर्तित छोड़ देता है और $|1\rangle$ अवस्था के चरण को उलट देता है ($-1$ से गुणा करता है)। (Z अक्ष के चारों ओर 180-डिग्री का घुमाव)

$$ Z = \begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix} $$

3.2 हैडामार्ड गेट (Hadamard Gate)

हैडामार्ड गेट (H गेट) एक बहुत ही महत्वपूर्ण गेट है जो एक निश्चित अवस्था ($|0\rangle$ या $|1\rangle$) को एक सुपरपोज़िशन अवस्था में परिवर्तित करता है।

$$ H = \frac{1}{\sqrt{2}} \begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix} $$

जब H गेट को $|0\rangle$ पर लागू किया जाता है, तो यह एक समान सुपरपोज़िशन अवस्था $|+\rangle$ बन जाता है।

$$ H|0\rangle = \frac{1}{\sqrt{2}}|0\rangle + \frac{1}{\sqrt{2}}|1\rangle = |+\rangle $$

3.3 फेज गेट्स (Phase Gates)

फेज गेट Z गेट का एक सामान्यीकरण है, जो $|1\rangle$ अवस्था के चरण को एक निर्दिष्ट कोण $\theta$ से घुमाता है।

$$ P(\theta) = \begin{pmatrix} 1 & 0 \\ 0 & e^{i\theta} \end{pmatrix} $$

विशिष्ट उदाहरणों में S गेट ($\theta = \pi/2$) और T गेट ($\theta = \pi/4$) शामिल हैं।

3.4 CNOT गेट (Controlled-NOT Gate)

CNOT गेट (CX गेट) एक ऐसा गेट है जो दो क्वांटम बिट्स के बीच काम करता है और क्वांटम एंटैंगलमेंट उत्पन्न करने के लिए आवश्यक है। इसमें एक “कंट्रोल (Control) बिट” और एक “टारगेट (Target) बिट” होता है।

केवल यदि कंट्रोल बिट $|1\rangle$ है, तो X गेट (NOT ऑपरेशन) टारगेट बिट पर लागू होता है; यदि कंट्रोल बिट $|0\rangle$ है, तो यह कुछ नहीं करता है।

$$ CNOT = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \end{pmatrix} $$

4. Qiskit की मूल बातें और पर्यावरण सेटअप

अब हम वास्तविक क्वांटम प्रोग्राम लिखने के लिए पायथन और Qiskit का उपयोग करेंगे।

4.1 Qiskit क्या है?

Qiskit एक ओपन-सोर्स क्वांटम कंप्यूटिंग सॉफ्टवेयर डेवलपमेंट किट (SDK) है जिसे IBM Quantum द्वारा विकसित किया गया है। यह आपको सहज रूप से क्वांटम सर्किट बनाने के लिए पायथन का उपयोग करने की अनुमति देता है, और उन्हें स्थानीय सिमुलेटर पर या वास्तविक IBM क्वांटम कंप्यूटरों पर क्लाउड के माध्यम से निष्पादित करने की अनुमति देता है।

4.2 स्थापित करने की विधि

Qiskit का उपयोग करने के लिए, पायथन वातावरण की आवश्यकता होती है। आप निम्नलिखित कमांड से Qiskit और संबंधित पैकेजों (सिमुलेटर और ड्राइंग लाइब्रेरी) को स्थापित कर सकते हैं:

1

pip install qiskit qiskit-aer qiskit-ibm-runtime matplotlib pylatexenc

4.3 प्रोग्रामिंग का मूल प्रवाह

Qiskit का उपयोग करते हुए क्वांटम प्रोग्रामिंग मुख्य रूप से निम्नलिखित चरणों में आगे बढ़ती है:

graph TD A["1. सर्किट का निर्माण (Build)"] --> B["2. संकलन/ट्रांसपाइल (Compile)"] B --> C["3. निष्पादन (Execute)"] C --> D["4. परिणामों का विश्लेषण और विज़ुअलाइज़ेशन (Analyze)"]

सर्किट का निर्माण: एक QuantumCircuit ऑब्जेक्ट बनाएं और गेट्स जोड़ें।
संकलन: निष्पादन के लिए बैकएंड (वास्तविक मशीन या सिम्युलेटर) से मेल खाने के लिए सर्किट को अनुकूलित करें।
निष्पादन: बैकएंड पर काम भेजें और परिणाम प्राप्त करें।
विश्लेषण: माप परिणामों के हिस्टोग्राम आदि प्लॉट करें।

5. अभ्यास: बेल स्टेट (क्वांटम एंटैंगलमेंट) बनाने के लिए एक सर्किट का निर्माण

आइए Qiskit का उपयोग करके उस “क्वांटम एंटैंगलमेंट (बेल स्टेट)” को बनाएं जिसे हमने सिद्धांत में सीखा था। लक्ष्य अवस्था $|\Phi^+\rangle = \frac{|00\rangle + |11\rangle}{\sqrt{2}}$ है।

5.1 सर्किट का डिज़ाइन

बेल स्टेट बनाने के लिए, हम इन चरणों का पालन करते हैं:

2 क्वांटम बिट्स तैयार करें (प्रारंभिक अवस्था दोनों के लिए $|0\rangle$ है)।
इसे एक सुपरपोज़िशन अवस्था में रखने के लिए पहले क्वांटम बिट पर एक हैडामार्ड गेट (H) लागू करें।
पहले क्वांटम बिट को “कंट्रोल बिट” और दूसरे क्वांटम बिट को “टारगेट बिट” के रूप में उपयोग करते हुए एक CNOT गेट लागू करें।
परिणाम को पढ़ने के लिए माप (Measure) करें।

5.2 Python/Qiskit कोड का कार्यान्वयन

आइए वास्तविक कोड देखें।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


import numpy as np
from qiskit import QuantumCircuit, transpile
from qiskit_aer import Aer
from qiskit.visualization import plot_histogram
import matplotlib.pyplot as plt

# 1. सर्किट आरंभीकरण
# 2 क्वांटम बिट्स और 2 शास्त्रीय बिट्स के साथ एक क्वांटम सर्किट बनाएं
qc = QuantumCircuit(2, 2)

# 2. H गेट लागू करें
# क्वांटम बिट 0 (q0) पर हैडामार्ड गेट लागू करें
qc.h(0)

# 3. CNOT गेट लागू करें
# q0 को कंट्रोल बिट और q1 को टारगेट बिट के रूप में मानते हुए CNOT लागू करें
qc.cx(0, 1)

# 4. माप
# क्वांटम बिट्स 0 और 1 को मापें, और उन्हें क्रमशः शास्त्रीय बिट्स 0 और 1 में लिखें
qc.measure([0, 1], [0, 1])

# सर्किट आरेख ड्रा करें (matplotlib का उपयोग करके)
# qc.draw('mpl')
print(qc.draw())

जब आप इस कोड को चलाते हैं, तो कंसोल पर ASCII आर्ट में निम्नलिखित क्वांटम सर्किट आरेख प्रदर्शित होगा:

1
2
3
4
5
6
7


 ┌───┐ ┌─┐
q_0: ┤ H ├──■──┤M├───
 └───┘┌─┴─┐└╥┘┌─┐
q_1: ─────┤ X ├─╫─┤M├
 └───┘ ║ └╥┘
c: 2/═══════════╩══╩═
 0 1

H हैडामार्ड गेट का प्रतिनिधित्व करता है, ■ और X का संयोजन CNOT गेट का प्रतिनिधित्व करता है, और M माप का प्रतिनिधित्व करता है।

5.3 सिम्युलेटर पर निष्पादन और परिणामों की व्याख्या

इसके बाद, हम इस सर्किट को IBM के उच्च-प्रदर्शन सिम्युलेटर Aer पर चलाएंगे और परिणामों की जांच करेंगे।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


# Aer सिम्युलेटर का बैकएंड प्राप्त करें
simulator = Aer.get_backend('qasm_simulator')

# सिम्युलेटर के लिए सर्किट को ट्रांसपाइल (अनुकूलित) करें
compiled_circuit = transpile(qc, simulator)

# सर्किट चलाएं (यहाँ हम 1000 शॉट्स निष्पादित करते हैं)
job = simulator.run(compiled_circuit, shots=1000)

# परिणाम प्राप्त करें
result = job.result()

# अवस्था के देखे जाने की संख्या (गणना) प्राप्त करें
counts = result.get_counts(compiled_circuit)
print("\nमाप परिणाम:", counts)

# हिस्टोग्राम प्लॉट करें
# plot_histogram(counts)
# plt.show()

परिणामों की व्याख्या

कंसोल का आउटपुट कुछ इस तरह होना चाहिए: माप परिणाम: {'00': 495, '11': 505} (※चूंकि प्रायिकताएं यादृच्छिक होती हैं, इसलिए हर बार निष्पादित होने पर संख्याएं थोड़ी बदल जाएंगी)

एक आदर्श सिमुलेशन वातावरण में, 00 और 11 को लगभग 50% मापा जाएगा, और 01 या 10 को बिल्कुल नहीं देखा जाएगा। यह ठीक उसी तरह है जैसा हमने जो बेल स्टेट $|\Phi^+\rangle = \frac{|00\rangle + |11\rangle}{\sqrt{2}}$ बनाया है, उसके सैद्धांतिक पूर्वानुमान के साथ पूरी तरह मेल खाता है। “क्वांटम एंटैंगलमेंट” जहां यदि पहला क्वांटम बिट 0 है, तो दूसरा भी 0 होना चाहिए, और यदि यह 1 है, तो यह 1 होना चाहिए, सटीक रूप से अनुकरण किया गया है।

ध्यान दें कि यदि इसे वास्तविक क्वांटम कंप्यूटर (IBM Quantum Hardware) पर चलाया जाता है, तो शोर (क्वांटम डिकोहेरेंस और गेट त्रुटियों) के प्रभाव के कारण 01 या 10 को थोड़ा देखा जा सकता है। वर्तमान क्वांटम कंप्यूटर के विकास में सबसे बड़ी चुनौतियों में से एक इस शोर को कम करना है (क्वांटम त्रुटि सुधार)।

6. अधिक उन्नत एल्गोरिदम में स्केल अप करना

बेल स्टेट का निर्माण क्वांटम प्रोग्रामिंग के “हैलो वर्ल्ड (Hello World)” जैसा है। इसे और विकसित करके, हम शक्तिशाली एल्गोरिदम बना सकते हैं जो शास्त्रीय कंप्यूटरों को पार करते हैं।

6.1 ड्यूश-जोस्ज़ा एल्गोरिदम (Deutsch-Jozsa Algorithm)

यह यह निर्धारित करने की समस्या है कि दिया गया फ़ंक्शन $f(x)$ “निरंतर फ़ंक्शन (इनपुट की परवाह किए बिना हमेशा 0 या हमेशा 1 आउटपुट करता है)” है या “संतुलित फ़ंक्शन (आधे इनपुट के लिए 0 और बाकी आधे के लिए 1 आउटपुट करता है)” है। शास्त्रीय कंप्यूटरों को सबसे खराब स्थिति में फ़ंक्शन के $2^{n-1} + 1$ मूल्यांकन की आवश्यकता होती है, लेकिन ड्यूश-जोस्ज़ा एल्गोरिदम का उपयोग करके, आप क्वांटम समानांतरता का उपयोग करके केवल 1 मूल्यांकन में इसे निर्धारित कर सकते हैं। यह क्वांटम एल्गोरिदम के मूल पैटर्न को दर्शाता है जो एक सुपरपोज़िशन अवस्था को इनपुट करता है, अनावश्यक अवस्थाओं को रद्द करने के लिए हस्तक्षेप (Interference) का उपयोग करता है, और वांछित उत्तर को बढ़ाता है।

6.2 ग्रोवर का एल्गोरिदम (Grover’s Algorithm)

एक खोज समस्या में जहां $N$ बिना क्रमबद्ध डेटाबेस से विशिष्ट डेटा की खोज की जाती है, एक शास्त्रीय एल्गोरिदम को औसतन $N/2$ गणनाओं की आवश्यकता होती है, जबकि ग्रोवर का एल्गोरिदम $\sqrt{N}$ बार में लक्ष्य डेटा ढूंढ सकता है। यह एल्गोरिदम लक्ष्य समाधान के चरण को पलटने के लिए “ओरेकल (Oracle)” नामक ब्लैक बॉक्स का उपयोग करता है, और “आयाम प्रवर्धन (Amplitude Amplification)” करके लक्ष्य समाधान को देखे जाने की प्रायिकता को नाटकीय रूप से बढ़ाता है।

graph TD A["आरंभीकरण (सभी अवस्थाओं का सुपरपोज़िशन)"] --> B["ओरेकल (सही उत्तर के चरण को पलटना)"] B --> C["प्रसार ऑपरेटर (औसत के चारों ओर पलटने से आयाम प्रवर्धन)"] C --> D{"क्या यह पर्याप्त प्रायिकता तक पहुंच गया है?"} D -- "नहीं (No)" --> B D -- "हाँ (Yes)" --> E["माप"]

7. निष्कर्ष और भविष्य की शिक्षा

इस लेख में, हमने सुपरपोज़िशन और क्वांटम एंटैंगलमेंट जैसी क्वांटम कंप्यूटिंग की मौलिक अवधारणाओं से शुरू किया, और Qiskit का उपयोग करके क्वांटम लॉजिक गेट्स के संचालन को विस्तार से समझाया, और वास्तव में एक बेल स्टेट का निर्माण, अनुकरण, और परिणामों की व्याख्या की।

चूंकि Qiskit को पायथन में लिखा जा सकता है, जो एक परिचित भाषा है, इसलिए यह एक शक्तिशाली उपकरण है जो आपको गणितीय और भौतिक बाधाओं को दूर करने और एल्गोरिदम के निर्माण पर ध्यान केंद्रित करने की अनुमति देता है। क्वांटम कंप्यूटर वर्तमान में शोर वाले मध्यवर्ती-स्तरीय क्वांटम उपकरणों (NISQ: Noisy Intermediate-Scale Quantum) के युग में हैं, लेकिन क्वांटम मशीन लर्निंग (Quantum Machine Learning), क्वांटम रसायन विज्ञान (Quantum Chemistry), और क्रिप्टोग्राफी जैसे कई क्षेत्रों में दुनिया भर में लागू अनुसंधान तेजी से आगे बढ़ रहा है।

कृपया इस अवसर का लाभ उठाकर Qiskit का उपयोग करके विभिन्न क्वांटम सर्किट बनाएं और उन्हें वास्तविक IBM Quantum प्रोसेसर पर चलाएं। आपको अपने हाथों से भविष्य के कंप्यूटिंग प्रतिमान का अनुभव करने में सक्षम होना चाहिए।

संदर्भ

Qiskit आधिकारिक दस्तावेज़
Qiskit पाठ्यपुस्तक (Textbook) - आधिकारिक पाठ्यपुस्तक जो उन लोगों के लिए अनुशंसित है जो गणितीय पृष्ठभूमि और एल्गोरिदम को अधिक गहराई से सीखना चाहते हैं
IBM Quantum Learning

क्वांटम की दुनिया में आपका स्वागत है!

पायथन में शोर के एल्गोरिथ्म का सिमुलेशन

Fri, 11 Sep 2026 08:00:00 +0900

1. परिचय: क्वांटम कंप्यूटर द्वारा लाया गया क्रिप्टोग्राफी का संकट

आधुनिक इंटरनेट समाज में सुरक्षा का अधिकांश हिस्सा सार्वजनिक कुंजी क्रिप्टोग्राफी (Public Key Cryptography) (विशेष रूप से RSA एन्क्रिप्शन) पर निर्भर करता है। जब हम ऑनलाइन शॉपिंग के दौरान क्रेडिट कार्ड की जानकारी भेजते हैं या अत्यधिक गोपनीय डेटा का आदान-प्रदान करते हैं, तो उस संचार की सामग्री को RSA एन्क्रिप्शन द्वारा दृढ़ता से सुरक्षित किया जाता है।

RSA एन्क्रिप्शन की सुरक्षा का आधार इस गणितीय तथ्य पर निर्भर करता है कि “एक बहुत बड़े पूर्णांक का अभाज्य गुणनखंडन शास्त्रीय कंप्यूटरों (जैसे पीसी या सुपरकंप्यूटर) के लिए अत्यंत कठिन है।” हालाँकि, 1994 में पीटर शोर (Peter Shor) द्वारा प्रकाशित “शोर का एल्गोरिथ्म (Shor’s Algorithm)” इस आधार को पूरी तरह से पलट देता है। यह गणितीय रूप से सिद्ध हो चुका है कि यदि शोर के एल्गोरिथ्म को बड़े पैमाने के क्वांटम कंप्यूटर पर निष्पादित किया जाए, तो अभाज्य गुणनखंडन, जिसे शास्त्रीय कंप्यूटर पर हल करने में ब्रह्मांड की आयु से अधिक समय लग सकता है, उसे केवल कुछ मिनटों से लेकर कुछ घंटों में हल किया जा सकता है।

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

2. कम्प्यूटेशनल जटिलता में नाटकीय बदलाव: घातांकीय से बहुपद समय तक

अभाज्य गुणनखंडन इतना कठिन क्यों है? भले ही हम “सामान्य संख्या क्षेत्र चलनी (General Number Field Sieve, GNFS)” का उपयोग करें, जिसे शास्त्रीय कंप्यूटरों के लिए सबसे अच्छा अभाज्य गुणनखंडन एल्गोरिथ्म माना जाता है, इसकी कम्प्यूटेशनल जटिलता उप-घातांकीय (sub-exponential) है।

$N$ अंकों की एक समग्र संख्या (composite number) का अभाज्य गुणनखंडन करने के लिए आवश्यक समय जटिलता (time complexity) शास्त्रीय तरीकों से इस प्रकार है:

$$ O\left(\exp\left( c (\log N)^{1/3} (\log \log N)^{2/3} \right)\right) $$

इस वजह से, केवल कुंजी की लंबाई बढ़ाने (उदाहरण के लिए, इसे 2048 बिट्स या 4096 बिट्स करने) से शास्त्रीय कंप्यूटरों के लिए डिक्रिप्शन में हजारों या लाखों साल लग सकते हैं, जो कि अव्यावहारिक है।

हालाँकि, जब क्वांटम कंप्यूटर पर शोर के एल्गोरिथ्म का उपयोग किया जाता है, तो इनपुट बिट्स $\log N$ की संख्या के सापेक्ष कम्प्यूटेशनल जटिलता नाटकीय रूप से कम होकर बहुपद समय (polynomial time) में आ जाती है।

$$ O((\log N)^3) $$

इसका मतलब यह है कि यदि बिट्स की संख्या दोगुनी कर दी जाए, तो शास्त्रीय कंप्यूटरों के लिए गणना का समय खगोलीय रूप से बढ़ जाता है, जबकि क्वांटम कंप्यूटरों के लिए गणना का समय केवल लगभग 8 गुना बढ़ जाता है। घातांकीय समय से बहुपद समय तक जटिलता वर्ग में यह कमी (BQP वर्ग में शामिल होना) ही शोर के एल्गोरिथ्म की सच्ची महानता है।

graph TD A["इनपुट आकार (बिट्स की संख्या) N में वृद्धि"] --> B{"एल्गोरिथ्म का चयन"} B -->|शास्त्रीय: सामान्य संख्या क्षेत्र चलनी| C["उप-घातांकीय वृद्धि O(exp(...))"] B -->|क्वांटम: शोर का एल्गोरिथ्म| D["बहुपद समय O((log N)^3)"] C --> E["हजारों से अरबों साल (डिक्रिप्ट करने में असमर्थ)"] D --> F["कुछ मिनट से कुछ घंटे (व्यावहारिक समय में डिक्रिप्ट)"]

3. एल्गोरिथ्म का अवलोकन और गणितीय पृष्ठभूमि

असल में, शोर के एल्गोरिथ्म में सब कुछ क्वांटम कंप्यूटर पर नहीं किया जाता है। यह शास्त्रीय कंप्यूटर द्वारा प्री-प्रोसेसिंग और पोस्ट-प्रोसेसिंग, और क्वांटम कंप्यूटर द्वारा मुख्य भाग (अवधि खोजने का एल्गोरिथ्म - Period Finding Algorithm) के बीच सहयोग पर निर्भर करता है।

एल्गोरिथ्म का समग्र प्रवाह इस प्रकार है:

graph TD A["इनपुट: वह समग्र संख्या N जिसका अभाज्य गुणनखंडन करना है"] --> B["यादृच्छिक संख्या a चुनें जहाँ a < N"] B --> C{"gcd(a, N) > 1 ?"} C -- "Yes" --> D["तुच्छ गुणनखंड gcd(a, N) आउटपुट करें और समाप्त करें"] C -- "No" --> E["क्वांटम एल्गोरिथ्म के साथ f(x) = a^x mod N की अवधि r खोजें"] E --> F{"क्या r सम है और a^(r/2) ≢ -1 mod N ?"} F -- "No" --> B F -- "Yes" --> G["गुणनखंड p = gcd(a^(r/2) - 1, N), q = gcd(a^(r/2) + 1, N) की गणना करें"] G --> H["आउटपुट: p, q"]

अभाज्य गुणनखंडन को अवधि खोजने की समस्या (Period Finding Problem) में बदलना

शोर का प्रतिभाशाली विचार “अभाज्य गुणनखंडन समस्या” को “अवधि खोजने की समस्या (Order Finding Problem)” में परिवर्तित करना था।

मान लीजिए कि एक पूर्णांक $N$ (वह संख्या जिसका अभाज्य गुणनखंडन किया जाना है) और एक सह-अभाज्य (coprime) पूर्णांक $a$ ($1 < a < N$) है। हम निम्नलिखित मॉड्यूलर एक्सपोनेंशियल फ़ंक्शन को परिभाषित करते हैं:

$$ f(x) = a^x \bmod N $$

इस फ़ंक्शन की एक निश्चित अवधि $r$ होती है। अर्थात, किसी भी $x$ के लिए, $f(x+r) = f(x)$ सत्य होता है। विशेष रूप से, जब $x=0$ होता है,

$$ a^r \equiv 1 \pmod N $$

सबसे छोटा धनात्मक पूर्णांक $r$ जो इसे संतुष्ट करता है, उसे “$N$ के मापांक में $a$ का क्रम (Order)” कहा जाता है। यदि हम इस अवधि $r$ को पा सकते हैं, तो हम अभाज्य गुणनखंडों को निम्न प्रकार से निकाल सकते हैं:

समीकरण को बदलने पर,

$$ a^r - 1 \equiv 0 \pmod N $$

यदि $r$ सम है, तो हम इसे वर्गों के अंतर के सूत्र का उपयोग करके गुणनखंडित कर सकते हैं:

$$ (a^{r/2} - 1)(a^{r/2} + 1) \equiv 0 \pmod N $$

यह इंगित करता है कि $N$ का $(a^{r/2} - 1)$ या $(a^{r/2} + 1)$ के साथ कोई सार्व भाजक (common divisor) है (बशर्ते कि शर्त $a^{r/2} \not\equiv -1 \pmod N$ संतुष्ट हो)। इसलिए, यूक्लिडियन एल्गोरिथ्म (Euclidean algorithm) का उपयोग करके,

$$ p = \gcd(a^{r/2} - 1, N) $$ $$ q = \gcd(a^{r/2} + 1, N) $$

की गणना करके, हम $N$ के गैर-तुच्छ अभाज्य गुणनखंड (non-trivial prime factors) $p, q$ खोज सकते हैं। यह गणना (महत्तम समापवर्तक की गणना और यादृच्छिक संख्या का निर्माण) शास्त्रीय कंप्यूटरों पर बहुत तेजी से की जा सकती है। समस्या केवल इस बात पर केंद्रित हो जाती है कि हम अवधि $r$ को तेजी से कैसे खोज सकते हैं। शास्त्रीय कंप्यूटरों के लिए, केवल इस अवधि $r$ को खोजने में ही घातांकीय समय लगता है। यहीं क्वांटम कंप्यूटर काम में आते हैं।

4. क्वांटम एल्गोरिथ्म भाग: अवधि खोजने का तंत्र

क्वांटम कंप्यूटर का उपयोग करके अवधि $r$ खोजने के लिए सबरूटीन में निम्नलिखित 4 चरण शामिल हैं:

graph LR subgraph "क्वांटम अवस्था का संक्रमण" S1["|0⟩|0⟩ (आरंभीकरण)"] --> S2["H गेट: सुपरपोजिशन Σ|x⟩|0⟩"] S2 --> S3["ओरेकल U: Σ|x⟩|a^x mod N⟩"] S3 --> S4["QFT: हस्तक्षेप द्वारा अवधि निष्कर्षण"] S4 --> S5["माप: अनुमानित मान y प्राप्त करना"] end

चरण 1: क्वांटम रजिस्टर का आरंभीकरण और सुपरपोजिशन

सबसे पहले, हम दो क्वांटम रजिस्टर तैयार करते हैं। पहला रजिस्टर अवस्था इनपुट करने के लिए है, और दूसरा रजिस्टर फ़ंक्शन के गणना परिणामों को संग्रहीत करने के लिए है। प्रारंभिक अवस्था पूरी तरह से $|0\rangle$ है।

$$ |\psi_0\rangle = |0\rangle_1 |0\rangle_2 $$

हम पहले रजिस्टर के सभी क्विबिट्स पर हैडमार्ड गेट (Hadamard Gate) लागू करते हैं ताकि सभी संभावित इनपुट्स $x$ ($0$ से $Q-1$ तक, $Q=2^n$) की समान संभावना वाली सुपरपोजिशन अवस्था (superposition state) बनाई जा सके।

$$ |\psi_1\rangle = \frac{1}{\sqrt{Q}} \sum_{x=0}^{Q-1} |x\rangle_1 |0\rangle_2 $$

इसके साथ, क्वांटम कंप्यूटर एक ही ऑपरेशन में एक साथ सभी $Q$ इनपुट्स के लिए अवस्था को बनाए रखता है। यही क्वांटम समानांतरता (quantum parallelism) का शक्तिशाली स्रोत है।

चरण 2: ओरेकल फ़ंक्शन (मॉड्यूलर एक्सपोनेंटिएशन) लागू करना

इसके बाद, हम फ़ंक्शन $f(x) = a^x \bmod N$ की गणना करने के लिए क्वांटम ऑपरेशन सर्किट $U_f$ का उपयोग करते हैं और परिणाम को दूसरे रजिस्टर में संग्रहीत करते हैं।

$$ |\psi_2\rangle = \frac{1}{\sqrt{Q}} \sum_{x=0}^{Q-1} |x\rangle_1 |a^x \bmod N\rangle_2 $$

इस बिंदु पर, पहला रजिस्टर और दूसरा रजिस्टर क्वांटम एंटैंगलमेंट (quantum entanglement) की अवस्था में होते हैं। यदि हम (काल्पनिक रूप से) दूसरे रजिस्टर का अवलोकन करते हैं और एक विशिष्ट मान $k = a^{x_0} \bmod N$ प्राप्त करते हैं, तो पहले रजिस्टर की अवस्था उस $x$ की सुपरपोजिशन अवस्था में ढह जाएगी जो वह मान $k$ देता है। चूंकि फ़ंक्शन की अवधि $r$ है, शेष अवस्थाएं $x_0, x_0+r, x_0+2r, \dots$ जैसे मानों के $r$ छलांग पर होंगी।

$$ |\psi_3\rangle = \sqrt{\frac{r}{Q}} \sum_{j=0}^{M-1} |x_0 + j r\rangle_1 |k\rangle_2 $$

हालाँकि, हम $x_0$ नहीं जानना चाहते हैं, बल्कि हम स्वयं अवधि $r$ जानना चाहते हैं। इस अवस्था से $r$ को सीधे मापना असंभव है। इसलिए, हम क्वांटम फूरियर ट्रांसफॉर्म (Quantum Fourier Transform) का उपयोग करते हैं।

चरण 3: क्वांटम फूरियर ट्रांसफॉर्म (QFT) के माध्यम से चरण हस्तक्षेप

हम पहले रजिस्टर पर क्वांटम फूरियर ट्रांसफॉर्म (QFT) लागू करते हैं। QFT शास्त्रीय असतत फूरियर ट्रांसफॉर्म (discrete Fourier transform) का क्वांटम संस्करण है, जो अवस्था वेक्टर के आयाम (amplitude) को परिवर्तित करता है। आधार अवस्था (basis state) $|x\rangle$ पर QFT की क्रिया को इस प्रकार परिभाषित किया गया है:

$$ QFT |x\rangle = \frac{1}{\sqrt{Q}} \sum_{y=0}^{Q-1} \omega^{xy} |y\rangle $$

यहाँ, $\omega = e^{2\pi i / Q}$ है।

जब QFT लागू किया जाता है, तो अवस्थाओं के आयाम में हस्तक्षेप (interference) होता है। गणितीय विवरण को छोड़ते हुए, जब अवधि $r$ वाली अवस्था पर QFT लागू किया जाता है, तो तरंगों में रचनात्मक हस्तक्षेप (Constructive Interference) केवल तभी होता है जब $y$ का मान $Q/r$ के पूर्णांक गुणज के बहुत करीब होता है। अन्य अवस्थाओं के लिए, संभावना आयाम (probability amplitude) विनाशकारी हस्तक्षेप (Destructive Interference) द्वारा रद्द हो जाते हैं और शून्य के करीब पहुंच जाते हैं।

चरण 4: मापन और निरंतर भिन्न विस्तार

अंत में, हम पहले रजिस्टर को मापते हैं। माप से प्राप्त मान $y$ उच्च संभावना के साथ निम्नलिखित शर्त को पूरा करता है:

$$ y \approx c \frac{Q}{r} \implies \frac{y}{Q} \approx \frac{c}{r} $$

($c$ एक अज्ञात पूर्णांक है जहाँ $0 \le c < r$ है)

प्राप्त परिमेय संख्या $y/Q$ पर शास्त्रीय एल्गोरिथ्म निरंतर भिन्न विस्तार (Continued Fraction Expansion) लागू करके, हम सन्निकट भिन्न (approximate fraction) $c/r$ की गणना करते हैं और हर (denominator) से अवधि $r$ निकालते हैं।

5. Python और Qiskit का उपयोग करके सिमुलेशन कार्यान्वयन

चूंकि केवल सिद्धांत से इसे समझना मुश्किल है, आइए वास्तव में Python और IBM के क्वांटम कंप्यूटिंग फ्रेमवर्क Qiskit का उपयोग करके शोर के एल्गोरिथ्म का सिमुलेशन करें।

यहाँ, हम सबसे क्लासिक और प्रसिद्ध परिदृश्य को लागू करेंगे: "$a=7$ का उपयोग करके $N=15$ का अभाज्य गुणनखंडन करना।"

निष्पादन वातावरण तैयार करना

कृपया सुनिश्चित करें कि आपने पहले ही Qiskit स्थापित कर लिया है।

1

pip install qiskit qiskit-aer numpy

Python कार्यान्वयन कोड का अवलोकन

नीचे दिया गया कोड $N=15, a=7$ के लिए विशेषीकृत शोर के एल्गोरिथ्म कार्यान्वयन का एक उदाहरण है। चूंकि वर्तमान सिमुलेटर में सामान्य प्रयोजन के मॉड्यूलर घातांक सर्किट का निर्माण करना कम्प्यूटेशनल रूप से बहुत महंगा है, हम विशेष रूप से $a=7$ के मामले में गेट ऑपरेशंस को हार्डकोड कर रहे हैं।

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123


import numpy as np
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit.visualization import plot_histogram
from fractions import Fraction
import math

# 1. व्युत्क्रम क्वांटम फूरियर ट्रांसफॉर्म (QFT†) बनाने का फलन
def qft_dagger(n):
 """n क्विबिट्स का इनवर्स क्वांटम फूरियर ट्रांसफॉर्म सर्किट बनाता है"""
 qc = QuantumCircuit(n)
 # क्रम को उलटने के लिए SWAP गेट
 for qubit in range(n//2):
 qc.swap(qubit, n-qubit-1)
 # नियंत्रित फेज़ गेट और H गेट को लागू करना
 for j in range(n):
 for m in range(j):
 qc.cp(-np.pi/float(2**(j-m)), m, j)
 qc.h(j)
 qc.name = "QFT_dagger"
 return qc

# 2. 7^x mod 15 के लिए नियंत्रित मॉड्यूलर एक्सपोनेंटिएशन ऑपरेशन बनाने का फलन
def c_amod15(a, power):
 """विशिष्ट 'a' और 'power' के लिए नियंत्रित U गेट बनाता है (केवल N=15 के लिए)"""
 U = QuantumCircuit(4)
 for _ in range(power):
 # a=7 होने पर 7^x mod 15 के लिए हार्डकोडेड लॉजिक
 if a in [2,13]:
 U.swap(2,3)
 U.swap(1,2)
 U.swap(0,1)
 if a in [7,8]:
 U.swap(0,1)
 U.swap(1,2)
 U.swap(2,3)
 if a in [4, 11]:
 U.swap(1,3)
 U.swap(0,2)
 if a in [7,11,13]:
 for q in range(4):
 U.x(q)
 U = U.to_gate()
 U.name = f"{a}^{power} mod 15"
 c_U = U.control()
 return c_U

# 3. मुख्य क्वांटम सर्किट विन्यास
def shor_circuit(a, n_count):
 # n_count: नियंत्रण रजिस्टर में बिट्स की संख्या
 # लक्ष्य रजिस्टर 0 से 15 तक दर्शाने के लिए 4 बिट्स का उपयोग करता है
 qc = QuantumCircuit(n_count + 4, n_count)

 # पहले रजिस्टर (नियंत्रण रजिस्टर) का आरंभीकरण (सुपरपोजिशन उत्पन्न करना)
 for q in range(n_count):
 qc.h(q)

 # दूसरे रजिस्टर (लक्ष्य रजिस्टर) को |1> (0001) पर आरंभ करना
 qc.x(3 + n_count)

 # नियंत्रित मॉड्यूलर एक्सपोनेंटिएशन (ओरेकल) को लागू करना
 for q in range(n_count):
 # 2^q घातांक ऑपरेशन लागू करना
 qc.append(c_amod15(a, 2**q),
 [q] + [i+n_count for i in range(4)])

 # पहले रजिस्टर पर इनवर्स क्वांटम फूरियर ट्रांसफॉर्म लागू करना
 qc.append(qft_dagger(n_count), range(n_count))

 # पहले रजिस्टर को मापना
 qc.measure(range(n_count), range(n_count))
 return qc

# --- निष्पादन अनुभाग ---
if __name__ == "__main__":
 N = 15
 a = 7
 n_count = 8 # नियंत्रण रजिस्टर में 8 क्विबिट्स का उपयोग करें (Q=256)

 print(f"खोज सेटिंग्स: N={N}, a={a}, नियंत्रण क्विबिट्स की संख्या={n_count}")

 # सर्किट का निर्माण
 qc = shor_circuit(a, n_count)

 # सिमुलेटर पर निष्पादन
 sim = AerSimulator()
 # नवीनतम Qiskit में transpile की अनुशंसा की जाती है
 from qiskit import transpile
 compiled_circuit = transpile(qc, sim)
 job = sim.run(compiled_circuit, shots=1024)
 result = job.result()
 counts = result.get_counts()

 print("\nमाप परिणाम (बिट स्ट्रिंग: प्रेक्षणों की संख्या):")
 for bitstring, count in counts.items():
 print(f" {bitstring}: {count} बार")

 # शास्त्रीय पोस्ट-प्रोसेसिंग: निरंतर भिन्न विस्तार (Continued fractions) का उपयोग करके अवधि r खोजना
 print("\n--- अवधि की गणना और अभाज्य गुणनखंडन ---")
 phases = []
 for output in counts:
 # बिट स्ट्रिंग को दशमलव में परिवर्तित करना
 decimal = int(output, 2)
 # फेज़ (Phase) = मापा गया मान / 2^n_count
 phase = decimal / (2**n_count)
 phases.append(phase)

 # निरंतर भिन्न विस्तार के माध्यम से सन्निकट भिन्न प्राप्त करें। हर (denominator) की ऊपरी सीमा N=15 है
 frac = Fraction(phase).limit_denominator(15)
 r = frac.denominator

 print(f"प्रेक्षित मान: {decimal:3d} | फेज़: {phase:.4f} | भिन्न: {frac} | अनुमानित अवधि r = {r}")

 # जांचें कि क्या अवधि r सम है और वैध परिणाम देती है
 if r % 2 == 0:
 guess1 = math.gcd(a**(r//2) - 1, N)
 guess2 = math.gcd(a**(r//2) + 1, N)
 if guess1 not in [1, N] or guess2 not in [1, N]:
 print(f" => सफलता! {N} के अभाज्य गुणनखंड {guess1} और {guess2} हैं।")
 else:
 print(f" => केवल तुच्छ गुणनखंड। पुनः प्रयास करें।")
 else:
 print(f" => विफलता क्योंकि अवधि विषम है।")

कोड की व्याख्या और निष्पादन परिणामों का विश्लेषण

जब आप उपरोक्त कोड निष्पादित करते हैं, तो आपको उच्च संभावना के साथ नियंत्रण रजिस्टर के मापन परिणामों के रूप में विशिष्ट चोटियाँ (प्रेक्षित मान) प्राप्त होंगी। n_count=8 ($Q=256$) के मामले में, एक आदर्श क्वांटम कंप्यूटर (या सिमुलेटर) पर, भारी संभावना के साथ प्रेक्षित मानों के रूप में 0, 64, 128, और 192 जैसी संख्याएं दिखाई देंगी।

जब इन्हें $Q=256$ से विभाजित किया जाता है, तो चरण (phase) $y/Q$ क्रमशः $0.0$, $0.25$, $0.5$, और $0.75$ हो जाते हैं। जब इन चरणों को निरंतर भिन्न (continued fraction) के रूप में विस्तारित किया जाता है:

$0.25 \to 1/4$ (अनुमानित अवधि $r=4$)
$0.50 \to 1/2$ (अनुमानित अवधि $r=2$)
$0.75 \to 3/4$ (अनुमानित अवधि $r=4$)

यहां प्राप्त अवधि $r=4$ का उपयोग करके, हम अभाज्य गुणनखंडों की गणना करते हैं। चूंकि $a=7, r=4$ है, $p = \gcd(7^2 - 1, 15) = \gcd(48, 15) = 3$ $q = \gcd(7^2 + 1, 15) = \gcd(50, 15) = 5$

शानदार ढंग से, हम सफलतापूर्वक $15 = 3 \times 5$ का अभाज्य गुणनखंडन कर चुके हैं।

[!TIP] यदि प्रेक्षित मान $y=128$ (चरण $0.5$) प्राप्त होता है, तो हर (denominator) $2$ होगा, और हमें सही अवधि $r=4$ के बजाय इसका एक विभाजक मिलेगा। ऐसे मामलों में, एल्गोरिथ्म को कई बार निष्पादित करके या प्राप्त $r$ के गुणकों की जाँच करके, सही अवधि तक पहुँचा जा सकता है।

6. व्यावहारिक अनुप्रयोग के लिए चुनौतियाँ और NISQ युग की सीमाएँ

हालाँकि एक सिमुलेटर पर $N=15$ का अभाज्य गुणनखंडन करना आसान था, वास्तविक दुनिया में उपयोग किए जा रहे RSA-2048 (617 अंकों की दशमलव संख्या) का अभाज्य गुणनखंडन करने के लिए वास्तविक क्वांटम कंप्यूटरों को अभी भी कई बाधाओं का सामना करना पड़ता है।

जिस युग में हम वर्तमान में रह रहे हैं उसे NISQ (Noisy Intermediate-Scale Quantum: शोरगुल वाले मध्यवर्ती-स्तरीय क्वांटम) युग कहा जाता है। क्वांटम बिट्स बाहरी वातावरण के शोर के प्रति बेहद संवेदनशील होते हैं, और गणना के बीच में “डिकोहेरेंस (decoherence)” के कारण उनकी अवस्था नष्ट हो जाती है।

शोर के एल्गोरिथ्म जैसे गहरे (बड़ी संख्या में गेट्स वाले) सर्किट को सटीक रूप से निष्पादित करने के लिए, क्वांटम त्रुटि सुधार (Quantum Error Correction) आवश्यक है जो शोर को ठीक करता है। एक शोर-मुक्त “लॉजिकल क्विबिट (logical qubit)” बनाने के लिए, सरफेस कोड (Surface Code) आदि के माध्यम से हजारों “फिजिकल क्विबिट्स (physical qubits)” को एन्कोड करना आवश्यक है।

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

[!WARNING] हालाँकि, “Store Now, Decrypt Later (अभी सहेजें, बाद में डिक्रिप्ट करें)” नामक एक खतरे का मॉडल (threat model) मौजूद है। हमलावर वर्तमान में एन्क्रिप्टेड गोपनीय संचार डेटा को बड़ी मात्रा में सहेज सकते हैं, और 10 से 20 साल बाद एक शक्तिशाली क्वांटम कंप्यूटर पूरा होने के तुरंत बाद उन सभी को डिक्रिप्ट करने की रणनीति अपना सकते हैं।

7. पोस्ट-क्वांटम क्रिप्टोग्राफी (PQC) में स्थानांतरण

ऐसे “Q-Day (वह दिन जब क्वांटम कंप्यूटर एन्क्रिप्शन को तोड़ेंगे)” के आगमन की तैयारी में, अमेरिका के नेशनल इंस्टीट्यूट ऑफ स्टैंडर्ड्स एंड टेक्नोलॉजी (NIST) के नेतृत्व में, दुनिया भर के क्रिप्टोग्राफर पोस्ट-क्वांटम क्रिप्टोग्राफी (Post-Quantum Cryptography, PQC) के लिए मानक विकसित कर रहे हैं।

PQC नई गणितीय समस्याओं (जैसे कि जालक समस्याएँ (lattice problems), बहुभिन्नरूपी बहुपद समस्याएँ (multivariate polynomial problems), हैश फ़ंक्शन-आधारित आदि) पर आधारित है, जिनके बारे में गणितीय रूप से माना जाता है कि उन्हें शोर के एल्गोरिथ्म (या ग्रोवर के एल्गोरिथ्म) का उपयोग करके भी कुशलता से हल नहीं किया जा सकता है। “CRYSTALS-Kyber” और “CRYSTALS-Dilithium” जैसे एल्गोरिथ्म को पहले ही मानक विनिर्देशों के रूप में चुना जा चुका है, और इन्हें धीरे-धीरे Apple के iMessage और विभिन्न वेब ब्राउज़र के संचार प्रोटोकॉल में पेश किया जा रहा है।

IT इन्फ्रास्ट्रक्चर का प्रबंधन करने वाले इंजीनियरों के लिए, मौजूदा RSA और इलिप्टिक कर्व क्रिप्टोग्राफी (elliptic curve cryptography) से PQC में सिस्टमिक बदलाव करना, अर्थात् “क्रिप्टो-एजिलिटी (Crypto-agility: एन्क्रिप्शन विधियों को तेज़ी से बदलने की क्षमता)” को सिस्टम में शामिल करना, भविष्य का एक बड़ा मिशन होगा।

8. निष्कर्ष

इस लेख में, हमने शोर के एल्गोरिथ्म की सैद्धांतिक गणितीय पृष्ठभूमि से शुरुआत करके, क्वांटम फूरियर ट्रांसफॉर्म का उपयोग करके अवधि निष्कर्षण तंत्र, और अंततः Python और Qiskit का उपयोग करके विशिष्ट सिमुलेशन कोड तक, 10,000 वर्णों के पैमाने पर एक विस्तृत व्याख्या प्रदान की है।

यह तथ्य कि क्वांटम यांत्रिकी के सूक्ष्म विश्व के भौतिक नियम, मैक्रोस्कोपिक सूचना विज्ञान के मूल (जैसे कम्प्यूटेशनल जटिलता सिद्धांत और क्रिप्टोग्राफी सिद्धांत) को पूरी तरह से पलट सकते हैं, विज्ञान के इतिहास में सबसे रोमांचक प्रतिमान बदलावों (paradigm shifts) में से एक है। हमें क्वांटम कंप्यूटिंग तकनीक के चल ক্রিম विकास और इसके खिलाफ बचाव करने वाली नई एन्क्रिप्शन तकनीकों के बीच लड़ाई पर नज़र रखनी चाहिए।

हम आपको इस लेख में प्रस्तुत Python कोड को अपने स्वयं के वातावरण में निष्पादित करने के लिए प्रोत्साहित करते हैं, और क्वांटम अवस्था सुपरपोजिशन (superposition) और हस्तक्षेप (interference) द्वारा बनाए गए “कम्प्यूटेशनल जादू (magic of computation)” का अनुभव करते हैं।

संदर्भ (References)

Shor, P. W. (1994). “Algorithms for quantum computation: discrete logarithms and factoring”. Proceedings 35th Annual Symposium on Foundations of Computer Science.
Nielsen, M. A., & Chuang, I. L. (2010). “Quantum Computation and Quantum Information”. Cambridge University Press.
Qiskit Documentation: https://qiskit.org/documentation/