Shor का ECDLP के लिए एल्गोरिदम — Q-Day Prize Submission

Q-Day Prize Challenge के लिए Project Eleven द्वारा निर्मित Elliptic Curve Discrete Logarithm Problem (ECDLP) का क्वांटम हल। लक्ष्य: Shor के एल्गोरिदम का उपयोग करके वास्तविक क्वांटम हार्डवेयर पर ECC निजी कुंजियाँ प्राप्त करना।

• लेखक: Giancarlo Lelli
• संपर्क: [email protected]
• LinkedIn: https://www.linkedin.com/in/giancarlolelli
• पृष्ठभूमि: एंटरप्राइज़ सॉफ़्टवेयर, फुल-स्टैक आर्किटेक्चर और क्लाउड-नेटिव डेवलपमेंट में 10+ वर्षों का अनुभव रखने वाले टेक्नोलॉजी लीडर। .NET, Python, Rust और Cloud इकोसिस्टम में व्यावहारिक अनुभव के साथ कंप्यूटर साइंस में पृष्ठभूमि। वर्तमान में Cloud GTM Specialist के रूप में कार्यरत, जो सॉल्यूशन आर्किटेक्चर और सेल्स इंजीनियरिंग पर केंद्रित है।

दृष्टिकोण

सभी चुनौती वक्र F_p पर y^2 = x^3 + 7 का उपयोग करते हैं (a = 0, b = 7), जो secp256k1 परिवार से मेल खाता है। सॉल्वर ECDLP के लिए Shor के एल्गोरिदम के दो-रजिस्टर वेरिएंट को कार्यान्वित करता है:

1. गणना रजिस्टरों |j>, |k> को एकसमान सुपरपोज़िशन (Hadamard) में तैयार करें
2. 2t नियंत्रित बिंदु योग (t = num_counting qubits) के माध्यम से |j>|k>|jG + kQ> की गणना करें
3. बिंदु रजिस्टर को मापें, इसे किसी समूह तत्व R पर संक्षिप्त करें
4. गणना रजिस्टरों पर व्युत्क्रम QFT लागू करें
5. j, k मापें और संबंध j + kd = r (mod n) से d निकालें

समूह क्रम n के मॉड्यूलो समान रैखिक संबंध को संतुष्ट करने वाले कई (j, k) नमूने एकत्र करके निजी कुंजी d पुनर्प्राप्त की जाती है। सॉल्वर नियंत्रित बिंदु योगों के लिए छह संभावित रणनीतियों का समर्थन करता है, जिन्हें वक्र आकार के आधार पर स्वचालित रूप से या --oracle के माध्यम से मैन्युअल रूप से चुना जाता है।

Oracle रणनीतियाँ

रणनीति 1: Dense Unitary (n_bits <= 6 के लिए डिफ़ॉल्ट)

~6 बिट तक के समूह क्रम वाले वक्रों के लिए उपयोग किया जाता है। projecteleven.py में कार्यान्वित।

प्रत्येक नियंत्रित बिंदु योग "add S" को qc.unitary() के माध्यम से लागू 2^(n+1) x 2^(n+1) आव्यूह (permutation matrix) के रूप में दर्शाया जाता है। मैट्रिक्स पूर्ण समूह क्रिया को एन्कोड करता है: ऊपरी-बाएं ब्लॉक पहचान है (control=0), निचला-दायां ब्लॉक मैप P -> P+S (control=1) के अनुसार आधार अवस्थाओं को क्रमपरिवर्तित करता है।

• एन्कोडिंग: समूह सूचकांक (0..n-1)
• मेमोरी: प्रति मैट्रिक्स O(2^{2n})
• क्यूबिट: 2t + n (दो गणना रजिस्टर + बिंदु रजिस्टर)
• सीमा: Qiskit का एकात्मक अपघटन O(4^n) है, जो ~6-बिट से परे अव्यवहारिक बनाता है

रणनीति 2: Efficient Permutation Decomposition (n_bits > 6 के लिए डिफ़ॉल्ट)

