पिछले अध्याय में, हमने दिखाया था कि वेक्टर्स $\mathbf{a}$ और $\mathbf{G}$ के तत्वों के योग को गुणा करने पर आउटर प्रोडक्ट (outer product) के पदों का योग प्राप्त होता है, अर्थात $\sum \mathbf{a}\otimes\mathbf{G}=\sum\mathbf{a}\sum\mathbf{G}$। हमने यह भी दिखाया था कि आउटर प्रोडक्ट के मुख्य विकर्ण (main diagonal) के साथ इनर प्रोडक्ट (inner product) “निहित” होता है।

इनर प्रोडक्ट $\langle\mathbf{a},\mathbf{G}\rangle$ को “निकालने” (extract) के लिए, आउटर प्रोडक्ट से उन सभी पदों को घटाना होगा जो इनर प्रोडक्ट का हिस्सा नहीं हैं, यानी नीचे दिया गया बैंगनी रंग का छायांकित क्षेत्र:

ऐसे $\mathcal{O}(n^2)$ पद हैं, इसलिए इसे सीधे करना कुशल (efficient) नहीं है।

हालाँकि, ध्यान दें कि हम नीचे दिए गए एनीमेशन में दिखाए गए तरीके से “आउटर प्रोडक्ट को भर” सकते हैं:

ऊपर दिए गए एनीमेशन में, प्रूवर (prover) द्वारा ऑफ-डायगोनल (off-diagonal) पदों को भेजने के बाद, प्रूवर $\mathbf{G}$ और $\mathbf{a}$ दोनों को फोल्ड (fold) करता है, जिससे उनकी लंबाई आधी हो जाती है।

अंत में, जब हम $\mathbf{a}$ और $\mathbf{G}$ को $\log n$ बार फोल्ड कर लेते हैं, तो वेक्टर्स का आकार 1 हो जाता है। जब $n=1$ होता है, तो आउटर प्रोडक्ट इनर प्रोडक्ट के बराबर हो जाता है और हम केवल दोनों वेक्टर्स को प्रकट (reveal) करते हैं, जो निरंतर आकार (constant size) के होंगे।

पुनरावृत्ति (Recap) – और यह पिछले अध्याय के एल्गोरिथम से कैसे संबंधित है

पहले, हमने दिखाया था कि यह कैसे साबित किया जाए कि हम $n$ के बजाय $n/2$ तत्व भेजते हुए कमिटमेंट $P$ की ओपनिंग (opening) जानते हैं। पुनरावृत्ति के रूप में:

प्रूवर वेक्टर $\mathbf{a}$ को $P$ में $P = \langle\mathbf{a},\mathbf{G}\rangle$ के रूप में कमिट करता है। फिर प्रूवर ऑफ-डायगोनल पदों $L=a_1G_2 + a_3G_4 + \dots a_{n-1}G_n$ और $R = a_2G_1 + a_4G_3 + \dots a_nG_{n-1}$ को भेजता है। वेरिफायर (verifier) $u$ के साथ प्रतिक्रिया देता है और प्रूवर वेक्टर $\mathbf{a}$ को $u$ पर $\mathbf{a}'=\mathsf{fold}(\mathbf{a},u)=[a_1u+a_2u^{-1}, a_3u+a_4u^{-1}, \dots, a_{n-1}u+a_nu^{-1}]$ के रूप में फोल्ड करता है और $\mathbf{a}'$ वेरिफायर को भेजता है। चूँकि $\mathbf{a}'$ की लंबाई $n/2$ है, इसलिए हमने प्रेषित (transmitted) किए जाने वाले डेटा का आकार आधा कर दिया है।

वेरिफायर फिर यह जांचता है कि $\langle\mathsf{fold}(\mathbf{G},u^{-1}),\mathbf{a}'\rangle\stackrel{?}=Lu^2+P+Ru^{-2}$

इस एल्गोरिथम का मूल उद्देश्य यह साबित करना था कि हम $P$ का कमिटमेंट जानते हैं, यह दिखाकर कि हम जानते हैं कि इनर प्रोडक्ट $P$ और ऑफ-डायगोनल पदों $L$ और $R$ का योग $\mathbf{a}$ और $\mathbf{G}$ के पेयरवाइज पार्टीशन (pairwise partitions) के आउटर प्रोडक्ट के तत्वों के योग के बराबर होता है।

