स्थान-कुशल बिंदु-योग के साथ अण्डाकार वक्र असतत लघुगणक के लिए क्वांटम एल्गोरिदम

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

वर्तमान कोडबेस तीन वर्कफ़्लो पर केंद्रित है:

1. मॉड्यूलर इन्वर्ज़न सर्किट की चंकवार पुनरावर्ती गणना;
2. सर्किट का वैकल्पिक स्थानीय NCT-टेम्पलेट अनुकूलन;
3. रैप किए गए एफ़ाइन बिंदु-योग सर्किट का संकलित ब्लॉकवार संसाधन अनुमान।

रिपॉज़िटरी संरचना

.
├── README.md
│
├── eea_model/: original classical EEA reference implementation used for algorithm prototyping and correctness validation.
│
├── run_eea_s835_fastdual_recursive_chunks_checkpoint.py
├── run_eea_s835_fastdual_recursive_chunks_checkpoint_nctopt.py
├── count_s835_fastdual_wrapped_point_addition_blocks_compiled.py
│
├── eea_circuit.py
├── eea_circuit_s835_fastdual.py
├── eea_circuit_s835_lowaux.py
├── eea_circuit_updated.py
├── under1000_eea_shared_s835_fastdual_wrapped.py
├── under1000_modular_arithmetic_base.py
│
├── point_addition_fig14_s835_fastdual_wrapped_quadratic.py
├── quadratic_fig15_inplace_s835_fastdual_wrapped.py
├── quadratic_gidney_arithmetic.py
├── quadratic_lazy_instruction.py
├── quadratic_modular_arithmetic.py
├── quadratic_squ_minus.py
│
├── ccx_recursive_block_counter.py
├── nct_template_segment_optimizer.py
│
├── test_eea_strict_main.py
└── test_point_addition_strict_main.py

मुख्य प्रवेश स्क्रिप्ट

• run_eea_s835_fastdual_recursive_chunks_checkpoint.py
  EEA एल्गोरिदम-3 चरणों की चेकपॉइंटेड चंकों में पुनरावर्ती गणना करता है।

• run_eea_s835_fastdual_recursive_chunks_checkpoint_nctopt.py
  वही EEA गणना वर्कफ़्लो, लेकिन स्थानीय NCT-टेम्पलेट अनुकूलन के साथ।

• count_s835_fastdual_wrapped_point_addition_blocks_compiled.py
  रैप किए गए बिंदु-योग सर्किट की गणना, पुन: प्रयोज्य संकलित उप-ब्लॉकों की पुनरावर्ती गणना करके तथा दोहराए गए अंकगणितीय घटकों को सटीक बहुलताओं के साथ जोड़कर करता है।

EEA फ़ाइलें

• eea_circuit_s835_fastdual.py: प्रोडक्शन EEA सर्किट का मुख्य कार्यान्वयन।
• eea_circuit_s835_lowaux.py: मुख्य कार्यान्वयन द्वारा उपयोग की जाने वाली निम्न-सहायक हेल्पर रूटीन।
• eea_circuit_updated.py: साझा EEA निर्माण खंड और पुनरावर्ती संसाधन-गणना उपयोगिताएँ।
• eea_circuit.py: परीक्षणों के लिए पिछड़ा-संगतता रैपर।

बिंदु-योग और अंकगणित फ़ाइलें