बड़े वक्रों के लिए उपयोग किया जाता है। quantum_arithmetic.py में कार्यान्वित।

सघन आव्यूह बनाने के बजाय, प्रत्येक "add S" क्रमपरिवर्तन को चक्र-अपघटित करके क्रमचयों में बदल दिया जाता है। प्रत्येक क्रमचय (दो आधार अवस्थाओं का स्वैप |a> <-> |b>) को इस प्रकार कार्यान्वित किया जाता है:

1. CNOT न्यूनीकरण -- एक पिवट बिट से अन्य सभी भिन्न बिट्स पर CNOT, जो मल्टी-बिट अंतर को एकल-बिट अंतर तक कम करता है
2. मल्टी-नियंत्रित X -- पिवट बिट पर एक MCX गेट, जो अन्य सभी बिट्स के लक्ष्य पैटर्न से मेल खाने की शर्त पर होता है
3. CNOT को पूर्ववत करें -- गैर-पिवट बिट्स को पुनर्स्थापित करने के लिए चरण 1 को उलटें

MCX (n-2) समर्पित एंसिला क्यूबिट के साथ V-चेन अपघटन का उपयोग करता है, जो एंसिला के बिना O(n^2) के बजाय प्रति MCX O(n) Toffoli गेट देता है। प्रत्येक नियंत्रित जोड़ को एक पृथक उप-सर्किट के रूप में बनाया जाता है और एक एकल अपारदर्शी गेट के रूप में जोड़ा जाता है, जो Qiskit में द्विघात DAG वृद्धि से बचता है।

• एन्कोडिंग: समूह सूचकांक (0..n-1)
• मेमोरी: प्रति जोड़ O(N) (N = समूह क्रम)
• क्यूबिट: 2t + n + (n-2) एंसिला
• गेट प्रति जोड़: O(N * n)

रणनीति 3: Coordinate-Based Quantum Oracle (--oracle coordinate)

~6-बिट तक के वक्रों के लिए उपलब्ध। quantum_oracle.py में कार्यान्वित।

बिंदुओं को समूह सूचकांक के रूप में एन्कोड करने के बजाय, क्वांटम रजिस्टर में बाइनरी में वास्तविक (x, y) क्षेत्र-तत्व निर्देशांक और एक पहचान फ़्लैग होता है। बिंदु रजिस्टर का लेआउट है:

• x_reg: f_bits क्यूबिट (f_bits = ceil(log2(p)))
• y_reg: f_bits क्यूबिट
• id_flag: 1 क्यूबिट (1 = अनंत पर बिंदु)

प्रत्येक नियंत्रित "add S" की गणना सभी मान्य निर्देशांक एन्कोडिंग पर EC योग सूत्र से की जाती है, जो निर्देशांक रजिस्टर पर एक क्रमपरिवर्तन उत्पन्न करता है। इस क्रमपरिवर्तन को CNOT-न्यूनीकरण + MCX बुनियादी ढांचे का उपयोग करके उसी तरह से क्रमचयों में चक्र-अपघटित किया जाता है जैसे रणनीति 2 में।

• एन्कोडिंग: (x, y, id_flag) निर्देशांक
• क्यूबिट: 2t + 2f_bits + 1 + max(0, 2f_bits - 1) एंसिला
• गेट प्रति जोड़: O(N * f_bits)

रणनीति 4: Arithmetic Oracle (--oracle arithmetic)

बहुपद-पैमाने पर बिंदु योग के लिए ढांचा। quantum_oracle.py और quantum_arithmetic.py में कार्यान्वित।

निर्देशांक एन्कोडिंग (रणनीति 3 के समान) का उपयोग करता है जिसमें पूरी तरह से अंकगणितीय बिंदु योग की दिशा में बिल्डिंग ब्लॉक के रूप में QFT-आधारित मॉड्यूलर अंकगणितीय प्राइमिटिव शामिल हैं। कोडबेस में इनका परीक्षण कार्यान्वयन शामिल है:

• Beauregard मॉड्यूलर योजक -- QFT-आधारित (target + constant) mod p उचित एंसिला अनगणना के साथ
• क्वांटम-क्वांटम मॉड्यूलर गुणक -- |a>|b>|0> -> |a>|b>|a*b mod p> via shift-and-add स्पष्ट मॉड्यूलर दोहरीकरण के साथ, O(n^3) गेट
• मॉड्यूलर व्युत्क्रम क्रमपरिवर्तन -- |x> -> |x^{-1} mod p> via लुकअप टेबल क्रमचय
• नियंत्रित क्वांटम-क्वांटम मॉड्यूलर योग -- नियंत्रित |a> -> |a + b mod p> Beauregard न्यूनीकरण के साथ

अंकगणितीय प्राइमिटिव क्रमपरिवर्तन दृष्टिकोण के लिए O(N*n) की तुलना में प्रति बिंदु योग O(n^3) स्केलिंग प्राप्त करते हैं। हालांकि, QFT-आधारित संक्रियाओं में ~150x बड़ा स्थिर कारक होता है, जिससे अंकगणितीय दृष्टिकोण केवल ~20-बिट समूह क्रम से ऊपर के वक्रों के लिए अधिक कुशल होता है। वर्तमान चुनौती आकारों (12-बिट तक) के लिए, क्रमपरिवर्तन-आधारित योजक तेज़ रहता है और डिफ़ॉल्ट रूप से उपयोग किया जाता है।

रणनीति 5: Google Semiclassical Phase Estimation (--oracle google)

google_semiclassical.py में कार्यान्वित। Griffiths & Niu (1996) की qubit-पुनर्चक्रित चरण अनुमान तकनीक से प्रेरित, Babbush et al. (2026) द्वारा secp256k1 ECDLP संसाधन अनुमानों के लिए पैमाने पर लागू। Babbush et al. पेपर 30 मार्च, 2026 को प्रकाशित हुआ था।

दो बहु-क्यूबिट गणना रजिस्टरों (j, k) और बल्क व्युत्क्रम QFT को दो एकल पुनर्चक्रित क्यूबिट और शास्त्रीय रूप से वातानुकूलित चरण सुधारों से बदल देता है। प्रत्येक गणना रजिस्टर बिट को क्रमिक रूप से संसाधित किया जाता है: |+> में तैयार करें, नियंत्रित बिंदु योग लागू करें, पहले मापे गए सभी बिट्स के आधार पर चरण सुधारें, फिर मापें। Qiskit में reset और if_test डायनेमिक सर्किट प्रिमिटिव IBM Quantum हार्डवेयर पर इसे सक्षम करते हैं।

नियंत्रित बिंदु योगों के लिए oracle मौजूदा बुनियादी ढांचे (<= 6-बिट के लिए सघन एकात्मक, > 6-बिट के लिए कुशल क्रमपरिवर्तन) को सौंपा गया है, इसलिए क्यूबिट बचत पूरी तरह से गणना रजिस्टरों को खत्म करने से आती है।

• एन्कोडिंग: अंतर्निहित रणनीति (समूह सूचकांक) के समान
• क्यूबिट: 2 + n_bits + ancillas (बनाम 2t + n_bits + ancillas)
• व्यापार-बंद: डायनेमिक सर्किट (मध्य-सर्किट माप, रीसेट, शास्त्रीय रूप से वातानुकूलित गेट) की आवश्यकता होती है। IBM Heron r2 पर 7-बिट तक काम करता है; 8-बिट+ पर शास्त्रीय फीडबैक सिंक्रोनाइज़ेशन ओवरहेड QPU समय बजट से अधिक हो जाता है

रणनीति 6: Ripple-Carry Modular Addition (--oracle ripple)

ripple_carry_shor.py में कार्यान्वित। नियंत्रित बिंदु योगों के लिए CDKM रिपल-कैरी योजक (Cuccaro et al. 2004) का उपयोग करता है, जो सघन एकात्मक आव्यूह और चक्र-अपघटित क्रमचय सर्किट दोनों को प्रतिस्थापित करता है।