यदि हम इस एल्गोरिथम को पुनरावर्ती (recursively) रूप से लागू करते हैं, तो हमें इस अध्याय के शुरुआत में वर्णित $\log n$ एल्गोरिथम प्राप्त होता है।

हालाँकि, हम इस प्रक्रिया की व्याख्या इस रूप में भी कर सकते हैं कि हम साबित कर रहे हैं कि हम $n'=n/2$ लंबाई के आधार वेक्टर (basis vector) $\mathsf{fold}(\mathbf{G},u^{-1})$ के संबंध में कमिटमेंट $P'$ की ओपनिंग जानते हैं जहाँ $P'=(Lu^2+P+Ru^{-2})$ है। हम सीधे तौर पर यह साबित कर सकते हैं कि हम $\mathbf{a}'$ भेजकर $P'$ की ओपनिंग जानते हैं और वेरिफायर यह जांचता है कि $P'\stackrel{?}=\langle\mathbf{a'},\mathsf{fold}(\mathbf{G},u^{-1})\rangle$।

लेकिन $\mathbf{a}'$ भेजकर $P'$ की ओपनिंग जानने को साबित करने के बजाय, हम $n/4$ आकार का एक वेक्टर $\mathbf{a}{\prime\prime}$ भेजकर $P'$ की ओपनिंग जानने को साबित करने के लिए एल्गोरिथम को पुनरावर्ती रूप से लागू कर सकते हैं। वास्तव में, हम तब तक पुनरावृत्ति (recurse) कर सकते हैं जब तक कि $a^{\prime\dots\prime}$ का आकार $n=1$ न हो जाए।

नीचे दिया गया एनीमेशन इस बात का आभास (intuition) देता है कि क्या हो रहा है। अगला खंड एनीमेशन का विस्तार से वर्णन करता है।

इस एल्गोरिथम के काम करने के लिए, वेक्टर्स की लंबाई दो की घात (power of two) होनी चाहिए। हालाँकि, यदि लंबाई दो की घात नहीं है, तो हम वेक्टर्स में तब तक शून्य (zeros) पैड (pad) कर सकते हैं जब तक कि लंबाई दो की घात न हो जाए।

यह साबित करना कि हम $\mathcal{O}(\log n)$ डेटा के साथ $P$ की ओपनिंग जानते हैं

एल्गोरिथम

प्रूवर और वेरिफायर लंबाई $n$ के आधार वेक्टर $\mathbf{G}$ पर सहमत होते हैं। प्रूवर वेरिफायर को $P$ भेजता है जो $\langle\mathbf{a},\mathbf{G}\rangle$ है। प्रूवर वेरिफायर को यह विश्वास दिलाना चाहता है कि वे $P$ की ओपनिंग जानते हैं जबकि केवल लॉगरिदमिक आकार का डेटा भेजते हैं।

प्रूवर और वेरिफायर तब नीचे दिए गए एल्गोरिथम में संलग्न होते हैं। | के बाद के तर्कों (arguments) का अर्थ है कि वे केवल प्रूवर को ज्ञात हैं।

नीचे दिए गए एल्गोरिथम विवरण में $n$ इनपुट में वेक्टर्स की लंबाई है, जो सभी समान लंबाई के हैं।

\texttt{prove_commitments_log}(P, \mathbf{G}, | \mathbf{a})

स्थिति 1 (Case 1): $n = 1$

1. प्रूवर $a$ भेजता है और वेरिफायर जांचता है कि $aG \stackrel{?}= P$ और एल्गोरिथम समाप्त हो जाता है।

स्थिति 2 (Case 2): $n > 1$

1. प्रूवर $(L, R)$ की गणना करता है और वेरिफायर को भेजता है जहाँ
   
   $$\begin{align*} L &= a_1G_2 + a_3G_4 + \dots a_{n-1}G_n\\ R &= a_2G_1 + a_4G_3 + \dots a_nG_{n-1} \end{align*}$$
2. वेरिफायर रैंडमनेस (randomness) $u$ भेजता है
3. प्रूवर और वेरिफायर दोनों गणना करते हैं:
   
   $$\begin{align*} \mathbf{G}'&=\mathsf{fold}(\mathbf{G},u^{-1})\\ P' &= Lu^2+P+Ru^{-2} \end{align*}$$
4. प्रूवर गणना करता है
   
   $$\mathbf{a}'=\mathsf{fold}(\mathbf{a},u)$$
5. \texttt{prove_commitments_log}(P', \mathbf{G}', \mathbf{a}')

एल्गोरिथम पर टिप्पणी

प्रूवर पुनरावर्ती रूप से यह साबित कर रहा है कि, दिए गए मानों $P$ और $\mathbf{G}$ के साथ, वे $\mathbf{a}$ को जानते हैं जिससे $P=\langle\mathbf{a},\mathbf{G}\rangle$ हो। दोनों पक्ष पुनरावर्ती रूप से $\mathbf{G}$ को तब तक फोल्ड करते हैं जब तक कि यह एक बिंदु न बन जाए, और प्रूवर पुनरावर्ती रूप से $\mathbf{a}$ को तब तक फोल्ड करता है जब तक कि यह एक बिंदु न बन जाए।

प्रूवर प्रत्येक पुनरावृत्ति (iteration) पर एक निश्चित (constant) मात्रा में डेटा प्रेषित करता है, और रिकर्सन (recursion) अधिकतम $\log n$ बार चलेगा, इसलिए प्रूवर $\mathcal{O}(\log n)$ डेटा भेजता है।

हम इस बात पर जोर देते हैं कि यह एल्गोरिथम ज़ीरो नॉलेज (zero knowledge) नहीं है क्योंकि $n=1$ की स्थिति में, वेरिफायर पूरा वेक्टर जान लेता है। वेरिफायर $\mathbf{a}$ के बारे में कुछ जानने का प्रयास करने के लिए $u$ के लिए गैर-यादृच्छिक (non-random) मान भी भेज सकता है।

हालाँकि, याद रखें कि इस एल्गोरिथम के लिए हमारी प्रेरणा चेक $t_u=\langle\mathbf{l}_u,\mathbf{r}_u\rangle$ के आकार को कम करना है, और $\mathbf{l}_u$ और $\mathbf{r}_u$ शुरुआत से ही गुप्त (secret) नहीं थे।

वास्तव में, हमने यह नहीं दिखाया है कि यह कैसे साबित किया जाए कि हम लॉगरिदमिक आकार के डेटा के साथ इनर प्रोडक्ट को जानते हैं, हमने केवल यह दिखाया है कि हम लॉगरिदमिक आकार के डेटा के साथ कमिटमेंट की ओपनिंग को जानते हैं। हालाँकि, यह दिखाने के लिए कि हम दो वेक्टर्स के इनर प्रोडक्ट को जानते हैं, हमारे एल्गोरिथम को अपडेट करना सीधा (straightforward) है, जैसा कि हम इस लेख में बाद में करेंगे।

रनटाइम (Runtime)

वेरिफायर $\mathbf{G}' = \mathsf{fold}(\mathbf{G}, u^{-1})$ की गणना $\log n$ बार करता है, और पहले $\mathsf{fold}$ में $\mathcal{O}(n)$ समय लगता है। पहली नज़र में, ऐसा लगता है कि वेरिफायर का रनटाइम $\mathcal{O}(n \log n)$ है। हालाँकि, ध्यान दें कि प्रत्येक पुनरावृत्ति के साथ, $n$ आधा हो जाता है, जिसके परिणामस्वरूप रनटाइम $n + \frac{n}{2} + \frac{n}{4} + ... + 1 = 2n$ होता है, जिससे वेरिफायर के लिए कुल रनटाइम $\mathcal{O}(n)$ हो जाता है।

यह साबित करना कि हम इनर प्रोडक्ट $\langle\mathbf{a},\mathbf{b}\rangle=v$ जानते हैं

अब हम यह साबित करने के लिए उपरोक्त एल्गोरिथम को समायोजित (adjust) करते हैं कि हमने फ़ील्ड तत्वों के वेक्टर और एलिप्टिक कर्व बिंदुओं (elliptic curve points) के वेक्टर के बजाय दो स्केलर (scalar) वेक्टर्स के बीच इनर प्रोडक्ट किया है।

विशेष रूप से, हमें यह साबित करना होगा कि $P$ इनर प्रोडक्ट $\langle\mathbf{a},\mathbf{b}\rangle$ के लिए एक कमिटमेंट रखता है। यह इनर प्रोडक्ट एक स्केलर है, इसलिए हम वेक्टर कमिटमेंट के बजाय एक सामान्य पेडरसन कमिटमेंट (Pedersen commitment) करते हैं। इसके लिए हम (अज्ञात डिस्क्रीट लॉग (unknown discrete log) के साथ) एक यादृच्छिक एलिप्टिक कर्व बिंदु $Q$ का उपयोग करते हैं। इस प्रकार, $P = \langle\mathbf{a},\mathbf{b}\rangle Q$।

हालाँकि, हम बस अपने पिछले एल्गोरिथम का पुन: उपयोग नहीं कर सकते क्योंकि प्रूवर $P$ के लिए कई ओपनिंग प्रदान कर सकता है। उदाहरण के लिए, यदि $\mathbf{a} = [1,2]$ और $\mathbf{b} = [3,4]$, तो प्रूवर वेक्टर्स $\mathbf{a}' = [3,2]$ और $\mathbf{b}' = [1, 4]$ के साथ भी ओपन कर सकता है।

एक इनर प्रोडक्ट के ज्ञान का सुरक्षित (secure) प्रूफ बनाने के लिए, प्रूवर को $\mathbf{a}$ और $\mathbf{b}$ के लिए भी एक कमिटमेंट की गणना करनी होगी और उसे भेजना होगा।

इसका सीधा उपाय (naive solution) कमिटमेंट एल्गोरिथम को दो बार चलाना है। पहली दो बार यह साबित करने के लिए कि $\mathbf{a}$ और $\mathbf{b}$ को $P_1 = \langle\mathbf{a},\mathbf{G}\rangle$ और $P_2 =\langle\mathbf{b},\mathbf{H}\rangle$ में ठीक से कमिट किया गया है और तीसरी बार यह दिखाने के लिए कि $\langle\mathbf{a},\mathbf{b}\rangle Q=P_3$ की ठीक से गणना की गई थी। अगले भाग में, हम दिखाते हैं कि जब दोनों वेक्टर्स फ़ील्ड तत्व (field elements) हों तो इनर प्रोडक्ट की गणना करने के लिए अपने एल्गोरिथम को कैसे संशोधित किया जाए।

स्केलर इनर प्रोडक्ट को स्केलर-पॉइंट इनर प्रोडक्ट में बदलना

मान लीजिए $\mathbf{Q}^n$ बिंदु $Q$ की $n$ प्रतियों (copies) से युक्त एक वेक्टर है, अर्थात

इस प्रकार,

ध्यान दें कि $\langle\mathbf{a},\mathbf{b}\rangle Q$, $\langle\mathbf{a},\mathbf{b}\circ\mathbf{Q}^n\rangle$ के बराबर है।

अर्थात्, हम $\mathbf{b}$ की प्रत्येक प्रविष्टि (entry) को $Q$ से गुणा कर सकते हैं और उस वेक्टर का $\mathbf{a}$ के साथ इनर प्रोडक्ट ले सकते हैं और परिणाम $\langle\mathbf{a},\mathbf{b}\rangle Q$ के समान होगा। उदाहरण के लिए, यदि $\mathbf{a} = [1,2]$ और $\mathbf{b} = [3,4]$, तो $\langle[1,2],[3,4]\rangle Q=(1\cdot 3+2\cdot 4)Q= \langle[1,2],[3Q,4Q]\rangle=1\cdot 3Q+2\cdot 4Q=11Q$।

वहां से, हम निम्नलिखित साबित कर सकते हैं:

1. $P_1 =\langle\mathbf{a},\mathbf{G}\rangle$
2. $P_2 =\langle\mathbf{b},\mathbf{H}\rangle$
3. $P_3 =\langle\mathbf{a},\mathbf{b}\circ\mathbf{Q}\rangle$

तीन के बजाय एक प्रूफ

हम तीन कमिटमेंट्स भेजने और एल्गोरिथम को तीन बार चलाने की तुलना में बेहतर कर सकते हैं।

चूँकि $\mathbf{G}$, $\mathbf{H}$ और $Q$ बिंदुओं का अज्ञात डिस्क्रीट लॉग संबंध है, इसलिए उन्हें एक ही कमिटमेंट $P = \langle\mathbf{a},\mathbf{G}\rangle +\langle\mathbf{b},\mathbf{H}\rangle + \langle\mathbf{a},\mathbf{b}\rangle Q = P_1 + P_2 + P_3$ के रूप में जोड़ा जा सकता है।

हम अगली ट्रिक (trick) को अधिक स्पष्ट बनाने के लिए कमिटमेंट $P = \langle\mathbf{a},\mathbf{G}\rangle +\langle\mathbf{b},\mathbf{H}\rangle + \langle\mathbf{a},\mathbf{b}\rangle Q$ को $P = \langle\mathbf{a},\mathbf{G}\rangle+\langle\mathbf{a},\mathbf{b}\circ\mathbf{Q}^n\rangle +\langle\mathbf{b},\mathbf{H}\rangle$ के रूप में थोड़ा पुनर्व्यवस्थित (re-arrange) करेंगे।

तीन इनर प्रोडक्ट के बजाय इस पूरे कमिटमेंट को एक ही बार में साबित करने के लिए, ध्यान दें कि

जहाँ $\oplus$ का अर्थ वेक्टर कॉनकैटेनेशन (vector concatenation) है।

प्रभावी रूप से, हम यह साबित कर रहे हैं कि हमने एलिप्टिक कर्व वेक्टर आधार (basis) $\mathbf{G}\oplus\mathbf{Q}^n\oplus\mathbf{H}$ के लिए वेक्टर $\mathbf{a}\oplus\mathbf{a}\oplus\mathbf{b}$ को कमिट किया है।

व्यवहार में, हम वास्तव में वेक्टर्स को कॉनकैटिनेट नहीं करते हैं क्योंकि कुल लंबाई आम तौर पर दो की घात नहीं होगी। इसके बजाय, हम $\mathbf{G}$, $\mathbf{H}$, और $\mathbf{b}\circ\mathbf{Q}^n$ घटकों (components) की अलग-अलग गणना करते हैं, लेकिन $L$ और $R$ की गणना इस तरह करते हैं जैसे कि वे कॉनकैटिनेट किए गए हों।

हम नीचे दिए गए एनीमेशन में एल्गोरिथम दिखाते हैं:

एल्गोरिथम

दिए गए $v = \langle\mathbf{a},\mathbf{b}\rangle$ और कमिटमेंट $P = vQ+\langle\mathbf{a},\mathbf{G}\rangle + \langle\mathbf{b},\mathbf{H}\rangle$ के साथ हम यह साबित करना चाहते हैं कि $P$ उसी तरह कमिट किया गया है जैसा दावा किया गया है। अर्थात्, $v$, $\mathbf{a}$, और $\mathbf{b}$, $P$ में कमिट किए गए हैं और $\langle\mathbf{a},\mathbf{b}\rangle=v$ है।

\texttt{prove_commitments_log}(P, \mathbf{G}, \mathbf{H},Q, |\mathbf{a}, \mathbf{b})

स्थिति 1: $n = 1$

1. प्रूवर $(a,b)$ भेजता है और वेरिफायर जांचता है कि $P \stackrel{?}= aG + bH + abQ$। एल्गोरिथम समाप्त हो जाता है।

स्थिति 2: $n > 1$

1. प्रूवर $(L, R)$ की गणना करता है और वेरिफायर को भेजता है जो केवल एक साथ कॉनकैटिनेट किए गए सभी वेक्टर्स के ऑफ-डायगोनल पद हैं (ऊपर दिया गया एनीमेशन देखें):
   
   $$\begin{align*} L &= (a_1b_2 + a_3b_4 + \dots a_{n-1}b_n)Q+(a_1G_2 + a_3G_4 + \dots a_{n-1}G_n)+(b_2H_1 + b_4H_3 + \dots b_nH_{n-1})\\ R &= (a_2b_1 + a_4b_3 + \dots a_nb_{n-1})Q+(a_2G_1 + a_4G_3 + \dots a_nG_{n-1})+(b_1H_2 + b_3H_4 + \dots b_{n-1}H_n) \end{align*}$$
2. वेरिफायर रैंडमनेस $u$ भेजता है।
3. प्रूवर और वेरिफायर दोनों गणना करते हैं:
   
   $$\begin{align*} P' &= Lu^2+P+Ru^{-2}\\ \mathbf{G}'&=\mathsf{fold}(\mathbf{G}, u^{-1})\\ \mathbf{H}'&=\mathsf{fold}(\mathbf{H}, u)\\\\ \end{align*}$$
4. प्रूवर गणना करता है:
   
   $$\begin{align*} \mathbf{a}'&=\mathsf{fold}(\mathbf{a},u)\\ \mathbf{b}'&=\mathsf{fold}(\mathbf{b},u^{-1}) \end{align*}$$
5. \texttt{prove_commitments_log}(P', G', H', \mathbf{a}', \mathbf{b}')

निम्नलिखित अभ्यास (exercises) हमारे ZK Bulletproofs GitHub Repo में पाए जा सकते हैं:

अभ्यास 1 (Exercise 1): यह साबित करने के लिए एल्गोरिथम लागू करने हेतु नीचे दिए गए छूटे हुए कोड को भरें कि बिंदु $P$ बनाने के लिए $\mathbf{a}$ को $\mathbf{G}$ में कमिट किया गया है:

Copy
from py_ecc.bn128 import G1, multiply, add, FQ, eq, Z1
from py_ecc.bn128 import curve_order as p
import numpy as np
from functools import reduce
import random

def random_element():
    return random.randint(0, p)

def add_points(*points):
    return reduce(add, points, Z1)

# if points = G1, G2, G3, G4 and scalars = a,b,c,d vector_commit returns
# aG1 + bG2 + cG3 + dG4
def vector_commit(points, scalars):
    return reduce(add, [multiply(P, i) for P, i in zip(points, scalars)], Z1)

# these EC points have unknown discrete logs:
G_vec = [(FQ(6286155310766333871795042970372566906087502116590250812133967451320632869759), FQ(2167390362195738854837661032213065766665495464946848931705307210578191331138)),
     (FQ(6981010364086016896956769942642952706715308592529989685498391604818592148727), FQ(8391728260743032188974275148610213338920590040698592463908691408719331517047)),
     (FQ(15884001095869889564203381122824453959747209506336645297496580404216889561240), FQ(14397810633193722880623034635043699457129665948506123809325193598213289127838)),
     (FQ(6756792584920245352684519836070422133746350830019496743562729072905353421352), FQ(3439606165356845334365677247963536173939840949797525638557303009070611741415))]

# return a folded vector of length n/2 for scalars
def fold(scalar_vec, u):
    pass

# return a folded vector of length n/2 for points
def fold_points(point_vec, u):
    pass

# return (L, R)
def compute_secondary_diagonal(G_vec, a):
    pass

a = [4,2,42,420]

P = vector_commit(G_vec, a)

L1, R1 = compute_secondary_diagonal(G_vec, a)
u1 = random_element()
aprime = fold(a, u1)
Gprime = fold_points(G_vec, pow(u1, -1, p))

L2, R2 = compute_secondary_diagonal(Gprime, aprime)
u2 = random_element()
aprimeprime = fold(aprime, u2)
Gprimeprime = fold_points(Gprime, pow(u2, -1, p))

assert len(Gprimeprime) == 1 and len(aprimeprime) == 1, "final vector must be len 1"
assert eq(vector_commit(Gprimeprime, aprimeprime), add_points(multiply(L2, pow(u2, 2, p)), multiply(L1, pow(u1, 2, p)), P, multiply(R1, pow(u1, -2, p)), multiply(R2, pow(u2, -2, p)))), "invalid proof"

अभ्यास 2 (Exercise 2): उस एल्गोरिथम को लागू करने के लिए उपरोक्त कोड को संशोधित करें जो यह साबित करता है कि $P$, $\mathbf{a}$, $\mathbf{b}$ और $v$ का कमिटमेंट रखता है, और यह कि $\langle\mathbf{a},\mathbf{b}\rangle=v$ है। $\mathbf{H}$ और EC बिंदु $Q$ के लिए निम्नलिखित आधार वेक्टर (basis vector) का उपयोग करें:

Copy
H = [(FQ(13728162449721098615672844430261112538072166300311022796820929618959450231493), FQ(12153831869428634344429877091952509453770659237731690203490954547715195222919)),
    (FQ(17471368056527239558513938898018115153923978020864896155502359766132274520000), FQ(4119036649831316606545646423655922855925839689145200049841234351186746829602)),
    (FQ(8730867317615040501447514540731627986093652356953339319572790273814347116534), FQ(14893717982647482203420298569283769907955720318948910457352917488298566832491)),
    (FQ(419294495583131907906527833396935901898733653748716080944177732964425683442), FQ(14467906227467164575975695599962977164932514254303603096093942297417329342836))]

Q = (FQ(11573005146564785208103371178835230411907837176583832948426162169859927052980), FQ(895714868375763218941449355207566659176623507506487912740163487331762446439))

यह ट्यूटोरियल Bulletproof ZKP पर एक सीरीज़ का हिस्सा है।