• point_addition_fig14_s835_fastdual_wrapped_quadratic.py: Fig.14 अनुसूची के अनुरूप रैप किए गए एफ़ाइन बिंदु-योग सर्किट का निर्माण करता है।
• quadratic_fig15_inplace_s835_fastdual_wrapped.py: EEA, गुणन, मापन, रीसेट और फ़ीड-फ़ॉरवर्ड फेज़ सुधार के साथ Fig.15 इन-प्लेस विभाजन और इन-प्लेस गुणन संरचना का निर्माण करता है।
• quadratic_modular_arithmetic.py: बिंदु-योग काउंटर द्वारा उपयोग किए जाने वाले मॉड्यूलर जोड़/घटाव, गुणन, व्युत्क्रम गुणन, द्विगुणन और अर्धांशन निर्देश।
• quadratic_gidney_arithmetic.py: क्वाड्रैटिक मॉड्यूलर अंकगणित परत द्वारा उपयोग किए जाने वाले Gidney-शैली अंकगणितीय प्रिमिटिव और मापन व फ़ीड-फ़ॉरवर्ड हेल्पर।
• quadratic_squ_minus.py: एफ़ाइन बिंदु-योग अनुसूची में उपयोग किया जाने वाला स्क्वायर-माइनस ब्लॉक।
• under1000_eea_shared_s835_fastdual_wrapped.py: बिंदु-योग सर्किट द्वारा उपयोग किया जाने वाला साझा EEA रैपर और हेल्पर।
• under1000_modular_arithmetic_base.py: छोटी साझा मॉड्यूलर-अंकगणित उपयोगिताएँ।

गणना और अनुकूलन उपयोगिताएँ

• ccx_recursive_block_counter.py: MCX विस्तार और SWAP विस्तार के लिए नीतियों के साथ Qiskit सर्किट के लिए पुनरावर्ती काउंटर।
• nct_template_segment_optimizer.py: {X, CX, CCX} सेगमेंट के लिए स्थानीय टेम्पलेट-आधारित अनुकूलक।

आवश्यकताएँ

अनुशंसित वातावरण:

• Python 3.10+
• Qiskit

मुख्य निर्भरता स्थापित करें:

python -m pip install --upgrade pip
python -m pip install qiskit

त्वरित आरंभ

परीक्षण सूट चलाएँ:

python test_eea_strict_main.py
python test_point_addition_strict_main.py

तेज़ बिंदु-योग स्मोक टेस्ट के लिए:

python test_point_addition_strict_main.py --skip-n256 --skip-report

1. EEA पुनरावर्ती चंक गणना

मानक EEA गणना प्रवेश बिंदु है:

python run_eea_s835_fastdual_recursive_chunks_checkpoint.py \
  --n 192 \
  --chunk-size 25 \
  --measurement-uncompute \
  --resume \
  --workdir eea_s835_fastdual_chunks25 \
  --out eea_s835_fastdual_algorithm3_recursive_chunks_n192_measurement.json

महत्वपूर्ण तर्क:

• --n: बिट चौड़ाई।
• --T-max: एल्गोरिदम-3 चरणों की संख्या के लिए वैकल्पिक ओवरराइड; डिफ़ॉल्ट रूप से eea.get_n_config(n) से मान उपयोग किया जाता है।
• --chunk-size: प्रति चेकपॉइंट चंक में गिने जाने वाले एल्गोरिदम-3 चरणों की संख्या।
• --aux-size: हेल्पर-क्यूबिट पूल के लिए वैकल्पिक ओवरराइड; छोड़े जाने पर लेआउट हेल्पर आकार स्वचालित रूप से परिकलित होता है।
• --measurement-uncompute: गिने गए EEA ब्लॉकों में मापन-आधारित अनकंप्यूटेशन सक्षम करता है।
• --resume: --workdir में मौजूदा गैर-रिक्त चंक JSON फ़ाइलों का पुन: उपयोग करता है।
• --workdir: प्रति-चंक चेकपॉइंट फ़ाइलों के लिए निर्देशिका।
• --out: प्रत्येक चंक के बाद लिखा जाने वाला संचयी JSON सारांश।

स्क्रिप्ट प्रति-चंक फ़ाइलें लिखती है जैसे:

eea_s835_fastdual_chunks25/eea_s835_fastdual_n192_T0001_0025.json

और एक संचयी आउटपुट JSON जिसमें निम्न फ़ील्ड शामिल हैं:

mode
n
T_max
num_qubits
len_width
shift_width
aux_size
measurement_based
ops
chunks
elapsed_s_so_far

2. NCT-टेम्पलेट अनुकूलन के साथ EEA गणना

अनुकूलित गणना प्रवेश बिंदु है:

python run_eea_s835_fastdual_recursive_chunks_checkpoint_nctopt.py \
  --n 128 \
  --chunk-size 25 \
  --measurement-uncompute \
  --templates small-nct \
  --rounds 1 \
  --max-nct-segment-gates 40 \
  --segment-timeout-s 10 \
  --timeout-mode auto \
  --resume \
  --workdir eea_s835_fastdual_chunks_nctopt_failopen_r1_128_seg40_to10 \
  --out eea_s835_fastdual_algorithm3_recursive_chunks_n128_measurement_nctopt_failopen_r1_seg40_to10.json

यह वर्कफ़्लो {X, CX, CCX} सेगमेंट पर स्थानीय टेम्पलेट अनुकूलन का प्रयास करता है। इसे एक सीमित फ़ेल-ओपन काउंटर के रूप में डिज़ाइन किया गया है: यदि कोई अनुकूलित चरण टाइमआउट करता है या अपवाद उत्पन्न करता है, तो उस चरण की गणना टेम्पलेट राउंड के बिना सटीक रूप से की जाती है और फिर चेकपॉइंट किया जाता है, इसलिए अंतिम रिपोर्ट की गई गणनाएँ पूर्ण रहती हैं।

मानक EEA तर्कों के अतिरिक्त उपयोगी तर्क:

• --templates {small-nct,all-nct}: टेम्पलेट लाइब्रेरी चयन।
• --rounds: टेम्पलेट-अनुकूलन राउंड की संख्या।
• --max-nct-segment-gates: टेम्पलेट अनुकूलन के लिए भेजे गए प्रतिवर्ती सेगमेंट का अधिकतम आकार।
• --max-nct-segment-qubits: सेगमेंट में क्यूबिट की अधिकतम संख्या।
• --segment-timeout-s: व्यक्तिगत सेगमेंट अनुकूलन के लिए टाइमआउट।
• --step-timeout-s: अपरिवर्तित गणना पर वापस गिरने से पहले पूरे एल्गोरिदम-3 चरण के लिए टाइमआउट।
• --fallback-step-timeout-s: सटीक फ़ॉलबैक गणना के लिए टाइमआउट।
• --force: चरण/चंक चेकपॉइंट पहले से मौजूद होने पर भी पुनर्गणना करता है।
• --ignore-policy-mismatch: अनुकूलन नीति भिन्न होने पर भी पुराने चेकपॉइंट का पुन: उपयोग करता है; यह मुख्य रूप से डीबगिंग के लिए है।

अनुकूलित वर्कफ़्लो चरण-स्तरीय चेकपॉइंट इनके अंतर्गत लिखता है:

<workdir>/steps/

और चंक-स्तरीय सारांश इनके अंतर्गत:

<workdir>/

3. रैप किए गए बिंदु-योग का संकलित ब्लॉकवार गणना

बिंदु-योग काउंटर उपरोक्त EEA वर्कफ़्लो में से किसी एक द्वारा निर्मित EEA एल्गोरिदम-3 JSON पर निर्भर करता है। बिंदु-योग काउंटर का --n मान EEA JSON में n फ़ील्ड से मेल खाना चाहिए।

n=64 के लिए उदाहरण:

python run_eea_s835_fastdual_recursive_chunks_checkpoint.py \
  --n 64 \
  --chunk-size 25 \
  --measurement-uncompute \
  --resume \
  --workdir eea_s835_fastdual_chunks25_n64 \
  --out eea_s835_fastdual_algorithm3_recursive_chunks_n64_measurement.json

फिर चलाएँ:

python count_s835_fastdual_wrapped_point_addition_blocks_compiled.py \
  --n 64 \
  --eea-steps-json eea_s835_fastdual_algorithm3_recursive_chunks_n64_measurement.json \
  --out point_addition_s835_fastdual_wrapped_blocks_compiled_counts_n64.json

अनुकूलित n=128 EEA आउटपुट के लिए उदाहरण:

python count_s835_fastdual_wrapped_point_addition_blocks_compiled.py \
  --n 128 \
  --eea-steps-json eea_s835_fastdual_algorithm3_recursive_chunks_n128_measurement_nctopt_failopen_r1_seg40_to10.json \
  --out point_addition_s835_fastdual_wrapped_blocks_compiled_counts_n128.json

महत्वपूर्ण तर्क:

• --n: बिट चौड़ाई।
• --p: मापांक; डिफ़ॉल्ट रूप से secp256k1 अभाज्य संख्या।
• --s-qubits: साझा EEA अंकगणित रजिस्टर आकार के लिए वैकल्पिक ओवरराइड।
• --point-constant {secp256k1-generator,zero,custom}: Fig.14 स्थिर-निर्देशांक अद्यतनों के लिए बिंदु स्थिरांक चयन।
• --x2, --y2: कस्टम बिंदु निर्देशांक; --point-constant custom उपयोग करने पर आवश्यक।
• --eea-steps-json: पुनरावर्ती एल्गोरिदम-3 EEA गणनाओं वाली JSON फ़ाइल।
• --allow-eea-n-mismatch: डीबग-केवल ओवरराइड जो EEA JSON n को अनुरोधित --n से भिन्न होने की अनुमति देता है।
• --mcx-policy {clean-vchain,keep}: पुनरावर्ती गणना के लिए MCX विस्तार नीति।
• : छोटे के लिए, पूर्ण गुणन/वर्गन परिभाषाओं की पुनरावर्ती गणना करें और उनकी तुलना संयोजित ब्लॉक गणनाओं से करें।

आउटपुट रिपोर्ट में शामिल हैं:

counting_mode
n
p
point_constant_kind
qiskit_width_report
eea_meta
block_summaries
raw_block_counters
key_ccx
validation
elapsed_s

बिंदु-योग काउंटर पुन: प्रयोज्य Qiskit सर्किट बनाता है, उन्हें {CCX, CX, X} आधार में पुनरावर्ती रूप से गिनता है, और फिर गुणन, व्युत्क्रम गुणन, इन-प्लेस विभाजन, इन-प्लेस गुणन, स्क्वायर-माइनस और कुल Fig.14 बिंदु-योग ब्लॉक जैसे बड़े दोहराए गए ब्लॉकों को संयोजित करता है।

परीक्षण

इस रिपॉज़िटरी में दो सादे Python परीक्षण ड्राइवर शामिल हैं। वे जानबूझकर pytest, Aer, या पूर्ण statevector सिमुलेशन के बिना लिखे गए हैं। परीक्षण जहाँ उपयुक्त हो Qiskit परिभाषाओं का पुनरावर्ती विस्तार करते हैं और Toffoli-नेटवर्क ब्लॉकों के लिए कम्प्यूटेशनल-आधार अवस्थाओं का अनुकरण करते हैं।

EEA सख्त परीक्षण

EEA परीक्षण इसमें हैं:

test_eea_strict_main.py

डिफ़ॉल्ट EEA सूट चलाएँ:

python test_eea_strict_main.py

डिफ़ॉल्ट सूट जाँचता है:

• कार्यान्वयन छोटे-n एंडपॉइंट शॉर्टकट नहीं है;
• एल्गोरिदम-3 डैश्ड-ब्लॉक अनुसूची मौजूद है;
• कई छोटी चौड़ाइयों पर सक्रिय-विंडो सूत्र;
• यूनरी पुनरावृत्ति, पूर्व/पश्च शिफ्ट, फेज़ अद्यतन, स्थान-नियंत्रित स्वैप और लंबाई-अद्यतन ब्लॉक;
• डिफ़ॉल्ट अभाज्य संख्याओं 3, 5, 7, 11, 13, 17 के लिए एल्गोरिदम-3 एंडपॉइंट, सटीक चरण गणनाओं और निश्चित T_max दोनों का उपयोग करके;
• छोटे डिफ़ॉल्ट अभाज्य 3, 5, 7 के लिए पूर्ण एल्गोरिदम-1 रैपर।

उपयोगी वेरिएंट:

# Fast structural + block tests only.
python test_eea_strict_main.py --skip-endpoint --skip-alg1

# Include the heavier PDF/Table-4 p=37, x=13 trace benchmark.
python test_eea_strict_main.py --table4

# Test all x values for primes above 13 as well.
python test_eea_strict_main.py --primes 3 5 7 11 13 17 --mid-all-x --verbose

बिंदु-योग सख्त परीक्षण

बिंदु-योग परीक्षण इसमें हैं:

test_point_addition_strict_main.py

डिफ़ॉल्ट बिंदु-योग सूट चलाएँ:

python test_point_addition_strict_main.py

डिफ़ॉल्ट बिंदु-योग सूट जाँचता है:

• रैप किए गए बिंदु-योग रजिस्टर लेआउट;
• n=256 चौड़ाई पहचान 835 = 1 + 3*256 + 66;
• Fig.14/Fig.15 शीर्ष-स्तरीय संक्रिया क्रम;
• H, measure, reset, क्लासिकल-नियंत्रित Z, और swap संक्रियाओं से युक्त स्पष्ट डायनामिक-सर्किट संरचना;
• छोटे मापांक के लिए संकलित अंकगणितीय उप-ब्लॉक संयोजन;
• सिंथेटिक एल्गोरिदम-3 JSON का उपयोग करके एक छोटी एकीकृत बिंदु-योग काउंटर रिपोर्ट, ताकि बड़ी EEA गणना चलाए बिना रिपोर्ट पथ का परीक्षण किया जा सके।

बड़े-अभाज्य प्रतिगमन मैट्रिक्स क्षेत्र की बिट चौड़ाई n और अभाज्य मापांक p के प्रतिनिधि युग्मों को कवर करता है, जो 12-बिट से 512-बिट अभाज्य क्षेत्रों तक है। परीक्षण किए गए उदाहरणों में शामिल हैं, उदाहरण के लिए, n=16, p=65521, n=32, p=4294967291, n=256 पर secp256k1 अभाज्य, तथा n=128, 160, 192, 224, 384, 512 पर प्रतिनिधि अभाज्य।

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

उपयोगी वेरिएंट:

# Skip the tiny integrated report and only check construction/schedule/assembly.
python test_point_addition_strict_main.py --skip-report

# Fast smoke test that also skips the n=256 width construction check.
python test_point_addition_strict_main.py --skip-n256 --skip-report

# Use a different small prime/width for compiled-block validation.
python test_point_addition_strict_main.py --n 5 --p 17

यदि Qiskit स्थापित नहीं है, तो test_point_addition_strict_main.py एक स्किप संदेश प्रिंट करता है और सफलतापूर्वक बाहर निकल जाता है। EEA सख्त परीक्षण के लिए Qiskit आवश्यक है क्योंकि यह EEA/PDF ब्लॉक गेट बनाता है।

मुख्य आँकड़ों का पुनरुत्पादन

हमारे पेपर में निम्नलिखित के लिए संख्यात्मक संसाधन-अनुमान परिणाम रिपोर्ट किए गए हैं:

n = 64, 128, 160, 192, 224, 256, 384, 512

एक विशिष्ट वर्कफ़्लो है:

1. किसी दिए गए n के लिए EEA एल्गोरिदम-3 काउंटर चलाएँ;
2. वैकल्पिक रूप से उसी n के लिए NCT-अनुकूलित संस्करण चलाएँ;
3. परिणामी EEA JSON को रैप किए गए बिंदु-योग काउंटर में पास करें;
4. आउटपुट रिपोर्ट से key_ccx, block_summaries, और qiskit_width_report फ़ील्ड एकत्र करें।

बड़ी चौड़ाइयों के लिए, --resume का उपयोग करें और --workdir निर्देशिकाओं को रखें, क्योंकि चंक और चरण चेकपॉइंट बाधित लंबी रन का समर्थन करने के लिए हैं।

उद्धरण

यदि आप अपने शोध में इस कोडबेस का उपयोग करते हैं, तो कृपया उद्धृत करें:

@misc{luo2026quantumalgorithmellipticcurve,
      title={Quantum Algorithm for Elliptic Curve Discrete Logarithms with Space-Efficient Point Addition}, 
      author={Han Luo and Ziyi Yang and Jingquan Luo and Ziruo Wang and Yuexin Su and Xiaoming Sun and Lvzhou Li and Tongyang Li},
      year={2026},
      eprint={2607.13816},
      archivePrefix={arXiv},
      primaryClass={quant-ph},
      url={https://arxiv.org/abs/2607.13816}, 
}