समूह-सूचकांक एन्कोडिंग में, बिंदु P = kG को चक्रीय समूह में इसके सूचकांक k द्वारा दर्शाया जाता है। S = sG जोड़ना शास्त्रीय स्थिरांक s का मॉड्यूलर योग (mod n) बन जाता है। मुख्य अंतर्दृष्टि: प्रत्येक नियंत्रित बिंदु योग एक ज्ञात स्थिरांक के एकल नियंत्रित मॉड्यूलर योग में कम हो जाता है, जिसे Qiskit के CDKMRippleCarryAdder और IntegerComparator के माध्यम से कार्यान्वित किया जाता है।

Oracle में 2m नियंत्रित मॉड्यूलर योग होते हैं (प्रति गणना रजिस्टर m), जहाँ प्रत्येक नियंत्रित mod-add निम्न कार्य करता है:

1. नियंत्रण क्यूबिट से एंसिला रजिस्टर में स्थिरांक लोड करें CX के माध्यम से
2. CDKM हाफ-एडर एंसिला को संचायक में जोड़ने के लिए (केवल निकटतम-पड़ोसी गेट)
3. पूर्णांक तुलनित्र अतिप्रवाह का पता लगाने के लिए (acc >= n)
4. शर्तसापेक्ष घटाव n का फ़्लैग-नियंत्रित जोड़ 2^m1 - n के माध्यम से
5. फ़्लैग अनगणना कैरी-आधारित जांच के माध्यम से

सर्किट निर्माण में निजी कुंजी d के किसी ज्ञान का उपयोग नहीं किया जाता है। G-पावर के लिए समूह सूचकांक 2^i mod n (सार्वजनिक) के रूप में गणना की जाती है। Q-पावर के लिए समूह सूचकांक G द्वारा उत्पन्न चक्रीय समूह की सार्वजनिक गणना से प्राप्त होते हैं — बिंदु Q को इस गणना में खोजा जाता है।

• एन्कोडिंग: समूह सूचकांक (0..n-1)
• क्यूबिट: 4m + 5 जहाँ m = ceil(log2(n))
• गेट प्रति जोड़: O(m) CDKM संक्रियाएँ, प्रत्येक O(m) CX गेट
• कुल CX स्केलिंग: O(m^3)
• हार्डवेयर मैपिंग: CDKM केवल निकटतम-पड़ोसी गेट का उपयोग करता है, जो IBM हेवी-हेक्स टोपोलॉजी पर ~1x रूटिंग ओवरहेड देता है (QFT-आधारित योजकों के लिए 26-33x की तुलना में)

तुलना

QFT अंकगणितीय प्राइमिटिव

कोडबेस में QFT-आधारित मॉड्यूलर अंकगणितीय बिल्डिंग ब्लॉक (Beauregard/Draper योजक, क्वांटम-क्वांटम मॉड्यूलर गुणन, मॉड्यूलर व्युत्क्रम/नकार) पूरी तरह से अंकगणितीय निर्देशांक-एन्कोडिंग के लिए 256-बिट पर एक नींव के रूप में शामिल हैं। इन प्राइमिटिव को p=13 तक के अभाज्यों के लिए Statevector सिमुलेशन के माध्यम से सही सत्यापित किया गया है।

परिणाम

IBM क्वांटम हार्डवेयर पर 17-बिट तक की चुनौती वक्रों के लिए सफलतापूर्वक निजी कुंजियाँ प्राप्त कीं:

सभी रन IBM Quantum ओपन-इंस्टेंस प्लान पर निष्पादित किए गए, जो प्रति माह 10 मिनट मुफ्त क्वांटम कम्प्यूटेशन प्रदान करता है। पूर्ण निष्पादन लॉग executions/ फ़ोल्डर में हैं।

रिपल-कैरी रणनीति (रणनीति 6) ने एक बड़ी छलांग सक्षम की: 10-बिट (40 क्यूबिट, 2M गेट) से 17-बिट (69 क्यूबिट, 112K गेट) तक — 7-बिट कुंजी आकार में वृद्धि के साथ दो-क्यूबिट गेट गणना में 18 गुना कमी। CDKM योजक की निकटतम-पड़ोसी गेट संरचना IBM के हेवी-हेक्स टोपोलॉजी पर कुशलतापूर्वक मैप होती है, रूटिंग ओवरहेड को ~1x पर रखती है।

Semiclassical PE: IBM हार्डवेयर पर डायनेमिक सर्किट

Semiclassical रणनीति (--oracle google) ने IBM Heron r2 प्रोसेसर पर डायनेमिक सर्किट (मध्य-सर्किट reset, शास्त्रीय रूप से वातानुकूलित p गेट if_test के माध्यम से) का उपयोग करके 4-बिट, 6-बिट और 7-बिट पर सफलतापूर्वक कुंजियाँ प्राप्त कीं। 7-बिट पर, सर्किट केवल 14 क्यूबिट का उपयोग करता है (मानक क्रमपरिवर्तन दृष्टिकोण के लिए 26 की तुलना में) जबकि ट्रांसपिलेशन के बाद तुलनीय 2Q गेट गणना उत्पन्न करता है।

8-बिट और उससे ऊपर, सेमीक्लासिकल दृष्टिकोण वर्तमान IBM हार्डवेयर पर अव्यवहारिक हो जाता है। हालाँकि if_else और reset Heron r2 पर समर्थित हैं (बैकएंड लक्ष्य निरीक्षण के माध्यम से पुष्टि), प्रत्येक शास्त्रीय फीडबैक बिंदु के लिए पूर्ण QPU सिंक्रोनाइज़ेशन की आवश्यकता होती है — सभी 156 भौतिक क्यूबिट को निष्क्रिय रहना चाहिए जबकि शास्त्रीय नियंत्रक ~16 सक्रिय क्यूबिट के लिए सशर्त को संसाधित करता है। ~295K CZ गेट को 16+ फीडबैक बिंदुओं पर विभाजित करने पर, प्रति-शॉट निष्पादन ओवरहेड जॉब को QPU समय बजट से अधिक कर देता है। मानक क्रमपरिवर्तन दृष्टिकोण, जो डायनेमिक सर्किट के बिना एक सतत बैच के रूप में समान गेट गणना चलाता है, इस पैमाने पर सफलतापूर्वक पूरा होता है।

एक अनुमानित QFT छंटाई (max_corrections पैरामीटर) if_else ब्लॉकों की संख्या को O(n^2) से O(n) तक कम कर देता है, प्रति माप चरण में केवल निकटतम k चरण सुधारों को बनाए रखते हुए (k से परे के कोण < pi/2^{k+1} का योगदान करते हैं, जो हार्डवेयर शोर तल से नीचे है)। max_corrections=1 के साथ, 8-बिट सर्किट में 16 if_else ब्लॉक हैं — फिर भी इस गेट गणना पर IBM हार्डवेयर पर टाइमआउट का कारण बनने के लिए पर्याप्त है।

शोर और निष्ठा विश्लेषण

अनुमानित सर्किट निष्ठा

~99.5% की विशिष्ट IBM Quantum दो-क्यूबिट (CX) गेट निष्ठा मानते हुए, अनुमानित सर्किट निष्ठा गेट गणना के साथ तेजी से घटती है:

सर्किट निष्ठा F ≈ (0.995)^{CX_count} के रूप में गणना की जाती है। 4-बिट से परे सब कुछ के लिए, अनुमानित निष्ठा खगोलीय रूप से छोटी है — आउटपुट वितरण अत्यधिक शोर है।

यह अभी भी क्यों काम करता है

8-बिट और उससे ऊपर, प्रत्येक शॉट लगभग एक अद्वितीय बिटस्ट्रिंग उत्पन्न करता है (8-बिट पर 8,192 शॉट्स में से 8,128 अद्वितीय परिणाम; 16-बिट और 17-बिट पर सभी 20,000 अद्वितीय)। बिटस्ट्रिंग स्तर पर आउटपुट एकसमान यादृच्छिक नमूने से अप्रभेद्य है। फिर भी एल्गोरिदम सही निजी कुंजी को पुनर्प्राप्त करता है।

मुख्य अंतर्दृष्टि यह है कि Shor का पोस्ट-प्रोसेसिंग शोर के प्रति मजबूत है, जैसा कि कच्चा बिटस्ट्रिंग विश्लेषण नहीं है। प्रत्येक शॉट एक (j, k, r) माप ट्रिपल उत्पन्न करता है। निष्कर्षण d_cand = (r - j) · k^{-1} mod n की गणना करता है और d_cand · G == Q के माध्यम से सत्यापित करता है। केवल सही d ही EC सत्यापन पास करता है, इसलिए हजारों शोर शॉट्स के बीच एक भी सही उम्मीदवार पर्याप्त है।

एक विशुद्ध रूप से यादृच्छिक (j, k, r) ट्रिपल ~1/n की संभावना के साथ सही d_cand उत्पन्न करता है। S शॉट्स के साथ, अकेले शोर से सत्यापित हिट की अपेक्षित संख्या ~S/n है। 17-बिट (n=65,173, S=20,000) पर, यह ~0.3 अपेक्षित शोर हिट देता है — इस पैमाने पर कोई भी सफल पुनर्प्राप्ति शास्त्रीय शोर तल से परे क्वांटम संकेत का सबूत प्रदान करती है।

छोटे वक्रों के लिए जहाँ shots >> n (जैसे, 10-बिट जिसमें n=547 और 1,024 शॉट), शोर तल ~1,024/547 ≈ 1.9 वोट प्रति उम्मीदवार है। यहां तक कि मुट्ठी भर संकेत-युक्त शॉट सही d को शोर तल से ऊपर धकेल देते हैं। यह बताता है कि सर्किट निष्ठाओं के बावजूद एल्गोरिदम कैसे सफल होता है जो गणना को असंभव बना देगा।

क्वांटम संकेत बनाम शास्त्रीय शोर

टॉय पैमाने पर, निष्कर्षण का सत्यापन चरण (d_cand * G == Q) एक फिल्टर के रूप में कार्य करता है जो केवल सही d को स्वीकार करता है। इसका मतलब है कि पूरी तरह से यादृच्छिक (j, k, r) ट्रिपल भी प्रति रन लगभग shots / n की दर से मान्य उम्मीदवार उत्पन्न करेंगे। जब shots >> n, अकेला यादृच्छिक शोर उच्च संभावना के साथ d पुनर्प्राप्त कर सकता है।

यह परीक्षण करने के लिए कि क्या क्वांटम सर्किट इस शास्त्रीय शोर तल से परे संकेत का योगदान देता है, हमने 6-बिट चुनौती (n=31) को केवल 8 शॉट्स (समूह क्रम से काफी नीचे) के साथ ibm_kingston पर 10 बार चलाया:

परिणाम: 4/10 सफलता (40%) बनाम ~20% का शास्त्रीय शोर आधार रेखा (मोंटे कार्लो सिमुलेशन के माध्यम से गणना: (r-j)*k_inv mod 31 के साथ 8 यादृच्छिक बिटस्ट्रिंग सत्यापन के माध्यम से फ़िल्टर की गई)। एक-पूंछ वाला द्विपद परीक्षण: P(X >= 4 | n=10, p=0.20) = 0.121, जो शोर तल पर 2x सुधार दर्शाता है। हालांकि p < 0.05 पर व्यक्तिगत रूप से सांख्यिकीय रूप से महत्वपूर्ण नहीं है (जिसके लिए 5+ सफलताओं की आवश्यकता होगी), देखी गई दर एक क्वांटम संकेत के अनुरूप है जो प्रति रन यादृच्छिक मौका प्रदान करने के अलावा लगभग 1-2 अतिरिक्त मान्य (j, k) जोड़े का योगदान देता है।

यह परिणाम शास्त्रीय शोर तल और सैद्धांतिक क्वांटम लाभ शासन के बीच बैठता है। बड़े वक्र आकारों पर जहाँ n >> shots, शोर आधार रेखा 1% से नीचे गिर जाती है और कोई भी सफल कुंजी पुनर्प्राप्ति क्वांटम गणना का मजबूत सबूत बन जाती है।

त्वरित प्रारंभ```bash

git clone https://github.com/GiancarloLelli/quantum.git cd quantum

python -m venv . Scripts\Activate.ps1 # For Windows only

pip install -r requirements.txt

### कैसे चलाएं

आपको एक [IBM Quantum](https://quantum.ibm.com/) खाता चाहिए। पहली बार चलाने पर अपना API टोकन दर्ज करें और यह स्थानीय रूप से सहेज लिया जाएगा:```bash
# Solve the 4-bit challenge curve:
python projecteleven.py --challenge 4 --token YOUR_IBM_TOKEN --backend ibm_marrakesh

# Subsequent runs (token already saved):
python projecteleven.py --challenge 4 --backend ibm_marrakesh

# Use the coordinate-based quantum oracle:
python projecteleven.py --challenge 4 --oracle coordinate --backend ibm_marrakesh

# Use the arithmetic oracle (coordinate encoding + QFT primitives):
python projecteleven.py --challenge 4 --oracle arithmetic --backend ibm_marrakesh

# Use ripple-carry modular addition (CDKM — best for 8-bit+):
python projecteleven.py --challenge 16 --oracle ripple --backend ibm_fez --shots 20000

# Use Google semiclassical phase estimation (qubit-recycled):
python projecteleven.py --challenge 4 --oracle google --backend ibm_marrakesh

# Use a specific IBM Quantum instance:
python projecteleven.py --challenge 4 --instance ibm-q/open/main --backend ibm_marrakesh

# Verify curve parameters without quantum execution:
python projecteleven.py --curve curve_4 --verify-only

CLI Options

परियोजना संरचना```

projecteleven.py # Shor solver — dense unitary approach + CLI entry point quantum_arithmetic.py # Efficient permutation decomposition + QFT arithmetic primitives quantum_oracle.py # Coordinate-based oracle + arithmetic oracle framework google_semiclassical.py # Google semiclassical PE — qubit-recycled phase estimation ripple_carry_shor.py # Ripple-carry modular addition oracle (CDKM) — best for 8-bit+ input_curves.json # Challenge curves (4-bit to 30-bit) problem/curves.py # Curve generation utility requirements.txt # qiskit, qiskit-ibm-runtime

## संदर्भ

- P. Shor, ["क्वांटम गणना के लिए एल्गोरिदम: असतत लघुगणक और गुणनखंडन"](https://arxiv.org/abs/quant-ph/9508027) (1994)
- S. Beauregard, ["शोर के एल्गोरिदम के लिए 2n+3 क्विबिट का उपयोग कर सर्किट"](https://arxiv.org/abs/quant-ph/0205095) (2003)
- S. A. Cuccaro, T. G. Draper, S. A. Kutin, D. P. Moulton, ["एक नया क्वांटम रिपल-कैरी जोड़ सर्किट"](https://arxiv.org/abs/quant-ph/0410184) (2004)
- M. Roetteler, M. Naehrig, K. Svore, K. Lauter, ["अण्डाकार वक्र असतत लघुगणक की गणना के लिए क्वांटम संसाधन अनुमान"](https://arxiv.org/abs/1706.06752) (2017)
- R. Griffiths, C.-S. Niu, ["क्वांटम गणना के लिए अर्धशास्त्रीय फूरियर रूपांतरण"](https://arxiv.org/abs/quant-ph/9511007) (1996)
- R. Babbush et al., ["क्वांटम कमजोरियों के विरुद्ध अण्डाकार वक्र क्रिप्टोकरेंसी की सुरक्षा: संसाधन अनुमान और शमन"](https://quantumai.google/static/site-assets/downloads/cryptocurrency-whitepaper.pdf) (2026)

## लाइसेंस

यह परियोजना Q-Day Prize Challenge के लिए एक प्रस्तुति है जो [MIT LICENSE](https://github.com/yuvadm/quantumslop/blob/HEAD/LICENSE) के तहत जारी की गई है।